}

    @Test
    fun `precompiled scripts use the build jvm target default`() {

        withClassJar("buildSrc/utils.jar", JavaClassUtil::class.java)

        withDefaultSettingsIn("buildSrc")
        withKotlinDslPluginIn("buildSrc").appendText("""
            dependencies {
                implementation(files("utils.jar"))
            }
        """)

    @Test
    @Requires(IntegTestPreconditions.NotEmbeddedExecutor::class)
    fun `can run with first version of kotlin-dsl plugin supporting Gradle 8_0`() {

        withDefaultSettingsIn("buildSrc")
        withBuildScriptIn("buildSrc", scriptWithKotlinDslPlugin(oldestSupportedKotlinDslPluginVersion)).appendText(
            """

        """)
    }

    def withKotlinBuildSrc() {
        withDefaultSettingsIn("buildSrc")
        withBuildScriptIn("buildSrc", """
            plugins {
                `kotlin-dsl`
            }

            $repositoriesBlock
        """)
    }

    ProjectSourceRoots[] withMultiProjectKotlinBuildSrc() {
        withDefaultSettingsIn("buildSrc").append("""
            include(":a", ":b", ":c")

    protected
    fun withFolders(folders: FoldersDslExpression) =
        projectRoot.withFolders(folders)

    protected
    fun withDefaultSettings() =
        withDefaultSettingsIn(".")

    protected
    fun withDefaultSettingsIn(baseDir: String) =
        withSettingsIn(baseDir, defaultSettingsScript)

    protected
    fun withSettings(script: String, produceFile: (String) -> File = ::newFile): File =

    @Test
    @Requires(IntegTestPreconditions.NotEmbeddedExecutor::class)
    fun `can try k2 with included build for build logic using kotlin-jvm plugin`() {

        withDefaultSettingsIn("build-logic")
        withBuildScriptIn("build-logic", """
            plugins {
                id("java-gradle-plugin")
                kotlin("jvm") version "$kotlinVersion"
            }

        expect:
        assertCanFetchClassPathForSubProjectScriptIn("nested-project")
    }

    @CompileStatic
    private void assertCanFetchClassPathForSubProjectScriptIn(String location) {

        withDefaultSettingsIn(location).append("""
            include("foo", "bar")
        """)

        def parentJar = withEmptyJar("$location/libs/parent.jar")
        def fooJar = withEmptyJar("$location/libs/foo.jar")

                appendLine("""logger.warn("WARN log from $origin")""")
                appendLine("""logger.error("ERROR log from $origin")""")
            }
        }

        withDefaultSettingsIn("external-plugins")
        withKotlinDslPluginIn("external-plugins").appendText("""group = "test"""")
        withFile("external-plugins/src/main/kotlin/applied-output.gradle.kts", outputFrom("applied-output plugin"))

                            println("property is present in consumer!")
                        }
                        """
                    )
                }

                withDefaultSettingsIn(relativePath).appendText(
                    """
                    include("gradlePropertyPlugin")
                    include("gradlePropertyPluginConsumer")
                    """
                )

    @Test
    @Requires(IntegTestPreconditions.NotEmbeddedExecutor::class)
    fun `can configure custom kotlin options on a kotlin-dsl project`() {

        withDefaultSettingsIn("buildSrc")
        val buildSrcBuildScript = withKotlinDslPluginIn("buildSrc")
        withFile("buildSrc/src/main/kotlin/MyDataObject.kt", "data object MyDataObject")
        withBuildScript("println(MyDataObject)")

class KotlinSettingsScriptModelCrossVersionSpec extends AbstractKotlinScriptModelCrossVersionTest {

    def "settings script has type-safe accessors on the classpath"() {
        given:
        withDefaultSettingsIn("included")
        withBuildScriptIn("included", """
            plugins { `kotlin-dsl` }
            $repositoriesBlock
        """)
        file("included/src/main/kotlin/SettingsExtension.kt") << """