if (expression.getType() == IncludeType.SYSTEM) {
            visitor.visitSystem(expression);
        } else if (expression.getType() == IncludeType.QUOTED) {
            visitor.visitQuoted(expression);
        } else if (expression.getType() == IncludeType.IDENTIFIER) {
            visitor.visitIdentifier(expression);

            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));
    }

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

        when:
        set2.artifacts.visitDependencies(visitor)

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

    ResolvedVariant of(List<ResolvableArtifact> artifacts) {

    }

    @Override
    public void visit(Visitor visitor) {
        visitor.visitArtifacts(this);
    }

    @Override
    public void visitTransformSources(TransformSourceVisitor visitor) {
        throw UncheckedException.throwAsUncheckedException(failure);
    }

    @Override
    public void visitExternalArtifacts(Action<ResolvableArtifact> visitor) {

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

        public void visit(IdeDependencyVisitor visitor) {
            resolvePlusConfigurations(visitor);
            resolveMinusConfigurations(visitor);
            resolveAuxiliaryArtifacts(visitor);
            visitArtifacts(visitor);
            visitUnresolvedDependencies(visitor);
        }

        private void resolvePlusConfigurations(IdeDependencyVisitor 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