when:
        buildA.buildFile << """
    task delegate {
        dependsOn gradle.includedBuild('buildB').task(':fails')
        dependsOn gradle.includedBuild('buildB').task(':succeeds')
    }
"""
        buildB.buildFile << """
    // force sequential execution
    tasks.succeeds.mustRunAfter tasks.fails
"""
        fails(buildA, ":delegate")

        then:

        given:
        applyPlugin(buildA, true, withVersion)
        addLifecycleTasks(buildA)

        includePluginBuild pluginBuild

        when:
        execute(buildA, "taskFromPluginBuild")

        then:
        executed ":pluginBuild:jar", ":taskFromPluginBuild"

        when:
        execute(buildA, "assemble")

        then:

        then:
        execute(buildA, 'help')

        and:
        canRunFromCache(buildA, 'help')
    }

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

        then:
        execute(buildA, 'help')

        and:
        canRunFromCache(buildA, 'help')

            }
        """
        includedBuilds = [empty]
        createDirs("buildA", "buildA/subproject1")
        buildA.settingsFile << """
            include('subproject1')
            $includeRootStatement
        """

        when:
        checkDependencies()

        then:
        def expectSubstitution = rootIsIncluded.contains("yes")
        checkGraph {

    @ToBeFixedForConfigurationCache
    def "builds IDE metadata artifacts in parallel"() {
        given:
        server.start()
        buildTestFixture.withBuildInSubDir()
        def buildA = singleProjectBuild("buildA") {
            buildFile << """
                apply plugin: 'java'
                apply plugin: 'idea'
            """
        }

        def included = ['buildB', 'buildC', 'buildD']

@TargetGradleVersion('>=5.6')
class CompositeProjectSubstitutionCrossVersionSpec extends ToolingApiSpecification {

    TestFile buildA
    TestFile buildB
    TestFile buildC

    def setup() {

        buildA = singleProjectBuildInRootFolder("buildA") {
            buildFile << """
                apply plugin: 'java-library'
                dependencies {

                }
            """
        }

        when:
        executer.inDirectory(buildA)
        run(":${workspaceTask}")

        then:
        def workspace = workspace(buildA, "ide")
        workspace.assertContains(project(buildA, "ide"))
        workspace.assertContains(project(buildB, "buildB"))
        workspace.assertContains(project(buildB.file("p1"), "p1"))

        then:
        execute(buildA, "help")
    }

    def "allows to rename included build that conflicts with subproject name"() {
        given:
        createDirs("buildA", "buildA/buildB")
        buildA.settingsFile << """
            include 'buildB'
        """

        when:
        includeBuildAs(buildB, "buildB-build")

        then:
        execute(buildA, "help")
    }

        """
        validationTask(buildA.buildFile, "broken", """
            assert gradle.includedBuilds.name == ["buildB", "buildC"]
            gradle.includedBuild("unknown")
        """)

        when:
        fails(buildA, "broken")

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

    def "dir name is used as build name"() {

        when:
        execute(buildA, 'a')

        then:
        assertTaskExecuted(':buildB', ':b')
        assertTaskExecuted(':buildB', ':c')
        assertTaskExecuted(':', ':a')
    }

    @Issue("https://github.com/gradle/gradle/issues/15875")
    void '#method can not reference tasks from another build'() {
        given:
        buildA.buildFile << """
            task a {