directoryDetailsHolder.push(details);
            if (directoryDetailsHolder.size() > 1 && !postfix) {
                visitor.visitDir(details);
            }
            return checkStopFlag();
        } else {
            return FileVisitResult.SKIP_SUBTREE;
        }
    }

    private FileVisitResult checkStopFlag() {
        return stopFlag.get()

    @Override
    public void visitStructure(MinimalFileTreeStructureVisitor visitor, FileTreeInternal owner) {
        visitor.visitFileTree(baseDir, getPatterns(), owner);
    }

    @Override
    public void visit(FileVisitor visitor) {
        doVisit(visitor, baseDir, new ArrayDeque<>(), 0, new AtomicBoolean());
    }

    private void doVisit(FileVisitor visitor, File file, Deque<String> pathSegments, int segmentIndex, AtomicBoolean stopFlag) {

        when:
        visitor.stopOn = rootFile2
        fileTree.visit(visitor)

        then:
        visitor.visited == [rootFile1, rootFile2]

        when:
        visitor = new TestVisitor(true)
        visitor.stopOn = dirFile1
        fileTree.visit(visitor)

        then:
        visitor.visited == [rootFile1, rootFile2, dir1, dirFile1]

        where:

    public FileTree visit(final Action<? super FileVisitDetails> visitor) {
        return visit(new FileVisitor() {
            @Override
            public void visitDir(FileVisitDetails dirDetails) {
                visitor.execute(dirDetails);
            }

            @Override
            public void visitFile(FileVisitDetails fileDetails) {
                visitor.execute(fileDetails);
            }
        });
    }

                    DetailsImpl details = new DetailsImpl(zipFile, expandedDir, entry, zip, stopFlag, chmod);
                    if (entry.isDirectory()) {
                        visitor.visitDir(details);
                    } else {
                        visitor.visitFile(details);
                    }
                }
            } catch (GradleException e) {

        List<Future<List<Long>>> results = executorService.invokeAll(callables);

        // And check that each visitor counted the complete number of lines in each file in the archive
        // (i.e. that the archive was not visited by the second visitor before the first visitor had finished fully decompressing it)
        results.forEach(f -> {
            try {

        when:
        e.accept(visitor)

        then:
        1 * visitor.visitCause(cause)
        1 * visitor.endVisiting()

        3 * visitor.startChildren()
        1 * visitor.node(childCause1)
        1 * visitor.node(childCause4)
        1 * visitor.node(childCause3)
        1 * visitor.node(childCause2)
        3 * visitor.endChildren()
        0 * visitor._

        and:

        def visitor = Mock(TaskDependencyResolveContext)
        def set1 = of([artifact1, artifact2])
        def set2 = of([artifact1])

        when:
        set1.artifacts.visitDependencies(visitor)

        then:
        1 * visitor.add(artifact1)
        1 * visitor.add(artifact2)
        0 * visitor._

        when:
        set2.artifacts.visitDependencies(visitor)

        then:

        buildOpResult.visitInputFileProperties(visitor)

        then:
        1 * visitor.preProperty(_)
        1 * visitor.preRoot(_)

        and:
        1 * visitor.preDirectory { it.path == '/foo' }

        and:
        1 * visitor.file() { it.path == '/foo/one.txt' }

        and:
        1 * visitor.preDirectory { it.path == '/foo/sub' }

        and:
        1 * visitor.file() { it.path == '/foo/sub/two.txt' }

		// delegate to visitor
		return visitor(namespace, name, kubeletVisible)
	}
}

// VisitPVSecretNames invokes the visitor function with the name of every secret
// referenced by the PV spec. If visitor returns false, visiting is short-circuited.
// Returns true if visiting completed, false if visiting was short-circuited.
func VisitPVSecretNames(pv *corev1.PersistentVolume, visitor Visitor) bool {
	visitor = skipEmptyNames(visitor)