}

    @Override
    String getProjectPath() {
        "':' + projectName"
    }

    @Override
    String dependsOnMechanism(String projectName, String taskName) {
        "gradle.includedBuild('multiProject').task(':$projectName:$taskName')"
    }

    @Override
    String declareDependency(String moduleName, String moduleVersion) {
        "project(':$moduleName')"
    }

    @Override

            // add lifecycle task here since we can not call the task of buildB directly yet - https://github.com/gradle/gradle/issues/2533
           tasks.register("buildBJar") {
                dependsOn(gradle.includedBuild("buildB").task(":jar"))
            }
        """
        buildA.settingsFile << """
            includeBuild('.')
        """

        includeBuild(buildB)
        dependency(buildB, "org.test:buildA")

        file("buildSrc/build.gradle").touch()

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

        return new IncludedPluginBuildSpec(rootDir, configurer);
    }

    public static IncludedBuildSpec includedBuild(File rootDir, Action<ConfigurableIncludedBuild> configurer) {
        return new IncludedLibraryBuildSpec(rootDir, configurer);
    }

    private static class IncludedLibraryBuildSpec extends IncludedBuildSpec {

            }
        }
    }

    internal
    fun readIncludedBuildStateFrom(stateFile: ConfigurationCacheStateFile, includedBuild: ConfigurationCacheBuild) =
        readConfigurationCacheState(stateFile) { state ->
            state.run {
                readBuildContent(includedBuild)
            }
        }

    private
    fun <T> readConfigurationCacheState(
        stateFile: ConfigurationCacheStateFile,

        """
        buildFile << """
            notifier.notify {
                println "failure message: \${it.failure.cause.message}"
            }
            task t {
                dependsOn gradle.includedBuild("child").task(":t")
                doLast { }
            }
        """
        file("child/build.gradle") << """
            gradle.buildFinished {
                throw new RuntimeException("broken")

        settingsFile << """
            includeBuild "child"
        """
        buildFile << """
            ${server.callFromBuild('root-build-script')}
            task hello {
                dependsOn gradle.includedBuild("child").task(":hello")
            }
        """
        createDirs("child/a", "child/b")
        file("child/settings.gradle") << """
            include 'a', 'b'
        """

        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 << """
            println 'Configured buildB'
"""

        then:
        execute(buildA, ":run", buildArgs)

        and:

            }
            gradle.taskGraph.whenReady {
                project(':foo').apply from: 'whenReady.gradle'
            }

            task foo {
                dependsOn gradle.includedBuild("included-build").task(":bar")
            }
        """

        when:
        succeeds('foo')

        then:

        given:
        settingsFile << """
            includeBuild 'included'
        """
        buildFile << """
            task run {
                dependsOn gradle.includedBuild('included').task(':d')
            }
        """
        file('included/build.gradle') << """
            task a { enabled = false }
            task b { dependsOn(a) }
            task c { dependsOn(b) }