}

    public void includeBuild(File includedBuild) {
        includedBuilds.add(includedBuild);
    }

    public void setIncludedBuilds(List<File> includedBuilds) {
        this.includedBuilds = includedBuilds;
    }

    public List<File> getIncludedBuilds() {
        return Collections.unmodifiableList(includedBuilds);
    }

    /**

                    }
                }
            """
        }
        includedBuilds << buildB
    }

    def "clean build and build clean work reliably with composite build"() {
        given:
        dependency "org.test:buildB:1.0"
        buildA.buildFile << """
            clean {
                dependsOn gradle.includedBuild('buildB').task(':clean')
            }
        """

        when:

                    }
                }
"""
        }
        includedBuilds << buildB
        buildBjar = buildB.file('build/libs/buildB-1.0.jar')


        buildC = singleProjectBuild("buildC") {
            buildFile << """
                println "Configured buildC"
                apply plugin: 'java'
"""
        }
        includedBuilds << buildC

    }

        buildB = multiProjectBuild("buildB", ['b1', 'b2']) {
            buildFile << """
                allprojects {
                    apply plugin: 'java'
                }
"""
        }
        includedBuilds << buildB
    }

    def "generates build operations for tasks in included builds"() {
        given:
        dependency 'org.test:buildB:1.0'

        when:
        execute(buildA, ":jar")

        Collection<? extends IncludedBuildState> includedBuilds = getBuildStateRegistry().getIncludedBuilds();
        List<Path> includedBuildIdentityPaths = new ArrayList<>(includedBuilds.size());
        for (IncludedBuildState includedBuild : includedBuilds) {
            includedBuildIdentityPaths.add(includedBuild.getIdentityPath());
        }
        return includedBuildIdentityPaths;
    }

        given:
        dependency("org.test:buildB:1.0")

        def buildB = singleProjectBuild("buildB") {
            buildFile << """
                apply plugin: 'java'
            """
        }
        includedBuilds << buildB

        def staleFiles = [
            file("buildA/build/classes/java/main/stale"),
            file("buildB/build/classes/java/main/stale")]
        staleFiles*.touch()

        when:

    def "buildTreePath is available on the GradleBuild model"() {
        given:
        includedBuild("b1")
        includedBuild("b2")

        when:
        def model = withConnection {
            it.getModel(GradleBuild)
        }

        then:
        def builds = model.includedBuilds
        builds.size() == 2
        builds.first().projects.first().buildTreePath == ":b1"

    val allInitScripts: List<File>
        get() = startParameter.allInitScripts

    val gradleUserHomeDir: File
        get() = startParameter.gradleUserHomeDir

    val includedBuilds: List<File>
        get() = startParameter.includedBuilds

    val isBuildScan: Boolean
        get() = startParameter.isBuildScan

    val isNoBuildScan: Boolean
        get() = startParameter.isNoBuildScan

    /**

    void setClassLoaderScope(Supplier<? extends ClassLoaderScope> classLoaderScope);

    ClassLoaderScope getClassLoaderScope();

    void setIncludedBuilds(Collection<? extends IncludedBuildInternal> includedBuilds);

    /**
     * Returns a unique path for this build within the current Gradle invocation.
     */
    Path getIdentityPath();

    String contextualize(String description);

                task succeeds
"""
        }
        includedBuilds << buildB << buildC
    }

    def "aborts build when delegated task in same build fails"() {
        when:
        buildA.buildFile << """
    task delegate {
        dependsOn gradle.includedBuild('buildB').task(':fails')
        dependsOn gradle.includedBuild('buildB').task(':succeeds')
    }
"""
        buildB.buildFile << """