import org.gradle.api.internal.file.TestFiles
import org.gradle.internal.Actions
import org.gradle.util.TestUtil
import spock.lang.Specification

class CopySpecMatchingTest extends Specification {

    DefaultCopySpec copySpec = new DefaultCopySpec(TestFiles.fileCollectionFactory(), TestUtil.objectFactory(), TestUtil.instantiatorFactory().decorateLenient(), TestFiles.patternSetFactory)

    def canMatchFiles() {

import java.util.Map;

import static org.gradle.api.file.FileVisitorUtil.assertVisitsPermissions;
import static org.gradle.api.internal.file.TestFiles.directoryFileTreeFactory;
import static org.gradle.api.internal.file.TestFiles.fileHasher;
import static org.gradle.api.internal.file.TestFiles.fileSystem;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.fail;

        repo.dirs('a', 'b')
        same.dirs('a', 'b')
        different.dirs('a')

        and:
        _ * fileCollectionFactory.resolving(['a', 'b']) >> TestFiles.fixed(new File('a'), new File('b'))
        _ * fileCollectionFactory.resolving(['a']) >> TestFiles.fixed(new File('a'))

        expect:
        same.descriptor.id == repo.descriptor.id
        different.descriptor.id != repo.descriptor.id

        when:

class DefaultCompositeFileTreeTest extends WorkspaceTest {

    private DefaultCompositeFileTree newCompositeFileTree(List<? extends FileTreeInternal> fileTrees) {
        new DefaultCompositeFileTree(TestFiles.taskDependencyFactory(), TestFiles.patternSetFactory, fileTrees)
    }

    def "can be empty"() {
        when:
        def ft = newCompositeFileTree([])

        then:
        ft.files.isEmpty()
    }

    JavaExecHandleBuilder builder = new JavaExecHandleBuilder(
        TestFiles.resolver(),
        TestFiles.fileCollectionFactory(),
        TestUtil.objectFactory(),
        Mock(Executor),
        new DefaultBuildCancellationToken(),
        temporaryFileProvider,
        null,
        TestFiles.execFactory().newJavaForkOptions()
    )

    @Rule
    final TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())

    def fileHasher = new AllowingHasher(TestFiles.fileHasher())
    def fileSystem = new AllowingStat(TestFiles.fileSystem())
    def updateListener = Mock(FileSystemAccess.WriteListener)
    def statisticsCollector = Mock(DirectorySnapshotterStatistics.Collector)

    def "works on real installation"() {
        when:
        def detector = new DefaultJvmMetadataDetector(
                () -> new DefaultExecHandleBuilder(TestFiles.pathToFileResolver(), Executors.newCachedThreadPool()),
                TestFiles.tmpDirTemporaryFileProvider(new File(SystemProperties.getInstance().getJavaIoTmpDir()))
        )

            visitor.visitOutputProperty("dir", TreeType.DIRECTORY, UnitOfWork.OutputFileValueSupplier.fromStatic(outputs.dir, TestFiles.fixed(outputs.dir)))
            visitor.visitOutputProperty("file", TreeType.FILE, UnitOfWork.OutputFileValueSupplier.fromStatic(outputs.file, TestFiles.fixed(outputs.file)))
        }
        _ * context.previousExecutionState >> Optional.of(previousExecutionState)

}

//go:embed testdata
var testDirAll embed.FS

func TestDir(t *testing.T) {
	all := testDirAll
	testFiles(t, all, "testdata/hello.txt", "hello, world\n")
	testFiles(t, all, "testdata/i/i18n.txt", "internationalization\n")
	testFiles(t, all, "testdata/i/j/k/k8s.txt", "kubernetes\n")
	testFiles(t, all, "testdata/ken.txt", "If a program is too slow, it must have a loop.\n")

	testDir(t, all, ".", "testdata/")

		Reason:             util.NewRSAvailableReason,
		LastUpdateTime:     testTime,
		LastTransitionTime: testTime,
	}
	replicaSetUpdated := apps.DeploymentCondition{
		Type:               apps.DeploymentProgressing,
		Status:             v1.ConditionTrue,
		Reason:             util.ReplicaSetUpdatedReason,
		LastUpdateTime:     testTime,
		LastTransitionTime: testTime,
	}

	tests := []struct {
		name            string