}

    public void visitsSelfAndParents() {
        def visitor = Mock(ClassLoaderVisitor)

        when:
        loader.visit(visitor)

        then:
        1 * visitor.visitSpec({it instanceof MultiParentClassLoader.Spec})
        1 * visitor.visitParent(parent1)
        1 * visitor.visitParent(parent2)
        0 * visitor._
    }

    def "hash code is identity based"() {
        given:

                return parser.parseNotation(notation);
            }

            @Override
            public void describe(DiagnosticsVisitor visitor) {
                parser.describe(visitor);
            }
        };
    }

    @Nonnull
    @Override
    public CapabilityNotationParser create() {

        return BUILDER;
    }

    static class MapConverter extends MapNotationConverter<ComponentSelector> {
        @Override
        public void describe(DiagnosticsVisitor visitor) {
            visitor.example("Maps, e.g. [group: 'org.gradle', name:'gradle-core', version: '1.0'].");
        }

        }

        @Override
        public Visitor getAll(Class<?> serviceType, final Visitor visitor) {
            super.getAll(serviceType, visitor);
            if (decorates == null) {
                return visitor;
            } else {
                return new Visitor() {
                    @Override
                    public void visit(Service service) {

        ClassDependenciesVisitor visitor = new ClassDependenciesVisitor(new ClassRelevancyFilter(className), reader, interner);
        reader.accept(visitor, ClassReader.SKIP_FRAMES);

        // Remove the "API accessible" types from the "privately used types"
        visitor.privateTypes.removeAll(visitor.accessibleTypes);
        String name = visitor.moduleName != null ? visitor.moduleName : className;

            return EmptySchema.INSTANCE;
        }

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

        @Override
        public void visitTransformSources(TransformSourceVisitor visitor) {
            // Should not be called
            throw new UnsupportedOperationException();
        }

        @Override

        this.executable = executable;
    }

    @Override
    public boolean accept(ChangeVisitor visitor) {
        if (!currentImplementation.getClassIdentifier().equals(previousImplementation.getClassIdentifier())) {
            return visitor.visitChange(new DescriptiveChange("The type of %s has changed from '%s' to '%s'.",

    def collectingVisitor = new CollectingChangeVisitor()
    def visitor = new LimitingChangeVisitor(2, collectingVisitor)

    def "will not accept more changes than specified"() {
        def change1 = Mock(Change)
        def change2 = Mock(Change)

        expect:
        visitor.visitChange(change1)
        !visitor.visitChange(change2)
        collectingVisitor.changes == [change1, change2]
    }

 */

package org.gradle.internal.execution.history.changes;

public interface ChangeContainer {
    /**
     * Propagate changes to the visitor.
     *
     * @return Whether the visitor still wants to obtain more changes.
     */
    boolean accept(ChangeVisitor visitor);

        }

        @Override
        public boolean accept(String propertyName, ChangeVisitor visitor) {
            return inputFileChangesDelegate.accept(propertyName, visitor);
        }

        @Override
        public boolean accept(ChangeVisitor visitor) {
            return changeContainerDelegate.accept(visitor);
        }
    }