1 * spec.isSatisfiedBy(excluded) >> false
        1 * source.visit(_) >> { FileVisitor nestedVisitor ->
            nestedVisitor.visitFile(included)
            nestedVisitor.visitFile(excluded)
        }
        1 * visitor.visitFile(included)
        0 * _
    }

    def "visits structure when backed by a directory tree"() {
        def dir = new File("dir")

        def fileTree = new DirectoryFileTree(rootDir, new PatternSet(), TestFiles.fileSystem(), false)
        def visited = []
        def visitClosure = { visited << it }
        def fileVisitor = [visitFile: visitClosure, visitDir: visitClosure, isReproducibleFileOrder: { isReproducible }] as ReproducibleFileVisitor
        fileTree.visit(fileVisitor)
        visited
    }

                    visitor.visitDir(dirDetails);
                }
            }

            @Override
            public void visitFile(FileVisitDetails fileDetails) {
                if (spec.isSatisfiedBy(fileDetails)) {
                    visitor.visitFile(fileDetails);
                }
            }
        });
    }

        def fileTree = new GeneratedSingletonFileTree({ tmpDir }, "file.bin", generationListener, contentWriter, fileSystem)

        when:
        fileTree.visit(visitor)

        then:
        1 * visitor.visitFile(_) >> { FileVisitDetails details ->
            assert details.path == "file.bin"
            assert !generatedFile.exists()
            assert details.file == generatedFile
            assert generatedFile.text == "contents!"

    private FileVisitResult checkStopFlag() {
        return stopFlag.get()
            ? FileVisitResult.TERMINATE
            : FileVisitResult.CONTINUE;
    }

    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
        FileVisitDetails details = getFileVisitDetails(file, attrs);
        if (shouldVisit(details)) {
            if (attrs.isSymbolicLink()) {

        public void processFile(FileCopyDetailsInternal details) {
            if (details.isDirectory()) {
                visitDir(details);
            } else {
                visitFile(details);
            }
        }

        private void visitFile(FileCopyDetails fileDetails) {
            try {
                TarArchiveEntry archiveEntry = new TarArchiveEntry(fileDetails.getRelativePath().getPathString());

            if (fileMetadata.getType() == FileType.RegularFile) {
                visitFile(file, prefix + file.getName(), visitor);
            } else if (fileMetadata.getType() == FileType.Directory) {
                visitDir(file, prefix + file.getName() + "/", visitor);
            }
        }
    }

    private void visitFile(File file, String name, ClasspathEntryVisitor visitor) throws IOException {

     */
    void visitDir(FileVisitDetails dirDetails);

    /**
     * Visits a file.
     *
     * @param fileDetails Meta-info about the file.
     */
    void visitFile(FileVisitDetails fileDetails);

    @Override
    public FileCollectionStructureVisitor.VisitType prepareForVisit(FileCollectionInternal.Source source) {
        return visitor.prepareForVisit(source);
    }

    @Override
    public void visitFile(File file) {
        files.add(file);
    }

    @Override
    public void visitFailure(Throwable failure) {
        failures.add(failure);
    }

    @Override

                    CollectingMacroLookup visibleMacros = new CollectingMacroLookup(initialIncludeDirectives);
                    FileVisitResult result = visitFile(sourceFile, fileContent, visibleMacros, new HashSet<HashCode>(), existingHeaders);
                    Set<IncludeFileEdge> includedFiles = new LinkedHashSet<IncludeFileEdge>();