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:

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

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()
    }

    }

    static ObjectFactory objectFactory() {
        return services().get(ObjectFactory)
    }

    static ObjectFactory objectFactory(TestFile baseDir) {
        def fileResolver = TestFiles.resolver(baseDir)
        def fileCollectionFactory = TestFiles.fileCollectionFactory(baseDir)
        return createServices(fileResolver, fileCollectionFactory).get(ObjectFactory)
    }

    @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/")

 * limitations under the License.
 */

package org.gradle.nativeplatform.internal.configure

import org.gradle.api.Named
import org.gradle.api.internal.file.TestFiles
import org.gradle.model.ModelMap
import org.gradle.model.internal.core.ModelPath
import org.gradle.model.internal.core.MutableModelNode
import org.gradle.model.internal.manage.instance.ManagedInstance

    }

    private DirectorySnapshotter directorySnapshotter() {
        new DirectorySnapshotter(TestFiles.fileHasher(), new StringInterner(), [], Stub(DirectorySnapshotterStatistics.Collector))
    }

    private static List<FileVisitDetails> walkFiles(rootDir) {
        def fileTree = new DirectoryFileTree(rootDir, new PatternSet(), TestFiles.fileSystem(), false)
        def visited = []
        def visitClosure = { visited << it }