TestFile initScript = testFile('init.gradle') << ''' apply { from 'other.gradle' } '''
        testFile('other.gradle') << '''
            projectsEvaluated {
                gradle.rootProject.task('doStuff')
            }
        '''
        inTestDirectory().usingInitScript(initScript).withTasks('doStuff').run()
    }

    @Test
    void canExecuteExternalScriptFromExternalScript() {

            }
        """.stripIndent()

        addBuilderRegisteringPluginImplementation("plugins", "MyModelBuilder")

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

        when:

    def "can run task from included build when querying a model"() {
        given:
        settingsFile << "includeBuild('other-build')"
        file('other-build/settings.gradle') << """
            rootProject.name = 'other-build'
            include 'sub'
        """
        file('other-build/sub/build.gradle') << """
            tasks.register('doSomething') {
                doLast {

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

    def setup() {
        settingsFile << """
            rootProject.name = 'module-root'
            includeBuild('module-a')
            includeBuild('module-c')
        """
        file('module-a').mkdir()
        file('module-b').mkdir()
        file('module-c').mkdir()

    def "build is not exponentially slower when many tasks are requested"() {
        createDirs((1..30).collect({ "sub" + it }) as String[])
        settingsFile << """
            rootProject.name = "test"
            (1..30).each {
                include "sub" + it
            }
        """
        buildFile << """
            subprojects {
                apply plugin: 'java'
            }

class BuildActionCrossVersionSpec extends ToolingApiSpecification {
    def "client receives the result of running a build action"() {
        given:
        file("settings.gradle") << 'rootProject.name="hello-world"'

        when:
        CustomModel customModel = withConnection { it.action(new FetchCustomModel()).run() }

        then:
        customModel.gradle.name == "hello-world"

}

val copyTestedVersionsInfo by tasks.registering(Copy::class) {
    from(rootProject.layout.projectDirectory.file("gradle/dependency-management/agp-versions.properties"))
    from(rootProject.layout.projectDirectory.file("gradle/dependency-management/kotlin-versions.properties"))
    into(layout.buildDirectory.dir("generated-resources/tested-versions"))
}

class DaemonJvmCompatibilityCrossVersionSpec extends ToolingApiSpecification {
    def setup() {
        buildFile.touch()
        settingsFile << """
            rootProject.name = "root"
        """
    }

    @TargetGradleVersion(">=8.8")
    def "can run a build with Java 21 followed by another build with a different version"() {
        given:

import org.gradle.tooling.model.eclipse.EclipseProject

@TargetGradleVersion(">=4.4")
class ToolingApiEclipseModelOutputLocationCrossVersionSpec extends ToolingApiSpecification {

    def setup() {
        settingsFile << 'rootProject.name = "root"'
    }

    def "Non-Java project has default output location"() {
        when:
        EclipseProject project = loadToolingModel(EclipseProject)

        project(':b') {
            apply plugin: 'eclipse'
            eclipse {
                project.name='explicitName'
            }
        }
        """
        settingsFile << """
        rootProject.name = 'root'
        include ':a', ':b'
        """
    }

    def "Included builds are deduplicated"() {
        given:
        settingsFile << """
                includeBuild 'includedBuild1'