}

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

        workspace.assertContains(project(buildA, "ide"))
        workspace.assertContains(project(buildB, "buildB"))
        workspace.assertContains(project(buildB.file("p1"), "p1"))
        workspace.assertContains(project(buildB.file("p2"), "p2"))
    }

    @ToBeFixedForConfigurationCache(because = "ide plugins")
    def "workspace includes projects from nested included builds"() {

        def moduleA = allProjects.rootIdeaProject.modules[0]
        moduleA.dependencies.each {
            assert it instanceof  IdeaModuleDependency
        }
        moduleA.dependencies.collect { it.targetModuleName } == ['buildB-b1', 'buildA-buildC', 'buildD-b1']

        allProjects.getIdeaProject('buildB').modules.collect { it.name } == ['buildB', 'buildB-b1', 'b2']

    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"

        }

        buildD = singleProjectBuild('buildD') {
            buildFile << javaProject()
            file('src/test/java/SampleTestD.java') << junitTestClass('SampleTestD')
        }
    }

    def "can collect build failures from multiple included builds"() {
        when:
        includedBuilds << buildB << buildC << buildD

        buildA.buildFile << """
            task testAll {

        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'.")
    }

        output.count('Configured buildB') == 1
    }

    def "configures included build only once when building multiple artifacts for a dependency of a referenced task"() {
        given:
        includeBuild buildB
        includeBuild buildC

        dependency buildC, "org.test:buildB:1.0"
        dependency buildC, "org.test:b1:1.0"

        when:
        buildA.buildFile << """
task run {

        def workspace = eclipseWorkspace([project("buildA", buildA),
                                          project("buildB", buildB),
                                          project("buildC", buildC, false),
                                          project("b1", buildB.file("b1")),
                                          project("b2", buildB.file("b2"))])

        when:
        withConnection { connection ->

        assertResolved buildB.file('b1/build/libs/b1-1.0.jar')

        configured("buildB") == 1
    }

    def "included build references substituted dependency from preceding included build"() {
        dependency 'org.test:buildC:1.0'
        configurationTimeDependency buildC, 'org.test:buildB:1.0'

        when:
        execute buildA, ":help"

        then:
        executed ":help"

        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: