}
        List<DependentBinariesResolvedResult> children = new ArrayList<>();
        for (Collection<DependentBinariesResolvedResult> childResults : index.asMap().values()) {
            children.add(mergeResults(childResults));
        }
        return new DefaultDependentBinariesResolvedResult(first.getId(), first.getProjectScopedName(), !hasNotBuildables, hasTestSuites, children);
    }

        project.targets.size() == 2
        assertTargetIsTool(project.targets[0], 'App')
        project.targets[1].assertIsIndexerFor(project.targets[0])

        project.products.children.size() == 1
        project.products.children[0].path == exe("build/install/main/debug/lib/App").absolutePath

        rootXcodeProject.schemeFiles.size() == 1

        }

        when:
        EclipseProject project = loadToolingModel(EclipseProject)
        EclipseProject projectA = project.children[0]
        EclipseProject projectB = project.children[1]
        EclipseProject projectC = project.children[2]
        EclipseProject projectD = project.children[3]

        then:
        projectA.classpath.collect { it.file.name } as Set == [ 'commons-lang3-3.9.jar' ] as Set

        return parent;
    }

    @Override
    public Set<ProjectDescriptor> getChildren() {
        return Cast.uncheckedCast(children);
    }

    public Set<? extends DefaultProjectDescriptor> children() {
        return children;
    }

    @Override
    public String getPath() {
        return path.toString();
    }

    void setPath(Path path) {

		} else if summary.Parent != nil {
			t.Errorf("unexpected parent %d for task %d", summary.Parent.ID, id)
		}

		// Check children.
		gotChildren := make(map[trace.TaskID]struct{})
		for _, child := range summary.Children {
			gotChildren[child.ID] = struct{}{}
		}
		for _, wantChild := range want.children {
			if _, ok := gotChildren[wantChild]; ok {
				delete(gotChildren, wantChild)
			} else {

        when:
        EclipseProject rootProject = loadToolingModel(EclipseProject)
        EclipseProject subprojectA = rootProject.children.find { it.name == 'subproject-a' }
        EclipseProject subprojectB = rootProject.children.find { it.name == 'subproject-b' }
        EclipseProject subprojectC = rootProject.children.find { it.name == 'subproject-c' }

        then:

        project.targets.size() == 2
        assertTargetIsTool(project.targets[0], 'App', 'app')
        project.targets[1].assertIsIndexerFor(project.targets[0])

        project.products.children.size() == 1
        project.products.children[0].path == exe("build/install/main/debug/lib/app").absolutePath
    }

    @ToBeFixedForConfigurationCache
    def "can create xcode project for C++ application with multiple architecture"() {

        0 * _

        when:
        invalidate(rootDirSnapshot.children[0])
        invalidate(rootDirSnapshot.children[1])
        then:
        0 * _

        when:
        invalidate(rootDirSnapshot.children[2])
        then:
        1 * watcher.stopWatching({ equalIgnoringOrder(it, [rootDir]) })

        renderChildren(getChildren(root));
    }

    private void renderChildren(Set<? extends RenderableDependency> children) {
        renderer.startChildren();
        int idx = 0;
        for (RenderableDependency child : children) {
            boolean last = idx++ == children.size() - 1;
            doRender(child, last);
        }
        renderer.completeChildren();
    }

    }

    private static List<String> visitCycle(
            Map<String, Set<String>> graph,
            Collection<String> children,
            Map<String, DfsState> stateMap,
            LinkedList<String> cycle) {
        if (children != null) {
            for (String v : children) {
                DfsState state = stateMap.putIfAbsent(v, DfsState.VISITING);
                if (state == null) {