}

    @Test
    fun `given line commented buildscript it returns null`() {
        assertNoBuildscript("// no buildscript {} here")
    }

    @Test
    fun `given block commented buildscript it returns null`() {
        assertNoBuildscript("/* /* no */ buildscript {} here either */")
    }

    @Test
    fun `given more than one top level buildscript block it throws UnexpectedDuplicateBlock`() {
        try {

        )
    }

    @Test
    fun `buildscript then plugins`() {
        val source = ProgramSource(
            "settings.gradle.kts",
            """
            buildscript { println("stage 1 buildscript") }
            plugins { println("stage 1 plugins") }
            """.trimIndent()
        )
        assertStageOneOutput(
            source,
            "stage 1 buildscript\nstage 1 plugins\n"
        )
    }

    }

    @ToBeFixedForConfigurationCache(because = "test relies on static state")
    def "refreshes when buildscript classpath gets new dependency"() {
        addIsCachedCheck()
        createJarWithProperties("foo.jar")

        when:
        run()
        buildFile << """
            buildscript { dependencies { classpath files("foo.jar") } }
        """
        run()

        then:

    }

    @Test
    fun `Settings target - top-level - buildscript block - empty body`() {

        val fragment =
            fragment("buildscript", "...")

        assertThat(
            "reduces to static program that evaluates buildscript block then applies default plugin requests",
            partialEvaluationOf(
                Program.Buildscript(fragment),
                ProgramKind.TopLevel,

        assertEmptyProgram("initscript {}", programTarget = ProgramTarget.Gradle)
        assertEmptyProgram("buildscript {}")
        assertEmptyProgram("plugins {}")
        assertEmptyProgram("buildscript {}\r\nplugins {}")
        assertEmptyProgram(" /* before */buildscript { /* within */ }/* after */ ")
    }

    @Test

        this.classes.scalaVersion = newScalaVersion
        buildScript(this.classes.buildScript())
        succeeds scaladoc
        then:
        executedAndNotSkipped scaladoc
    }

    def "scaladoc is loaded from cache"() {
        classes.baseline()
        buildScript(classes.buildScript())

        when:
        withBuildCache().run scaladoc

        then:
        executedAndNotSkipped scaladoc

        }

        publishPlugin("").dependsOn(GROUP, ARTIFACT + "2", VERSION).publishPom()

        when:
        buildScript """
            buildscript {
              dependencies {
                classpath "$GROUP:${ARTIFACT + 2}:$VERSION"
              }
              repositories {
                maven { url "$pluginRepo.uri" }

import static org.gradle.api.internal.initialization.ClassLoaderIds.testTaskClasspath
import static org.gradle.util.Matchers.strictlyEquals

class ClassLoaderIdsTest extends Specification {

    def "equality"() {
        expect:
        strictlyEquals(buildScript("x", "x"), buildScript("x", "x"))
        buildScript("x", "x") != buildScript("x", "y")

        def buildScript = buildFile.text
        def index = buildScript.indexOf('publishing {')
        assert index >= 0
        buildScript = buildScript.substring(0, index) + """
repositories {
    maven { url "${buildContext.localRepository.toURI()}" }
}
""" + buildScript.substring(index)

        buildFile.text = buildScript
    }

    fun `avoids buildscript recompilation on non ABI change in buildscript classpath`() {
        val (className, jarPath) = buildJarForBuildScriptClasspath(
            """
            public void foo() {
                System.out.println("foo");
            }
            """
        )

        withUniqueScript(
            """
            buildscript {