${getBuildScriptDependency(rootJar)}
            apply(from = "some.gradle.kts")
        """)
        def a = withBuildScriptIn("a", """
            ${getBuildScriptDependency(aJar)}
            apply(from = "../some.gradle.kts")
        """)
        def b = withBuildScriptIn("b", """
            plugins {
                `kotlin-dsl`
            }
            ${getBuildScriptDependency(bJar)}

        registry.register(new CustomBuilder())
    }

    public void apply(Project project) {
    }
}
"""
        withBuildScriptIn("a")
        withBuildScriptIn("b")
        withBuildScriptIn("c")
        withBuildScriptIn("d")
        withBuildScriptIn("e")

        settingsFile << """
include 'a', 'b', 'c', 'd', 'e'
"""
    }

    @ToolingApiVersion(">=7.0 <8.2")

        withBuildScriptIn("kotlin-dsl-producer", "plugins { `kotlin-dsl` }")
        withFile(
            "kotlin-dsl-producer/src/main/kotlin/some/Some.kt",
            """
            package some
            interface Some { fun some() = Unit }
            """
        )

        withBuildScriptIn(
            "java-consumer",
            """

        mavenRepo.module("test", "utils", "1.0")
            .mainArtifact(mapOf("content" to utils.readBytes()))
            .publish()

        withDefaultSettingsIn("plugin")
        withBuildScriptIn("plugin", """
            plugins {
                `kotlin-dsl`
                `maven-publish`
            }
            group = "test"
            version = "1.0"
            java {

    @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"
            }
            ${mavenCentralRepository(KOTLIN)}

    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") << """
            import org.gradle.api.provider.*

    def "can fetch KotlinDslScripts model for single subproject build"() {
        withSettings("""
            rootProject.name = "root"
            include("a")
        """)
        withBuildScript()
        withBuildScriptIn("a")

        when:
        def originalModel = fetchModel(KotlinDslScriptsModel)

        then:
        fixture.assertNoConfigurationCache()


        when:
        withIsolatedProjects()

        // this is to force buildSrc/build.gradle.kts to be written to test-local buildscript cache
        // and not to be reused from daemon's cache from other tests when daemon is in use
        withBuildScriptIn("buildSrc", scriptWithKotlinDslPlugin())
            .bustScriptCache()
    }

    private
    fun File.bustScriptCache() {
        appendText(
            """
                val cacheBuster = "$cacheBuster"

        return withFile("src/main/kotlin/$fileName", code)
    }

    private TestFile withImplementationDependencyOn(String basedir, TestFile jar) {
        return withBuildScriptIn(basedir, """
            plugins {
                `kotlin-dsl`
            }

            $repositoriesBlock

            dependencies {
                implementation(files("${jar.name}"))

    private
    val boom = """throw InternalError("BOOM!")"""

    @Test
    fun `location of exception thrown from build script is reported`() {

        withSettings("""include("a")""")
        val script = withBuildScriptIn("a", boom)

        assertFailingBuildOutputOf("help") {
            """
            * Where:
            Build file '${script.canonicalPath}' line: 1
            """
        }
    }

    @Test