0 * _._
    }

    def 'visit listeners does not visit dispatch instances'() {
        def dispatch = Mock(Dispatch)
        def visitor = Mock(Action)

        given:
        broadcast.add(dispatch)

        when:
        broadcast.visitListeners(visitor)

        then:
        0 * visitor._
    }

    def 'dispatch is not used after it is removed'() {

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

        public VisitorImpl(TokenVisitor visitor) {
            this.visitor = visitor;
        }

        private void unwindTo(String element, TokenVisitor visitor) {
            if (elementStack.contains(element)) {
                while (!elementStack.getFirst().equals(element)) {
                    visitor.onEndHtmlElement(elementStack.removeFirst());
                }
                elementStack.removeFirst();

        1 * visitor.visitText('<')
        1 * visitor.visitType('OtherType')
        1 * visitor.visitText('>')
        0 * visitor._
    }

    def visitsSignatureForWildcardType() {
        TypeMetaData.SignatureVisitor visitor = Mock()
        type.setWildcard()

        when:
        type.visitSignature(visitor)

        then:
        1 * visitor.visitText('?')
        0 * visitor._
    }

    }

    @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,