and:
        Map<File, KotlinBuildScriptModel> multiRequestsModels = spec.scripts.values().collectEntries {
            [(it): kotlinBuildScriptModelFor(projectDir, it)]
        }

        then:
        spec.scripts.values().each { script ->
            assert singleRequestModels[script].classPath == multiRequestsModels[script].classPath

import java.io.File


@LeaksFileHandles("Kotlin Compiler Daemon working directory")
class PrecompiledScriptPluginAccessorSettingEvaluationTest : AbstractPrecompiledScriptPluginTest() {

    @Test
    fun `settings and init scripts are not evaluated when generating accessors`() {
        // given:
        val evaluationLog = file("evaluation.log")
        withFolders {
            // a precompiled script plugin contributing an extension

 * limitations under the License.
 */
package org.gradle.groovy.scripts.internal;

import org.codehaus.groovy.ast.stmt.Statement;
import org.codehaus.groovy.control.CompilationUnit;
import org.gradle.api.specs.Spec;
import org.gradle.configuration.ScriptTarget;
import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.groovy.scripts.Transformer;
import org.gradle.internal.Factory;

    }

    def "does nothing when there are no init scripts"() {
        given:
        startParameter.allInitScripts >> []

        when:
        handler.executeScripts(gradle)

        then:
        0 * executor._
        0 * processor._
    }

    def "finds and processes init scripts"() {
        File script1 = testDirectoryProvider.createFile("script1.gradle")

     * @return this
     */
    ObjectConfigurationAction to(Object... targets);

    /**
     * Adds a script to use to configure the target objects. You can call this method multiple times, to use multiple
     * scripts. Scripts and plugins are applied in the order that they are added.
     *
     * @param script The script. Evaluated as per {@link org.gradle.api.Project#file(Object)}. However, note that

# limitations under the License.

# Setup env vars
source ./common/scripts/setup_env.sh

set -eu

# Speed up builds when using recent CPUs
export GGCR_EXPERIMENT_SHA256_SIMD=1

if [[ -f ${LOCAL_OUT}/docker-builder ]]; then
  CURRENT_BUILD="$(./common/scripts/report_build_info.sh | grep buildGitRevision | cut -d= -f2)"
  PREBUILT="$(${LOCAL_OUT}/docker-builder --version)"

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.internal.scripts;

/**
 * This interface is implemented by remapped build scripts.
 */
public interface ScriptOrigin {

    /**
     * Returns the non-remapped class name.
     */
    String getOriginalClassName();

    /**

# See the License for the specific language governing permissions and
# limitations under the License.

# A single script that runs a predefined set of update-* scripts, as they often go together.
set -o errexit
set -o nounset
set -o pipefail

KUBE_ROOT=$(dirname "${BASH_SOURCE[0]}")/../..
source "${KUBE_ROOT}/hack/lib/init.sh"

SILENT=${SILENT:-true}
ALL=${FORCE_ALL:-false}

_You don't have to migrate all at once!_ Both Groovy and Kotlin-based build scripts can `apply` other scripts of either language. You can find inspiration for any Gradle features not covered in the link:https://github.com/gradle/kotlin-dsl/tree/master/samples[Kotlin DSL samples].


== Prepare your Groovy scripts

Some simple Kotlin and Groovy language differences can make converting scripts tedious:

     */
    public List<File> getInitScripts() {
        return Collections.unmodifiableList(initScripts);
    }

    /**
     * Returns all init scripts, including explicit init scripts and implicit init scripts.
     *
     * @return All init scripts, including explicit init scripts and implicit init scripts.
     */
    public List<File> getAllInitScripts() {