}

    def "reports failure for included build name that conflicts with subproject name"() {
        given:
        createDirs("buildA", "buildA/buildB")
        buildA.settingsFile << """
            include 'buildB'
"""
        includedBuilds << buildB

        when:
        fails(buildA, "help")

        then:

                buildFile << """
                    apply plugin: 'java'
"""
            }
            dependency previousBuild, "org.test:${buildName}:1.0"
            includedBuilds << build
            previousBuild = build
        }

        expect:
        execute(buildA, "jar", "--max-workers=1")
    }

    def "constructs included build artifacts in parallel"() {

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

            .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()

        when:
        fails(buildA, "buildC:broken1")

        then:
        failure.assertHasCause("Included build 'buildA' not found in build 'buildC'.")

        when:
        fails(buildA, "buildC:broken2")

        then:
        failure.assertHasCause("Included build 'buildB' not found in build 'buildC'.")
    }

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

        buildC.settingsFile << "includeBuild '../buildA'"

        then:
        execute(buildA, 'help')

        and:
        canRunFromCache(buildA, 'help')
    }

    def "nested build can include root build"() {
        when:
        buildB.settingsFile << "includeBuild '../buildC'"
        buildC.settingsFile << "includeBuild '../buildA'"

        then:
        execute(buildA, 'help')

        and:

    def "can query the included builds defined by the root build"() {
        given:
        def buildB = singleProjectBuild("buildB") {
        }
        includeBuild(buildB)
        def buildC = singleProjectBuild("buildC") {
        }
        includeBuild(buildC)
        buildA.buildFile << """
            assert gradle.includedBuild("buildB").name == "buildB"

        when:
        execute(buildA, "tasks", ["--include-build", "../pluginBuild"])

        then:
        executed ":pluginBuild:jar"
        outputContains("taskFromPluginBuild")
    }

    def "does not substitute plugin from same build into root build"() {
        disableProblemsApiCheck()
        buildA.settingsFile << """
            include "a", "b"
        """