import static org.gradle.model.internal.core.ModelNodes.withType;

abstract class ModelNodeInternal implements MutableModelNode {
    protected final ModelRegistryInternal modelRegistry;
    private final ModelPath path;
    private final ModelRuleDescriptor descriptor;

    private Set<ModelNodeInternal> dependencies;
    private Set<ModelNodeInternal> dependents;
    private ModelNode.State state = ModelNode.State.Registered;

            return;
        }

        ModelNodeInternal ancestor = flattened.get(listener.getAncestor());
        if (ancestor != null) {
            Deque<ModelNodeInternal> queue = new ArrayDeque<ModelNodeInternal>();
            queue.add(ancestor);
            while (!queue.isEmpty()) {
                ModelNodeInternal parent = queue.removeFirst();
                for (ModelNodeInternal node : parent.getLinks()) {

        }

        public void removeNode(ModelNodeInternal node) {
            predicatesForPath(node.getPath()).remove();
        }
    }

    private class ScopeIndex {
        final Map<ModelType<?>, PredicateMatches> types = new LinkedHashMap<>();
        final List<ModelNodeInternal> nodes = new ArrayList<>();

        public void addNode(ModelNodeInternal node) {
            nodes.add(node);

            ));
        }

        doOnBind(node);
    }

    protected void doOnBind(ModelNodeInternal node) {
        // Do nothing by default
    }

    public void onUnbind(ModelNodeInternal node) {
        if (node == boundTo) {
            boundTo = null;
        }
    }

    @Override
    public void remove(ModelPath path) {
        ModelNodeInternal node = modelGraph.find(path);
        if (node == null) {
            return;
        }

        List<ModelNodeInternal> nodesToRemove = new ArrayList<>();
        ensureCanRemove(node, nodesToRemove);
        Collections.reverse(nodesToRemove);

        for (ModelNodeInternal nodeToRemove : nodesToRemove) {

    }

    @Override
    @Nullable
    public ModelNodeInternal getLink(String name) {
        return links == null ? null : links.get(name);
    }

    @Override
    public Iterable<? extends ModelNodeInternal> getLinks() {
        return links == null ? Collections.<ModelNodeInternal>emptyList() : links.values();
    }

    @Override

    ExtractedRuleSource<?> newRuleSource(Class<? extends RuleSource> rules);

    void registerNode(ModelNodeInternal node, Multimap<ModelActionRole, ? extends ModelAction> actions);

    <T> void bind(ModelReference<T> subject, ModelActionRole role, ModelAction mutator);

    void transition(ModelNodeInternal node, ModelNode.State desired, boolean laterOk);

    }

    @Nullable
    @Override
    public ModelNodeInternal getLink(String name) {
        return target == null ? null : target.getLink(name);
    }

    @Override
    public Iterable<? extends ModelNodeInternal> getLinks() {
        return target == null ? Collections.<ModelNodeInternal>emptyList() : target.getLinks();
    }

    @Override

        TestNode(ModelRegistration registration) {
            super(null, registration)
        }

        @Override
        Iterable<? extends ModelNodeInternal> getLinks() {
            return links
        }

        ModelNodeInternal addLink(ModelNodeInternal node) {
            links << node
            return node
        }

        @Override

        new TestNode(registration).getExecutedRules().size() == 0
    }

    def "should record executed rules when notify fired #fireCount time(s)"() {
        def descriptor = Mock(ModelRuleDescriptor)
        ModelNodeInternal modelNode = new TestNode(registration)
        def executionBinder = Mock(RuleBinder)
        executionBinder.isBound() >> true
        executionBinder.getInputBindings() >> []