}

    private void addAncestorListener(ModelListener listener) {
        if (ModelPath.ROOT.equals(listener.getAncestor())) {
            // Don't need to match on path
            addEverythingListener(listener);
            return;
        }

        ModelNodeInternal ancestor = flattened.get(listener.getAncestor());
        if (ancestor != null) {
            Deque<ModelNodeInternal> queue = new ArrayDeque<ModelNodeInternal>();

          (getAncestor() == null) ? this : getAncestor());
    }

    @Override
    public SortedSet<V> subSet(@ParametricNullness V fromElement, @ParametricNullness V toElement) {
      refreshIfEmpty();
      return new WrappedSortedSet(
          getKey(),
          getSortedSetDelegate().subSet(fromElement, toElement),
          (getAncestor() == null) ? this : getAncestor());
    }

        private final ModelPath scope;

        private NonReferenceDescendantsSpec(ModelPath scope) {
            this.scope = scope;
        }

        @Nullable
        @Override
        public ModelPath getAncestor() {
            return scope;
        }

        @Override
        public boolean matches(MutableModelNode node) {
            return !(node instanceof ModelReferenceNode);
        }
    };

          (getAncestor() == null) ? this : getAncestor());
    }

    @Override
    public SortedSet<V> subSet(@ParametricNullness V fromElement, @ParametricNullness V toElement) {
      refreshIfEmpty();
      return new WrappedSortedSet(
          getKey(),
          getSortedSetDelegate().subSet(fromElement, toElement),
          (getAncestor() == null) ? this : getAncestor());
    }

     *
     * <p>A node will be selected if its path or one of its ancestor's path equals the specified path.</p>
     */
    @Nullable
    public ModelPath getAncestor() {
        return null;
    }

        }

        @Nullable
        @Override
        public ModelPath getParent() {
            return parent;
        }

        @Nullable
        @Override
        public ModelPath getAncestor() {
            return ancestor;
        }

        @Override
        public boolean matches(MutableModelNode node) {
            return matcher.apply(node);
        }
    }

        def d = node("a.b.d")
        def e = node("a.b.c.e")
        def f = node("d")

        given:
        def listener = Mock(ModelListener) {
            matches(_) >> true
            getAncestor() >> a.path
        }
        a.addLink b
        b.addLink c

        when:
        graph.add(a)
        graph.add(b)
        graph.add(c)
        graph.addListener(listener)

        @Nullable
        public ModelPath getParent() {
            return spec.getParent();
        }

        @Override
        @Nullable
        public ModelPath getAncestor() {
            return spec.getAncestor();
        }
    }

            resultProcessor.completed(getId(testIdentifier), completeEvent());
        }
    }

    private TestStartEvent startEvent(TestIdentifier testIdentifier) {
        Object idOfClosestStartedAncestor = getAncestors(testIdentifier).stream()
            .map(TestIdentifier::getUniqueId)
            .filter(descriptorsByUniqueId::containsKey)
            .findFirst()
            .map(descriptorsByUniqueId::get)