}

    def "reports task dependencies for tasks in included builds"() {
        given:
        settingsFile << """
            includeBuild 'included'
        """
        buildFile << """
            task run {
                dependsOn gradle.includedBuild('included').task(':d')
            }
        """
        file('included/build.gradle') << """
            task a { enabled = false }

            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") {
        }

import java.io.File;

/**
 * A build that is included in the composite.
 *
 * @since 3.1
 */
public interface IncludedBuild {
    /**
     * The name of the included build.
     */
    String getName();

    /**
     * The root directory of the included build.
     */
    File getProjectDir();

    /**
     * Produces a reference to a task in the included build.
     */
    TaskReference task(String path);

        }

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

import org.gradle.api.Action;
import org.gradle.api.artifacts.DependencySubstitutions;

/**
 * A build that is to be included in the composite.
 *
 * @since 3.1
 */
public interface ConfigurableIncludedBuild extends IncludedBuild {

    /**
     * Sets the name of the included build.
     *
     * @param name the name of the build
     * @since 6.0
     */
    void setName(String name);

    /**

 */

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: