"""

        file("buildSrc/build.gradle.kts") << """
            plugins {
                `kotlin-dsl`
            }
            ${mavenCentralRepository(GradleDsl.KOTLIN)}
        """

        buildScript("""
            apply plugin: SomePlugin
        """)

        when:
        configurationCacheRun("-Dsome.property=some.value")

        then:
        configurationCache.assertStateStored()

====

=== Locking buildscript classpath configuration

If you apply plugins to your build, you may want to leverage dependency locking there as well.
In order to lock the <<plugins.adoc#sec:applying_plugins_buildscript,`classpath` configuration>> used for script plugins, do the following:

.Locking buildscript classpath configuration
====

        buildFile << getPluginDescriptors(pluginIds)
        projectDir.file('settings.gradle').write("")
    }

    void publishTo(GradleExecuter executer, TestFile testFile, String buildScript = "") {
        prepareToExecute()
        buildFile << buildScript
        buildFile << """
            jar {
                archiveFileName = "$testFile.name"

        unreadableOutput.makeReadable()
    }

    @Requires(UnitTestPreconditions.FilePermissions)
    def "permissions block overrides mode"() {
        given:
        withSourceFiles("r--------")
        buildScript '''
            task (copy, type:Copy) {
               from 'files'
               into 'dest'
               eachFile {
                    mode = 0777
                    permissions {}
               }

            executer.withPluginRepositoryMirrorDisabled();
        }

        return executer;
    }

    @Override
    @Deprecated
    public GradleExecuter usingBuildScript(File buildScript) {
        this.buildScript = buildScript;
        return this;
    }

    @Override
    public GradleExecuter usingProjectDirectory(File projectDir) {
        this.projectDir = projectDir;
        return this;
    }

    def "build service can be injected to build task with #injectionAnnotation"() {
        given:
        def configurationCache = newConfigurationCacheFixture()

        buildScript("""
            ${constantServiceImpl("ConstantBuildService", "constant")}
            def serviceProvider = gradle.sharedServices.registerIfAbsent("constant", ConstantBuildService) {}

    def "native services flag should be passed to the daemon and to the worker"() {
        given:
        executer.withArguments(systemProperties.collect { it.toString() })
        buildScript("""
            import org.gradle.workers.WorkParameters
            import org.gradle.internal.nativeintegration.services.NativeServices
            import org.gradle.internal.nativeintegration.NativeCapabilities

    @Rule
    TestResources testResources = new TestResources(temporaryFolder)

    def setup() {
        args("-PscalaVersion=$version")
        buildFile << buildScript()
        executer.withRepositoryMirrors()
    }

    def compileGoodCode() {
        goodCode()

        expect:
        succeeds("compileScala")
        scalaClassFile("compile/test/Person.class").exists()

        with(containsPluginApplicationResultsForJavaPlugin(displayName)) {
            def buildScript = pluginApplicationResults.find { it.plugin instanceof ScriptPluginIdentifier && it.plugin.uri == new File(buildscriptDir, "build.gradle").toURI() }
            assert buildScript.totalConfigurationTime >= Duration.ZERO
            assert buildScript.plugin.displayName == "build.gradle"

                    IdeaModule m = p.idea.module
                    m.name = '123'
                    println m.name
                }
            }
            """

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

apply plugin: SomePlugin
"""

        expect: