is GeneratedSingletonFileTree -> GeneratedTreeSpec(tree.toSpec())
        is DirectoryFileTree -> DirectoryTreeSpec(tree.dir, tree.patternSet)
        else -> null
    }

    private
    fun cannotCreateSpecFor(tree: MinimalFileTree): Nothing =
        throw UnsupportedOperationException("Cannot create spec for file tree '$tree' of type '${tree.javaClass}'.")

    FileTreeInternal treeOf(List<? extends FileTreeInternal> fileTrees);

    FileTreeInternal treeOf(MinimalFileTree tree);

    static FileTreeInternal emptyTree() {
        return EmptyFileTree.INSTANCE;
    }

    static FileTreeInternal emptyTree(String displayName) {
        if (FileTreeInternal.DEFAULT_TREE_DISPLAY_NAME.equals(displayName)) {
            return emptyTree();
        } else {

            return new DefaultCompositeFileTree(taskDependencyFactory, patternSetFactory, ImmutableList.copyOf(fileTrees));
        }
    }

    @Override
    public FileTreeInternal treeOf(MinimalFileTree tree) {
        return new FileTreeAdapter(tree, listener, taskDependencyFactory, patternSetFactory);
    }

    @Override
    public FileCollectionInternal create(TaskDependency builtBy, MinimalFileSet contents) {

    }

    def 'constructs empty tree when composite tree created with empty list'() {
        def tree = factory.treeOf([])

        expect:
        emptyTree(tree)
    }

    def 'returns source file tree when composite tree created with single entry'() {
        def source = Stub(FileTreeInternal)
        def tree = factory.treeOf([source])

        expect:
        tree.is source
    }

        Map<File, DirectoryTree> trees = new LinkedHashMap<>();
        for (DirectoryTree tree : getSourceTrees()) {
            if (!trees.containsKey(tree.getDir())) {
                trees.put(tree.getDir(), tree);
            }
        }
        return new LinkedHashSet<>(trees.values());
    }

    protected Set<DirectoryFileTree> getSourceTrees() {

            walk(copySpecResolver -> builder.add(Cast.<FileTreeInternal>uncheckedCast(copySpecResolver.getSource())));
            return fileCollectionFactory.treeOf(builder.build());
        }

        @Override
        public Collection<? extends Action<? super FileCopyDetails>> getAllCopyActions() {
            if (parentResolver == null) {
                return copyActions;

    def "can add file trees together"() {
        File file1 = new File("f1")
        File file2 = new File("f2")
        FileVisitDetails fileVisitDetails1 = fileVisitDetails(file1)
        FileVisitDetails fileVisitDetails2 = fileVisitDetails(file2)
        def tree1 = new TestFileTree([fileVisitDetails1])
        def tree2 = new TestFileTree([fileVisitDetails2])

        when:
        FileTree sum = tree1.plus(tree2)

        then:

// limitations under the License.

/*
tree.go contains functions for traversing and updating a tree constructed from yaml or json.Unmarshal.
Nodes in such trees have the form map[interface{}]interface{} or map[interface{}][]interface{}.
For some tree updates, like delete or append, it's necessary to have access to the parent node. PathContext is a

        visited.toSet() == [a1, b1].toSet()
    }

    def "dependencies are union of dependencies of source trees"() {
        def task1 = Stub(Task)
        def task2 = Stub(Task)
        def task3 = Stub(Task)
        def tree1 = Stub(FileTreeInternal)
        def tree2 = Stub(FileTreeInternal)

        given:
        tree1.visitDependencies(_) >> { TaskDependencyResolveContext context ->
            context.add(task1)

    }

    def "can view directory as a file tree"() {
        given:
        def dir1 = baseDir.createDir("dir1")
        def file1 = dir1.createFile("sub-dir/file1")
        def file2 = dir1.createFile("file2")
        def dir2 = baseDir.createDir("dir2")
        def file3 = dir2.createFile("other/file3")

        expect:
        def tree1 = baseDirectory.asFileTree
        tree1.files == [file1, file2, file3] as Set

        and: