output.count("prop1=new-value") == 2
        outputContains("prop2=other-value")
    }

    @Issue("https://github.com/gradle/gradle/issues/27521")
    def "buildscript dependencies are resolved properly"() {
        buildFile << """
            buildscript {
                repositories {
                    mavenCentral()
                }
                dependencies {

        delegate.beforeEvaluate(closure)

    override fun property(propertyName: String): Any? =
        delegate.property(propertyName)

    override fun buildscript(configureClosure: Closure<*>) =
        delegate.buildscript(configureClosure)

    override fun getProject(): Project =
        delegate.project

    override fun getIsolated(): IsolatedProject =
        delegate.isolated

    }

    def "applicationId for cross script buildscript configuration is emitted correctly"() {
        given:
        settingsFile << """
        gradle.allprojects {
            buildscript {
                repositories.all {
                    println "script repo callback"
                }
            }

        )

        buildFile << """
            buildscript {
                dependencies {
                    classpath 'group:artifact:1.0'
                }

                repositories {
                    maven {
                        url '${mavenRepo.uri}'

                @TaskAction
                void doGet() {
                    project.file("file.txt")
                }
            }
        """

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

            task task(type: SubclassTask)
        """

        then:

    def setup() {
        executer.requireIsolatedDaemons()
        executer.requireOwnGradleUserHomeDir()
        executer.requireDaemon()

        buildScript """
            task hello() {
                doLast {
                    println "Hello Gradle!"
                }
            }
        """
    }

                matching("gradle-kotlin-dsl-extensions-$version\\.jar")
            )
        )
    }

    protected void assertClassPathFor(
        File buildScript,
        Set<? extends File> includes,
        Set<? extends File> excludes,
        File importedProjectDir = projectDir
    ) {
        def includeItems = hasItems(includes.collect { it.name } as String[])

        setup:
        executer.requireDaemon().requireIsolatedDaemons()
        boolean java9orAbove = JavaVersion.current().java9Compatible

        buildScript """
            import java.lang.management.ManagementFactory
            import java.lang.management.MemoryMXBean

            println "GRADLE_VERSION: " + gradle.gradleVersion

            task verify {

        val buildScript = withBuildScriptIn("buildSrc", scriptWithKotlinDslPlugin(testedVersion))
        if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_20)) {
            // Kotlin 1.8.20 that is a dependency of kotlin-dsl plugin 4.0.2 doesn't work
            // with Java20+ without setting jvmTarget that is lower than JvmTarget.JVM_20
            buildScript.appendText(
                """

    }

    def setup() {
        executer.beforeExecute {
            it.withBuildCacheEnabled()
        }
    }

    def "exposes origin build id when reusing cached outputs"() {
        given:
        buildScript """
            apply plugin: "base"
            def write = tasks.create("write", WriteProperties) {
                destinationFile = file("build/out.properties")
                properties = [v: 1]
            }