// has been changed.
	// +optional
	NestedValueValidation func(vv *NestedValueValidation) bool
}

// Visit recursively walks through the structural schema and calls the given callbacks
// at each node of those types.
func (m *Visitor) Visit(s *Structural) {
	m.visitStructural(s)
}

func (m *Visitor) visitStructural(s *Structural) bool {
	ret := false
	if m.Structural != nil {
		ret = m.Structural(s)
	}

                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 {
        visitor.visit(new FileEntry(name, file));
    }

        when:
        visitor.visitNode(rootNode)

        then:
        2 * rootNode.owner >> component
        1 * rootNode.root >> true
        1 * component.componentId >> identifier
        1 * component.metadataOrNull >> null

        and:
        visitor.allResolvedModules.empty
    }

    def 'finishes without error when visited match expected'() {
        given:

        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:

        1 * visitor.visitInputFileProperty('inputFile', _, _, _, _, _, _, InputFilePropertyType.FILE)
        1 * visitor.visitInputFileProperty('inputFiles', _, _, _, _, _, _, InputFilePropertyType.FILES)
        1 * visitor.visitInputProperty('bean', { it.call().implementationClassIdentifier == NestedBean.name }, false)
        1 * visitor.visitInputProperty('bean.nestedInput', { it.call() == 'nested' }, false)

    }

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

    @Override
    public void visit(FileVisitor visitor) {
        visitFrom(visitor, dir, RelativePath.EMPTY_ROOT, new AtomicBoolean());
    }

    /**

            builder.add(processValue(element, visitor));
        }
        return visitor.set(builder.build());
    }

    private <T> T processList(List<?> value, ValueVisitor<T> visitor) {
        if (value.isEmpty()) {
            return visitor.emptyList();
        }
        return visitor.list(processListElements(value, visitor));
    }

        @Override
        public void visit(Visitor visitor) {
            visitor.visitArtifacts(new Artifacts() {
                @Override
                public void startFinalization(BuildOperationQueue<RunnableBuildOperation> actions, boolean requireFiles) {
                    // Nothing to do
                }

                @Override
                public void visit(ArtifactVisitor visitor) {

        this(visitor, resolver, taskDependencyFactory, patternSetFactory, ProviderResolutionStrategy.REQUIRE_PRESENT, true);
    }

    public UnpackingVisitor(Consumer<FileCollectionInternal> visitor, PathToFileResolver resolver, TaskDependencyFactory taskDependencyFactory, Factory<PatternSet> patternSetFactory, ProviderResolutionStrategy providerResolutionStrategy, boolean includeBuildable) {
        this.visitor = visitor;

                }
                visitor.endChildren();
            }
        } else if (t.getCause() != null) {
            visitor.startChildren();
            visitContextual(t.getCause(), visitor);
            visitor.endChildren();
        }
    }

    private void visitContextual(Throwable t, TreeVisitor<? super Throwable> visitor) {
        Throwable next = findNearestContextual(t);