<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")

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

 */

dependencyResolutionManagement {
    repositories {
        gradlePluginPortal()
    }
}

plugins {
    id("org.gradle.toolchains.foojay-resolver-convention") version("0.8.0")
}

includeBuild("../build-logic-settings")

// Shared basics for all
include("basics")

// Platform: defines shared dependency versions
include("build-platform")

    def "can interpret the settings file with the declarative DSL"() {
        given:
        file("settings.gradle.dcl") << """
            pluginManagement {
                includeBuild("pluginIncluded")
                repositories {
                    mavenCentral()
                    google()
                }
            }

            rootProject.name = "test-value"