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]
            }

                    getInputs();
                    getOutputs();
                }
            }
        """
        builder.buildJar(pluginJar)

        buildFile << """
            buildscript {
                dependencies {
                    classpath files("${pluginJar.toURI()}")
                }
            }

            task myTask(type: com.example.MyTask)
        """
    }

        group = "Plugin development"
        outputFile = project.layout.buildDirectory.file("reports/plugins/validation-report-for-$idWithoutDots.txt")

        val scriptHandler = project.buildscript as ScriptHandlerInternal
        val scriptClassPath = scriptHandler.scriptClassPath.asFiles
        classpath = project.files(scriptClassPath)

        val archiveOperations = findArchiveOperations(project)

            onAccess("dependencyFactory")
            return delegate.dependencyFactory
        }

        override fun buildscript(configureClosure: Closure<*>) {
            onAccess("buildscript")
            delegate.buildscript(configureClosure)
        }

        override fun copy(closure: Closure<*>): WorkResult {
            onAccess("copy")
            return delegate.copy(closure)

import static org.gradle.integtests.fixtures.ToBeFixedForConfigurationCache.Skip.INVESTIGATE

@LeaksFileHandles
class InitScriptIntegrationTest extends AbstractIntegrationSpec {

    private void createProject() {
        buildScript """
            task hello() {
                doLast {
                    println "Hello from main project"
                }
            }
        """

        file("buildSrc/build.gradle") << """

    def setup() {
        inputFile.text = 'This is the input'
        cacheOriginInputFile.text = 'And this is not'

        buildScript """
            apply plugin: 'base'

            import org.gradle.api.*
            import org.gradle.api.tasks.*

            task cacheableTask(type: MyTask) {
                inputFile = file('input.txt')

        classPathAsList(AGENT_INSTRUMENTATION_MARKER.fileName, "instrumented/instrumented-1.jar")                         ...

    }
    // endregion Role-Based Configurations

    // region Warnings
    def "changing usage for configuration #configuration produces warnings"() {
        given: "a buildscript which attempts to change a configuration's usage"
        buildFile << """
            plugins {
                id 'java-library'
            }

            configurations {
                $configuration {