return precompiledScriptPluginModelBuilder(scriptFile, enclosingSourceSet, modelRequestProject)
        }

        if (isSettingsFileOf(modelRequestProject, scriptFile)) {
            return settingsScriptModelBuilder(scriptFile, modelRequestProject)
        }

        return when (kotlinScriptTypeFor(scriptFile)) {

 * invocation of an executable. It uses "sh" syntax on POSIX platforms and batch files on Windows.
 */
abstract class ShellScript {
    protected final TestFile scriptFile

    protected ShellScript(TestFile scriptFile) {
        this.scriptFile = scriptFile
    }

    /**
     * Returns a command line elements that can be used to start this script.

    public void canConstructSourceFromFile() throws IOException {
        scriptFile.createNewFile();
        ScriptSource source = forFile(scriptFile);
        assertThat(source.getResource(), instanceOf(UriTextResource.class));
        assertThat(source.getResource().getFile(), equalTo(this.scriptFile));
        assertThat(source.getResource().getLocation().getFile(), equalTo(this.scriptFile));

    val scriptFile: File?,
    val response: KotlinBuildScriptModel
) : ResolverEvent()


internal
data class ResolvedDependencies internal constructor(
    val correlationId: String,
    val scriptFile: File?,
    val dependencies: KotlinScriptExternalDependencies
) : ResolverEvent()


internal
data class ResolvedDependenciesWithErrors internal constructor(
    val correlationId: String,
    val scriptFile: File?,

        assert '\u20AC'.charAt(0) == 0x20AC
    }
}
""", "ISO-8859-15")
        assert scriptFile.getText("ISO-8859-15") != scriptFile.getText("UTF-8")
        server.expectGet('/script.gradle', scriptFile).contentType("text/plain; charset=ISO-8859-15")

        and:
        buildFile << "apply from: '${server.uri}/script.gradle'"

        expect:
        succeeds 'check'
    }

        if (File.separator.equals("/")) {
            // Unix
            return "sh " + scriptFile.getAbsolutePath() + " $INPUT_FILE";
        } else {
            // Windows
            return scriptFile.getAbsolutePath() + " $INPUT_FILE";
        }
    }

    public void test_getText() throws IOException {
        final File scriptFile = createScriptTempFile(3);
        final String content = "TEST";

    final TestFile projectDir
    final TestFile scriptFile
    final List<String> buildArguments
    final String expectedOutputBeforeChange = 'Hello!'
    final String expectedOutputAfterChange = 'Hi!'

    ScriptChangeFixture(TestFile projectDir, TestFile scriptFile, List<String> buildArguments) {
        this.projectDir = projectDir
        this.scriptFile = scriptFile
        this.buildArguments = buildArguments
    }

        }
        if (hasScript(buildFile, scriptFile.name)) {
            rootOtherScriptAppId = findScriptApplicationId(targetsProject(':'), scriptFile(scriptFile))
        }
        if (hasScript(subBuildFile, scriptFile.name)) {
            subOtherScriptAppId = findScriptApplicationId(targetsProject(':sub'), scriptFile(scriptFile))
        }
    }

    }

    return intermediateModels.associateBy({ it.scriptFile }) {
        val classPath = base.nonProjectScriptPaths.bin + it.classPath
        val gradleKotlinDslJar = classPath.filter(::isGradleKotlinDslJar)
        val sourcePath = gradleKotlinDslJar + base.nonProjectScriptPaths.src + it.sourcePath
        buildOutputModel(it.scriptFile, classPath, sourcePath, base.implicitImports, base.classPathModeExceptions)
    }
}

                        withFile("build.gradle.kts")
                    }
                }
            }
        }

        assertThat(
            projectRootOf(
                scriptFile = file("root/nested-project-root/sub-project/build.gradle.kts"),
                importedProjectRoot = folder("root")
            ),
            equalTo(folder("root/nested-project-root"))
        )
    }

    @Test