public:
    explicit IncrementStackDepth(PredicateFactory* parent) : parent_(parent) {
      parent_->stack_depth_++;
    }

    bool HasOverflowed() const {
      const int kMaxStackDepth = 8;
      return parent_->stack_depth_ >= kMaxStackDepth;
    }

    ~IncrementStackDepth() { parent_->stack_depth_--; }

   private:
    PredicateFactory* parent_;
  };

  // A cache for the MakeNotPredicate function.

        DefaultResolvedDependency parent1 = new DefaultResolvedDependency("p1", newId("someGroup", "someChild", "someVersion"), buildOperationProcessor)
        parent1.addChild(resolvedDependency)

        DefaultResolvedDependency parent2 = new DefaultResolvedDependency("p2", newId("someGroup", "someChild", "someVersion"), buildOperationProcessor)
        parent2.addChild(resolvedDependency)

        def parent1 = Mock(ParentServices)
        def parent2 = Mock(ParentServices)
        def registry = new DefaultServiceRegistry(registry(parent1), registry(parent2))

        when:
        def result = registry.get(BigDecimal)

        then:
        result == value

        and:
        1 * parent1.get(BigDecimal) >> null
        1 * parent2.get(BigDecimal) >> value
    }

    <modelVersion>4.0.0</modelVersion>

    <groupId>org.apache.maven.its</groupId>
    <artifactId>parent</artifactId>
    <version>0.1</version>
    <packaging>pom</packaging>

    <name>Maven Integration Test :: Dummy Parent</name>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>

        parent1.hasPackaging('pom')
        parent1.publish()

        def parent2 = mavenRepo.module("org", "parent2", "1.0")
        parent2.hasPackaging('pom')
        parent2.publish()

        buildFile << """
            repositories {
                maven {
                    url = uri('$blockingServer.uri')
                    $authConfig
                }
            }

        collectOwnStrictVersions(parent1, ['b', 'c'])
        collectOwnStrictVersions(parent2, ['b', 'd'])

        def child = nextNode()
        def edge1 = edge(parent1, false, null, child)
        def edge2 = edge(parent2, false, null, child)
        parent1.collectAncestorsStrictVersions([parent1Edge])
        parent2.collectAncestorsStrictVersions([parent2Edge])

    }

    public MultiParentClassLoader(ClassLoader... parents) {
        this(Arrays.asList(parents));
    }

    public MultiParentClassLoader(Collection<? extends ClassLoader> parents) {
        super(null);
        this.parents = new CopyOnWriteArrayList<ClassLoader>(parents);
    }

    public void addParent(ClassLoader parent) {
        parents.add(parent);
    }

    public List<ClassLoader> getParents() {

            is KtWhenCondition ->
                doesParentUseChild(parent.parent, parent)

            // Type parameters, return types and other annotations are all contained in KtUserType,
            // and are never considered used as expressions
            is KtUserType ->
                false

        if (spec instanceof SystemClassLoaderSpec) {
            return rootClassLoader;
        }
        if (spec instanceof MultiParentClassLoader.Spec) {
            return new MultiParentClassLoader(parents);
        }
        if (parents.size() != 1) {
            throw new IllegalArgumentException("Expected a single parent.");
        }
        ClassLoader parent = parents.get(0);

    }

    private ResolvedArtifactSet getArtifactsForIncomingEdge(DependencyGraphNodeResult parent) {
        if (!parents.contains(parent)) {
            throw new InvalidUserDataException("Provided dependency (" + parent + ") must be a parent of: " + this);
        }
        return CompositeResolvedArtifactSet.of(parentArtifacts.get((ResolvedDependency) parent));
    }

    @Override