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:
        buildB.settingsFile << "includeBuild '../buildA'"

        def builds = nestedBuilds {
            includedBuild {
                buildLogic
                nested {
                    buildLogic
                    includeBuild '../buildLogic'
                }
            }
            includingBuild {
                includeBuild '../includedBuild'
                buildLogic
                nested {
                    includeBuild '../buildLogic'
                    buildLogic

        given:
        includeBuild buildB
        includeBuild buildC

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

        when:
        buildA.buildFile << """
task run {
    dependsOn gradle.includedBuild('buildC').task(':jar')
}
"""
        buildB.buildFile << """

        }
        includeBuild(buildB)
        def buildC = singleProjectBuild("buildC") {
        }
        includeBuild(buildC)
        buildA.buildFile << """
            assert gradle.includedBuild("buildB").name == "buildB"
            assert gradle.includedBuild("buildB").projectDir == file('${buildB.toURI()}')
            assert gradle.includedBuild("buildC").name == "buildC"

// This build is not necessarily needed. The component builds work independently.

includeBuild('platforms')
includeBuild('build-logic')

includeBuild('aggregation')

includeBuild('user-feature')
includeBuild('admin-feature')

includeBuild('server-application')

// This build is not necessarily needed. The component builds work independently.

includeBuild("platforms")
includeBuild("build-logic")

includeBuild("aggregation")

includeBuild("user-feature")
includeBuild("admin-feature")

includeBuild("server-application")

        given:
        def build = pluginAndLibraryBuild("included-build")
        settingsFile << """
            pluginManagement {
                includeBuild("${build.buildName}")
            }
            includeBuild("${build.buildName}")
        """

        when:
        buildFile << """
            plugins {
                id("java-library")

            settingsFile << """
                includeBuild 'includedBuild'
            """
        }
        singleProjectBuildInSubfolder("includedBuild")

        when:
        def builds = withConnection {
            action(new FetchBuilds()).run()
        }

        then:
        builds.rootProject.name == ["root", "includedBuild"]
    }

    @Issue("https://github.com/gradle/gradle/issues/5167")

    }

    def "can combine included builds with declared and discovered substitutions"() {
        given:
        dependency "org.test:b1:1.0"
        dependency "org.test:XXX:1.0"

        includeBuild buildB
        includeBuild buildC, """
            substitute module("org.test:XXX") using project(":")
"""

        expect:
        resolvedGraph {
            edge("org.test:b1:1.0", ":buildB:b1", "org.test:b1:2.0") {

        given:
        settingsFile << """
            pluginManagement {
                includeBuild("${build2.buildName}")
                includeBuild("${build1.buildName}")
            }
        """
        build2.settingsFile.setText("""
            pluginManagement {
                includeBuild("../${build1.buildName}")
            }
            rootProject.name = "${build2.buildName}"
        """)