void apply(Project project) {
                    $pluginApplyBody
                }
            }
            """

        buildFile << """
            buildscript {
                dependencies { classpath fileTree(dir: "producer/build/libs", include: '*.jar') }
            }

            apply plugin: SomePlugin
        """
    }

        settingsFile << """
            buildscript { dependencies { classpath files(\"${plugin1Jar.name}\") } }

            getClass().classLoader.loadClass('${plugin1ClassName}')
            println "settings: plugin 1 visible"
        """

        file("buildSrc/settings.gradle") << """
            buildscript { dependencies { classpath files(\"../${plugin2Jar.name}\") } }

    def "does not download gradleApi() sources when sources download is disabled"() {
        given:
        executer.withEnvironmentVars('GRADLE_REPO_OVERRIDE': "$server.uri/")

        buildScript """
            apply plugin: "java"
            apply plugin: "idea"
            apply plugin: "eclipse"

            dependencies {
                implementation gradleApi()
            }

class AbstractClassBackedManagedTypeIntegrationTest extends AbstractIntegrationSpec {

    def "rule can provide a managed model element backed by an abstract class"() {
        when:
        buildScript '''
            @Managed
            abstract class Person {
                abstract String getName()
                abstract void setName(String name)
            }

    }

    // TODO: remove in Gradle 9.0
    def "nag with deprecation warnings when using legacy TestReport APIs"() {
        given:
        buildScript """
            apply plugin: 'java'
            $junitSetup
            tasks.register('otherTests', Test) {
                binaryResultsDirectory = file("bin")
                classpath = files('blahClasspath')

    fun reduce(program: Program): ResidualProgram = when (program) {

        is Program.Empty -> reduceEmptyProgram()

        is Program.PluginManagement -> stage1WithPluginManagement(program)

        is Program.Buildscript -> reduceBuildscriptProgram(program)

        is Program.Plugins -> stage1WithPlugins(program)

        is Program.Stage1Sequence -> stage1WithPlugins(program)

        is Program.Script -> reduceScriptProgram(program)

        )
    }

    @Test
    fun `given a script plugin with a buildscript block, it will be used to compute its classpath`() {

        withClassJar("fixture.jar", DeepThought::class.java)

        withFile(
            "other.settings.gradle.kts",
            """
            buildscript {
                dependencies { classpath(files("fixture.jar")) }
            }

This removes the need for the special `buildSrc` project and makes prototyping plugins even easier.

== Buildscript dependencies are substituted

        "newer"  | PLUGIN_NEWER_VERSION
    }

    def "uses #sequence version of plugin when added to buildscript classpath"() {
        when:
        fixture.runtimeVersion = version
        fixture.artifactVersion = version
        settingsFile.text = """
            buildscript {
                repositories {
                    maven { url '${mavenRepo.uri}' }
                }

@UnsupportedWithConfigurationCache(because = "software model")
class ModelRuleValidationIntegrationTest extends AbstractIntegrationSpec {

    def "invalid model name produces error message"() {
        when:
        buildScript """
            class MyPlugin {
                static class Rules extends RuleSource {
                    @Model(" ")
                    List<String> strings() {
                      []
                    }