) + entries.toMap()

    private
    fun resolvedScriptDependencies(
        scriptFile: File? = null,
        previousDependencies: KotlinScriptExternalDependencies? = null,
        vararg env: Pair<String, Any?>
    ) =
        resolver.resolve(
            scriptContentFor(scriptFile),
            environment(*env),
            recorder,
            previousDependencies
        ).get()

                found.add(candidate);
            }
        }
        return found;
    }


    private void notifyListener(File scriptFile) {
        if (scriptFileResolvedListener != null) {
            scriptFileResolvedListener.onScriptFileResolved(scriptFile);
        }
    }

    private boolean hasScriptExtension(File file) {
        for (String extension : EXTENSIONS) {

        succeeds()
        then:
        outputContains("hello from settings")
    }

    private void addExecToScript(TestFile scriptFile) {
        file("message") << """
            hello from settings
        """
        if (OperatingSystem.current().windows) {
            scriptFile << """
                def message = providers.exec {
                    commandLine "cmd.exe", "/d", "/c", "type", "message"

import java.io.File


const val buildSrcSourceRootsFilePath = "build/source-roots/buildSrc/source-roots.txt"


object SourcePathProvider {

    fun sourcePathFor(
        classPath: ClassPath,
        scriptFile: File?,
        projectDir: File,
        gradleHomeDir: File?,
        sourceDistributionResolver: SourceDistributionProvider
    ): ClassPath {
        val gradleKotlinDslJar = classPath.filter(::isGradleKotlinDslJar)

import org.gradle.internal.service.scopes.Scope;

import java.io.File;

@EventScope(Scope.Global.class)
public interface ScriptFileResolvedListener {

    void onScriptFileResolved(File scriptFile);

    }

    /**
     * The file to write the wrapper script to.
     *
     * @since 4.0
     */
    public void setScriptFile(File scriptFile) {
        this.scriptFile = scriptFile;
    }

    /**
     * The file to write the wrapper script to.
     */
    public void setScriptFile(Object scriptFile) {
        this.scriptFile = scriptFile;

        // given:
        // Notice the project directory is never written to by the test so its path is immaterial
        val projectDir = File("/project-dir")
        val scriptFile = File(projectDir, "build.gradle.kts")

        /**
         * Request accepted into the queue.
         */
        val acceptedRequest = Channel<KotlinBuildScriptModelRequest>(3)

        /**

        )
        invokeApplyPluginsTo()
    }

    fun emitStage2ProgramFor(scriptFile: File, originalPath: String) {

        val scriptDefinition = stage2ScriptDefinition
        val compiledScriptClass = compileScript(
            scriptFile,
            originalPath,
            scriptDefinition,
            StableDisplayNameFor.stage2
        )

    compilerOptions: KotlinCompilerOptions,
    scriptFile: File,
    scriptDef: ScriptDefinition,
    classPath: List<File>,
    logger: Logger,
    pathTranslation: (String) -> String
): String {

    compileKotlinScriptModuleTo(
        outputDirectory,
        compilerOptions,
        "buildscript",
        listOf(scriptFile.path),
        scriptDef,
        classPath,

        <table>
            <thead>
                <tr>
                    <td>Name</td>
                    <td>Default</td>
                </tr>
            </thead>
            <tr>
                <td>scriptFile</td>
                <td><literal><replaceable>${project.projectDir}</replaceable>/gradlew</literal></td>
            </tr>
            <tr>
                <td>jarFile</td>