}
            plugins {
                id("${build2.settingsPluginId}")
            }
            rootProject.name = "${build1.buildName}"
        """)

        then:
        succeeds()
        build2.assertSettingsPluginApplied()
        build1.assertSettingsPluginApplied()
    }

    def "second included build can not see settings plugins contributed to root by first included build"() {

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

        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 {
                $method gradle.includedBuild('buildB').task(':b')

            """
        }
        dependency(buildB, "org.test:c1")
        dependency(buildB, "org.test:c2:1.0")
        dependency(new BuildTestFile(buildB.file('c3'), 'c3'), "org.test:buildB") // dependency to root

        buildB.settingsFile << """
            includeBuild('${buildA.toURI()}') // include another build to become a composite
        """

        when:
        fails(buildB, "c3:jar")

        then:

import org.gradle.integtests.fixtures.build.BuildTestFile

/**
 * Tests for resolving dependency artifacts with substitution within a composite build.
 */
class CompositeBuildDetectionIntegrationTest extends AbstractCompositeBuildIntegrationTest {
    BuildTestFile buildB

    def setup() {
        dependency('org.test:buildB:1.0')
        buildB = singleProjectBuild("buildB") {
            buildFile << """

        """

        when:
        fails(buildA, "assemble")

        then:
        result.assertTaskExecuted(":buildB:broken")
        failure.assertHasFailures(1)
        failure.assertHasDescription("Execution failed for task ':buildB:broken'.")
    }

    def "does not compile build script when build script classpath cannot be built"() {
        given:
        buildB.file("src/main/java/B.java") << """
            broken!

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

        task build1(type:BuildSrcTask) {
            doLast {
                ${server.callFromBuild('build1')}
            }
        }

        task build2(type:BuildSrcTask) {
            doLast {
                ${server.callFromBuild('build2')}
            }
        }
        """

        server.expectConcurrent("build1", "build2")

        when:

/**
 * Dependency substitution is performed for models in a composite build
 */
@TargetGradleVersion(">=3.1")
class AdHocCompositeDependencySubstitutionCrossVersionSpec extends ToolingApiSpecification implements WithOldConfigurationsSupport {
    TestFile buildA
    TestFile buildB

    def setup() {

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

        // Block until second build has produced blue things
        def build2 = executer.withTasks("redThings", "blueThings", "block2").start()
        block2.waitForAllPendingCalls()

        // Finish up first build while second build is still running
        block1.releaseAll()
        def result1 = build1.waitForFinish()

        block2.releaseAll()
        def result2 = build2.waitForFinish()

        then: