def moduleA = allProjects.rootIdeaProject.modules[0]
        moduleA.dependencies.each {
            assert it instanceof  IdeaModuleDependency
        }
        moduleA.dependencies.collect { it.targetModuleName } == ['buildB-b1', 'buildA-buildC', 'buildD-b1']

        allProjects.getIdeaProject('buildB').modules.collect { it.name } == ['buildB', 'buildB-b1', 'b2']

        given:
        buildB
        def buildC = multiProjectBuild("buildC", ['c1', 'c2']);
        createDirs("buildC", "buildC/nested", "buildC/nested/c1")
        buildC.settingsFile << """
            include ':nested:c1'
        """
        buildC.buildFile << """
            allprojects {
                apply plugin: 'java'
            }

                    classpath 'org.test:buildC:1.0'
                }
            }
        """)
        buildA.buildFile << registration("buildA")
        dependency buildB, "org.test:buildC:1.0"
        buildB.buildFile << registration("buildB")

        when:
        execute(buildA, ":jar")

        then:
        executed ":buildB:jar", ":buildC:jar"

        and:

        def workspace = eclipseWorkspace([project("buildA", buildA),
                                          project("buildB", buildB),
                                          project("buildC", buildC, false),
                                          project("b1", buildB.file("b1")),
                                          project("b2", buildB.file("b2"))])

        when:
        withConnection { connection ->

        buildB.rootProject.name == "buildB"
        buildB.projects.size() == 4
        buildB.includedBuilds.size() == 1

        def buildC = buildB.includedBuilds[0]
        buildC.buildIdentifier.rootDir == buildCDir
        buildC.rootProject.name == "buildC"
        buildC.projects.size() == 1
        buildC.includedBuilds.empty
    }

    @TargetGradleVersion(">=4.10")

        def moduleA = originalResult.rootIdeaProject.modules[0]
        moduleA.dependencies.each {
            assert it instanceof IdeaModuleDependency
        }
        moduleA.dependencies.targetModuleName == ['buildB-b1', 'buildA-buildC', 'buildD-b1']

        originalResult.getIdeaProject('buildB').modules.name == ['buildB', 'buildB-b1', 'b2']
        originalResult.getIdeaProject('buildC').modules.name == ['buildA-buildC']

                assert !components[1].build.currentBuild
                assert components[1].projectPath == ':'
                assert components[1].projectName == 'buildB'
                assert components[1].buildTreePath == ':buildB'
                assert components[2].build.buildPath == ':${buildName}'
                assert components[2].build.name == '${buildName}'
                assert !components[2].build.currentBuild

        "rootProject.name='someLib'" | "buildB"  | "someLib"      | "configured root project name"
    }

    def "project component identifiers know if projects belong to the current build or not"() {
        def buildC = singleProjectBuild('buildC') {
            buildFile << "apply plugin: 'java'"
        }
        includeBuild(buildC)

        buildA.buildFile << """
            dependencies {

            assertConfirmationCount(build1)
            assertConfirmationCount(build2)
            assertConfirmationCount(build3)
        }
        replaceSocketReceiver { additionalRequests++ }

        then:
        waitCloseAndFinish(build1)
        build2.waitForFinish()
        build3.waitForFinish()
        assertConfirmationCount(build1)
        assertConfirmationCount(build2)
        assertConfirmationCount(build3)

### Build tree state

"Build tree" is another name for the build definition.
The "build tree state" holds the state for the entire build definition for a single build execution within a session.

The build tree state is managed by the `BuildTreeState` class.
An instance is created at the start of a build execution and discarded at the end of the execution.

### Build state