"""
        includedBuilds << buildE

        when:
        dependency(buildA, "org.test:buildD-impl:1.0")
        dependency(buildA, "org.test:buildE-impl:1.0")

        then:
        resolveSucceeds(":build")

        assertTaskExecuted(":buildD", ":buildD-api:jar")
        assertTaskExecuted(":buildE", ":buildE-api:jar")
        assertTaskExecuted(":buildD", ":buildD-impl:jar")

        then:
        iprHasModules "buildA.iml",
            "b1/buildA-b1.iml",
            "../buildB/buildB.iml",
            "../buildB/b1/buildB-b1.iml",
            "../buildB/b2/b2.iml",
            "../buildC/buildC.iml",
            "../buildC/buildA/buildC-buildA.iml"

        imlHasDependencies "buildC-buildA", "buildA-b1", "buildB-b1"
    }

    @ToBeImplemented

        then:
        executed ":buildB:jar", ":buildB:myJar", ":buildC:jar"
        assertResolved buildB.file('build/libs/buildB-1.0.jar'), buildB.file('build/libs/buildB-1.0-my.jar'), buildC.file("build/libs/buildC-1.0.jar")
    }

    def "builds artifacts for different subprojects from the same build included via separate dependency paths"() {
        given:
        dependency 'org.test:b1:1.0'

        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'
            }

            .assertHasLineNumber(13)
        failure.assertHasDescription("build C broken")
            .assertHasFileName("Build file '${buildC.buildFile}'")
            .assertHasLineNumber(9)
    }

    @ToBeFixedForConfigurationCache(because = "build listener")
    def "fires build finished events for all builds when other builds fail"() {
        given:
        disableProblemsApiCheck()

                    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:

        execute(buildA, ":buildC:build")
    }

    @Issue("https://github.com/gradle/gradle/issues/15659")
    def "resolves dependencies of included build with dependency substitution when substitution build uses a plugin from its build-logic build"() {
        given:
        includeBuild(buildB, """
            substitute(module("org.test:b1")).using(project(":b1"))
        """)
        includeBuild(buildC)
        buildC.buildFile << """

        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']

        "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)