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"

@TargetGradleVersion('>=6.8')
class CompositeBuildBuildActionExecuterCrossVersionSpec extends ToolingApiSpecification {

    def "can run task from included build when running a build action"() {
        given:
        settingsFile << "includeBuild('other-build')"
        file('other-build/settings.gradle') << """
            rootProject.name = 'other-build'
            include 'sub'
        """
        file('other-build/sub/build.gradle') << """

            task a {
                dependsOn gradle.includedBuild('buildB').task(':b')
            }
        """
        buildB.buildFile << """
            task b {
                dependsOn gradle.includedBuild('buildC').task(':c')
            }
        """
        buildB.settingsFile << """
            includeBuild('../buildC')
        """
        buildC.buildFile << """
            task c {

        fixture.setup()
        def build = { configurationCacheRunLenient(*fixture.buildArguments) }
        settingsFile << """
            includeBuild 'build-logic'
        """

        when:
        build()

        then:
        outputContains fixture.expectedOutputBeforeChange
        configurationCache.assertStateStored()

        when: