includeBuild('included')
        """
        buildFile << """
            task doIt {
                dependsOn gradle.includedBuild("included").task(":doIt")
                doLast {
                    println "Hello from root"
                }
            }
        """
        file("included/settings.gradle") << """
            rootProject.name = "included"
        """

     */
    void finalizeIncludedBuilds();

    /**
     * Creates an included build. An included build is-a nested build whose projects and outputs are treated as part of the composite build.
     */
    IncludedBuildState addIncludedBuild(BuildDefinition buildDefinition);

    /**
     * Creates an included build. An included build is-a nested build whose projects and outputs are treated as part of the composite build.
     *

        then:
        failure.assertHasDescription("A problem occurred evaluating root project 'buildA'.")
        failure.assertHasCause("Included build 'does-not-exist' not found in build 'buildA'.")
    }

    def "reports failure when task does not exist for included build"() {
        when:
        buildA.buildFile << """
    task delegate {
        dependsOn gradle.includedBuild('buildB').task(':does-not-exist')

            gradle.includedBuild("buildB")
        """)

        when:
        fails(buildA, "broken")

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

    def "included builds added from command-line are visible to root build"() {
        given:
        def buildB = singleProjectBuild("buildB") {
        }

        }

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

    def "constructs included build artifacts in parallel"() {
        given:
        server.start()

        when:
        def included = ['buildB', 'buildC', 'buildD']
        included.each { buildName ->
            def build = singleProjectBuild(buildName) {
                buildFile << """

== Declaring the dependencies substituted by an included build

By default, Gradle will configure each included build in order to determine the dependencies it can provide. The algorithm for doing this is very simple: Gradle will inspect the `group` and `name` for the projects in the included build, and substitute project dependencies for any matching external dependency.

        }
        includeBuild(buildB)

        when:
        fails(buildA, "help")

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

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

 */

package org.gradle.integtests.composite

class CompositeBuildNestedBuildLookupIntegrationTest extends AbstractCompositeBuildValidationIntegrationTest {
    def "can query the included builds defined by an included build"() {
        given:
        def buildC = singleProjectBuild("buildC") {
        }
        def buildB = singleProjectBuild("buildB") {
            settingsFile << """

public interface BuildIncluder {
    /**
     * Registers an included build of the current build. An included build may provide plugins and libraries to this build and all other builds in the tree.
     */
    CompositeBuildParticipantBuildState includeBuild(IncludedBuildSpec includedBuildSpec);

    /**

        includedBuilds << buildC
    }

    def "two included builds can include each other"() {
        when:
        buildB.settingsFile << "includeBuild '../buildC'"
        buildC.settingsFile << "includeBuild '../buildB'"

        then:
        execute(buildA, 'help')

        and:
        canRunFromCache(buildA, 'help')
    }

    def "included build can include root build"() {
        when: