file("b/buildSrc/build.gradle") << ""
        file("b/build.gradle") << ""
        file("b/settings.gradle") << ""
        settingsFile << """
            includeBuild "a"
            includeBuild "b"
        """
        buildFile.text = """
            task t
        """

        when:
        succeeds "t", "--scan"

        then:

        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>includeBuild</td>
            </tr>
            <tr>
                <td>plugins</td>
            </tr>
            <tr>
                <td>resolutionStrategy</td>
            </tr>
            <tr>

                }
            }
        """.stripIndent()

        addBuilderRegisteringPluginImplementation("plugins", "MyModelBuilder")

        settingsFile << """
            includeBuild("plugins")
            rootProject.name = 'root'
        """
        buildFile << """
            plugins {
                id("my.plugin")
            }
        """

        when:

    def "unsupported method for older versions"() {
        given:
        includedBuild("b1")
        includedBuild("b2")

        when:
        withConnection {
            it.action(new FetchRootProjectsTasks()).run();
        }.collect { it.buildTreePath }

        then:
        thrown(UnsupportedMethodException)
    }

    TestFile includedBuild(String build) {
        settingsFile << """
            includeBuild("$build")

        // Add all included builds from the command-line
        SettingsInternal settings = state.getSettings();
        for (File rootDir : gradle.getStartParameter().getIncludedBuilds()) {
            settings.includeBuild(rootDir);
        }

        return state;
    }

class IsolatedProjectsCompositeBuildIntegrationTest extends AbstractIsolatedProjectsIntegrationTest {
    def "can build libraries composed from multiple builds"() {
        settingsFile << """
            includeBuild("libs")
        """
        file("libs/settings.gradle") << """
            include("a")
        """
        file("libs/a/build.gradle") << """
            plugins { id('java-library') }
            group = 'libs'

        p2.details.targetPath == ":b"
        p2.details.pluginClass == "Plugin2"
    }

    def "associates target to correct build"() {
        when:
        settingsFile << """
            includeBuild "a"
            includeBuild "b"
        """
        file("a/settings.gradle") << ""
        file("b/settings.gradle") << ""
        file("a/build.gradle") << """
            class PluginA implements Plugin {

        !projects.collect({ it.name }).contains("explicitName")
    }

    def "Reserved names work in composite builds"() {
        given:
        settingsFile << """
                includeBuild 'includedBuild1'
                includeBuild 'includedBuild2'
            """
        def inc1 = multiProjectBuildInSubFolder("includedBuild1", ["a", "b", "c"])
        def inc2 = multiProjectBuildInSubFolder("includedBuild2", ["a", "b", "c"])

class CompositeBuildSubstitutionsCrossVersionSpec extends ToolingApiSpecification {

    private compositeIncludedRoot() {
        settingsFile << """
            rootProject.name = 'module-root'
            includeBuild('.')
            include('sub-a', 'sub-b')
        """
        file('sub-a').mkdir()
        file('sub-a/build.gradle') << """
            plugins { id 'java-library' }
            group = 'g'
        """

    @ToBeImplemented
    def "included builds participate in type-safe accessors generation"() {
        settingsFile << """
            rootProject.name = 'test'

            includeBuild 'other'
        """
        file('other/settings.gradle') << """
            rootProject.name = 'other'
        """

        buildFile << """
            def projectDependency = projects.other