e.message == 'No test for task :included-build:test declared for execution.'
    }

    def "can target specific test task and classes from included build"() {
        when:
        launchTests { TestLauncher launcher ->
            launcher.withTaskAndTestClasses(':included-build:test', ["example.IncludedTest2"])
        }
        then:
        assertTaskExecuted(":included-build:test")

            }
        """

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

    def "first included build can not see project plugins contributed to root by second included build"() {
        when:
        buildFile << """
            plugins {
                id("${build1.projectPluginId}")
            }
        """

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

class CompositeBuildIsolationIntegrationTest extends AbstractIntegrationSpec {
    def "included build can access root project sneakily"() {
        given:
        buildTestFixture.withBuildInSubDir()
        singleProjectBuild("included") {
            buildFile << """
                apply plugin: 'java'

                def rootGradleBuild = gradle

        "included build - included root"        | ":includedBuild"                      | ":includedBuild"         // Included build projects
        "included build - projectI"             | ":includedBuild:projectI"             | ":includedBuild:projectI"
        "included build - projectI/projectSubI" | ":includedBuild:projectI:projectSubI" | ":includedBuild:projectI:projectSubI"

                project(':').apply from: 'buildSrcWhenReady.gradle'
            }
        """

        file('included-build/settings.gradle') << """
            rootProject.name = 'included-build'
        """

        file('included-build/includedWhenReady.gradle') << ""
        file('included-build/build.gradle') << """
            apply plugin: AcmePlugin

            class AcmePlugin implements Plugin<Project> {

        expect:
        model.includedBuilds.size() == 1

        def included = model.includedBuilds[0]
        included.buildIdentifier.rootDir == file("child")
        included.includedBuilds.size() == 1
        included.editableBuilds.empty

        model.editableBuilds.size() == 1

        model.editableBuilds[0].is(included)

        included.includedBuilds[0].is(model)
    }

        outputContains 'sub.MyTask.doLast is running'
    }

    def "can use lifecycle service in included build"() {
        settingsFile << """
            include 'foo', 'bar'
            includeBuild 'included'
        """
        ['foo', 'bar', 'included/sub1', 'included/sub2'].each { file(it).mkdirs() }
        file('included/settings.gradle') << """
            include 'sub1', 'sub2'

            $beforeProject {

    def setup() {
        createDirs("sub", "included", "included/sub")
        settingsFile << """
            rootProject.name = 'root'
            include('sub')
            includeBuild('included')
        """
        file('included/settings.gradle') << """
            include('sub')
        """
        buildFile << """

        given:
        file("src").with {
            createFile("subdir/included.txt")
            createFile("included.txt")
        }

        file("dest").with {
            createFile("subdir/included.txt")
            createFile("subdir/extra.txt")
            createFile("included.txt")
            createFile("extra.txt")
            createDir("extra")
        }

        when:

        given:
        def buildC = singleProjectBuild("buildC")
        includeBuild(buildB)
        includeBuildAs(buildC, 'buildB')

        when:
        fails(buildA, "help")

        then:
        failure.assertHasDescription("Included build $buildC has build path :buildB which is the same as included build $buildB")
    }