and:
        dslFixtureFor(scriptDsl).getBuildFile().text.contains("Swift tool chain does not support Windows. The following targets macOS and Linux:")
        dslFixtureFor(scriptDsl).getBuildFile().text.contains("targetMachines.add(machines.macOS.x86_64")
        dslFixtureFor(scriptDsl).getBuildFile().text.contains("targetMachines.add(machines.linux.x86_64")

        and:

    }

    static ScriptDslFixture of(BuildInitDsl scriptDsl, TestFile rootDir, String subprojectName) {
        new ScriptDslFixture(scriptDsl, rootDir, subprojectName)
    }

    final BuildInitDsl scriptDsl
    final TestFile rootDir
    final String subprojectName

    ScriptDslFixture(BuildInitDsl scriptDsl, TestFile rootDir, String subprojectName) {
        this.scriptDsl = scriptDsl
        this.rootDir = rootDir

    }

    def "creates a simple project with #scriptDsl build scripts when no pom file present and no type specified"() {
        given:
        useTestDirectoryThatIsNotEmbeddedInAnotherBuild()
        def dslFixture = ScriptDslFixture.of(scriptDsl, targetDir, null)

        when:
        runInitWith scriptDsl

        then:
        commonFilesGenerated(scriptDsl, dslFixture)

        and:

configurations {
    create("gradleScriptsElements") {
        isVisible = false
        isCanBeResolved = false
        isCanBeConsumed = true
        attributes.attribute(Usage.USAGE_ATTRIBUTE, objects.named("start-scripts"))
        outgoing.artifact(startScripts)
    }

 * If the compiled script is not found in this cache, it will try to find it in the global cache,
 * which will use the delegate script class compiler in case of a miss. The lookup in this cache is
 * more efficient than looking in the global cache, as we do not check the script's hash code here,
 * assuming that it did not change during the build.
 */

	prefix := path.Join("/", filepath.ToSlash(relDir))

	r.mu.RLock()
	defer r.mu.RUnlock()
	for {
		// For efficiency, we cache the script's output (in the work directory)
		// across invocations. However, to allow for rapid iteration, we hash the
		// script's contents and regenerate its output if the contents change.
		//
		// That way, one can use 'go run main.go' in this directory to stand up a

create in the script's temporary file system before it starts executing.

As an example, run_hello.txt says:

	# hello world
	go run hello.go
	stderr 'hello world'
	! stdout .

	-- hello.go --
	package main
	func main() { println("hello world") }

Each script runs in a fresh temporary work directory tree, available to scripts as $WORK.

[[sec:basic_usage]]
== Using an init script

Initialization scripts, also called _init scripts_, are similar to other scripts in Gradle.
Initialization scripts run before the build starts.

They are useful for various purposes:

* Setting up enterprise-wide configurations (e.g., custom plugin locations)
* Configuring properties based on the environment (e.g., developer's machine vs. CI server)

        String scriptName = "script-missing.gradle"
        String scriptUrl = "${server.uri}/${scriptName}"
        def scriptFile = file("script.gradle") << """
            println 'loaded remote script'
        """

        buildFile << """
            apply from: '${scriptUrl}'
        """

        when:
        server.expectGetMissing("/" + scriptName)

        then:

     *
     * Gradle runtime.
     */
    ClassLoaderScope getBaseClassLoaderScope();

    /**
     * The scope for this settings object.
     *
     * Gradle runtime + this object's script's additions.
     */
    ClassLoaderScope getClassLoaderScope();

    ServiceRegistry getServices();

    @Override
    BuildCacheConfigurationInternal getBuildCache();

    @Override