/**
     * Visits all types in a type hierarchy in breadth-first order, super-classes first and then implemented interfaces.
     *
     * @param clazz the type of whose type hierarchy to visit.
     * @param visitor the visitor to call for each type in the hierarchy.
     */
    public static <T> void walkTypeHierarchy(Class<T> clazz, TypeVisitor<? extends T> visitor) {

    def "visits self and parent"() {
        def visitor = Mock(ClassLoaderVisitor)
        def parent = new ClassLoader(null) { }
        def classPath = [new File("a").toURI().toURL(), new File("b").toURI().toURL()]
        def cl = new VisitableURLClassLoader("test", parent, classPath)

        when:
        cl.visit(visitor)

        then:

    def fileInputFingerprint = Mock(CurrentFileCollectionFingerprint)
    def normalizer = Mock(FileNormalizer)

    def "visits properties"() {
        when:
        def result = fingerprintInputProperties { visitor ->
            visitor.visitInputProperty("input") { input }
            visitor.visitInputFileProperty(
                "file",
                NON_INCREMENTAL,

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

        def id = Stub(ComponentIdentifier)
        def visitor = Mock(ResolvedArtifactSet.Visitor)
        def artifactVisitor = Mock(ArtifactVisitor)

        when:
        set.visit(visitor)

        then:
        _ * dep.componentId >> id
        1 * visitor.prepareForVisit(_) >> FileCollectionStructureVisitor.VisitType.Visit
        1 * filter.isSatisfiedBy(id) >> false

    def change = Mock(Change)
    def visitor = Mock(ChangeVisitor)

    def "detects no change between empty current and previous"() {
        when:
        detector.visitChangesSince([:], [:], "test", visitor)
        then:
        0 * _
    }

    def "detects no change between the same one item"() {
        when:
        detector.visitChangesSince([one: 1], [one: 1], "test", visitor)
        then:

    def "formats candidates with examples"() {
        def visitor = new FormattingDiagnosticsVisitor()

        given:
        visitor.candidate("thing 1")
        visitor.candidate("thing 2").example("a")
        visitor.candidate("thing 3").example("a").example("b")

        expect:
        visitor.candidates == ["thing 1", "thing 2, for example a.", "thing 3, for example a, b."]
    }

    private final FilePropertyVisitor visitor;

    private FilePropertyVisitState(FilePropertyVisitor visitor, Map<String, InputFilePropertySpec> propertySpecsByName) {
        super(propertySpecsByName);
        this.visitor = visitor;
    }

    @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) {

        this.visitor = visitor;
    }

    @Override
    protected void preRoot() {
        visitor.preRoot(this);
    }

    @Override
    protected void postRoot() {
        visitor.postRoot();
    }

    @Override
    protected void preDirectory() {
        visitor.preDirectory(this);
    }

    @Override
    protected void preUnvisitedDirectory(DirectorySnapshot unvisited) {