delegate.copy(action)

    override fun getDescription(): String? =
        delegate.description

    override fun subprojects(action: Action<in Project>) =
        delegate.subprojects(action)

    override fun subprojects(configureClosure: Closure<*>) =
        delegate.subprojects(configureClosure)

    override fun getBuildscript(): ScriptHandler =
        delegate.buildscript

            group = "group of root task"
        }
        project(":someproj1"){
            task hello {
                group = "group of subproject task"
            }
        }
        project(":someproj2"){
            task hello {
                group = "group of subproject task"
            }
        }
"""
        when:
        run "help", "--task", "hello"
        then:

    }

    String providerOf(String expression) {
        return "project.provider { $expression }"
    }

    def setup() {
        createDirs("subproject")
        settingsFile("""
            include "subproject"

            rootProject.name = "${PROJECT_NAME}"
            gradle.rootProject {
                version = "${PROJECT_VERSION}"
            }
        """)

A composite build is a build that includes other builds.

image::structuring-builds-4.png[]

[[composite_build_intro]]
A composite build is similar to a Gradle multi-project build, except that instead of including `subprojects`, entire `builds` are included.

Composite builds allow you to:

* Combine builds that are usually developed independently, for instance, when trying out a bug fix in a library that your application uses.

            include(":libA")
            include(":libB")
            include(":libC")

        """.stripIndent()

        if (config.subProjects != 0) {
            includedProjects += """${(0..config.subProjects - 1).collect { "include(\"project$it\")" }.join("\n")}"""
        }

        return includedProjects
    }

    static String generateBuildGradle(Integer subProjectNumber) {

    }

    private void withSubprojects(String... subprojects) {
        subprojects.each {
            createDir it
            settingsFile "include '$it'\n"
        }
    }

    private void withZipArtifactProducingSubprojects(String... subprojects) {
        withSubprojects subprojects
        taskTypeWithOutputFileProperty()
        buildFile '''

    }

    TestFile multiProjectBuildInSubFolder(String projectName, List<String> subprojects, @DelegatesTo(BuildTestFile) Closure cl = {}) {
        new BuildTestFixture(projectDir).withBuildInSubDir().multiProjectBuild(projectName, subprojects, cl)
    }

    void multiProjectBuildInRootFolder(String projectName, List<String> subprojects, @DelegatesTo(BuildTestFile) Closure cl = {}) {

:buildB:compileJava
\\--- :buildC:compileJava
     \\--- :buildB:compileJava (*)""")
    }

    def "dependency cycle between subprojects in an included multiproject build"() {
        given:
        dependency "org.test:buildB:1.0"

        buildB.buildFile << """
            dependencies {
                implementation "org.test:b1:1.0"

        given:
        def repoDir = file("repo")
        createDirs("deck", "card", "shuffle")
        settingsFile << "include 'deck', 'card', 'shuffle'"
        buildFile << """
            subprojects {
                apply plugin: 'cpp-library'
                apply plugin: 'maven-publish'

                group = 'some.group'
                version = '1.2'
                publishing {

    abstract int getMaxDistributionSizeBytes()

    /**
     * Change this whenever you add or remove subprojects for distribution core modules (lib/).
     */
    int getCoreLibJarsCount() {
        69
    }

    /**
     * Change this whenever you add or remove subprojects for distribution-packaged plugins (lib/plugins).
     */
    int getPackagedPluginsJarCount() {
        80
    }

    /**