loggingDir.file("buildSrc/build/.gradle").deleteDir()
        loggingDir.file("nestedBuild/buildSrc/.gradle").deleteDir()

        String initScript = new File(loggingDir, 'init.gradle').absolutePath
        List<String> allArgs = logLevel.args + ['-I', initScript]

        when:
        executer.noExtraLogging().inDirectory(loggingDir).withArguments(allArgs)
        run "log"
        then:

    void canExecuteExternalScriptFromInitScript() {
        TestFile initScript = testFile('init.gradle') << ''' apply { from 'other.gradle' } '''
        testFile('other.gradle') << '''
            projectsEvaluated {
                gradle.rootProject.task('doStuff')
            }
        '''
        inTestDirectory().usingInitScript(initScript).withTasks('doStuff').run()
    }

    @Test

        def swiftc4 = AvailableToolChains.getToolChain(ToolChainRequirement.SWIFTC_4)
        Assume.assumeNotNull(swiftc3, swiftc4)

        initScript.text = """
            allprojects { p ->
                apply plugin: ${swiftc3.pluginClass}

                model {
                      toolChains {
                        ${swiftc3.buildScriptConfig}

        def initial = 256
        def max = 512
        def events = eventsFor(initial, max, 35, garbageCollector.monitoringStrategy.gcRateThreshold + 0.2)
        def initScript = file("init.gradle")
        initScript << """
            ${injectionImports}

            gradle.buildFinished {
                ${eventInjectionConfiguration("heap", events, initial, max)}
            }

    def helloWorldApp = new CppCompilerDetectingTestApp()

    def setup() {
        // Discard init script content generated by superclass
        initScript.text = ""
    }

    @ToBeFixedForConfigurationCache
    def "can discover tool chain in environment"() {
        given:
        toolChain.initialiseEnvironment()

        and:
        buildFile << """

    def "can inject plugin #pluginVersion in #ci using '#ciScriptVersion' script version"() {
        def versionNumber = VersionNumber.parse(pluginVersion)
        def initScript = "init-script.gradle"
        file(initScript) << getCiInjectionScriptContent(ci)

        // URL is not relevant as long as it's valid due to the `-Dscan.dump` parameter
        file("gradle.properties") << """

abstract class KotlinInitScript(
    private val host: KotlinScriptHost<Gradle>
) : @Suppress("DEPRECATION") InitScriptApi(host.target) {

    /**
     * The [ScriptHandler] for this script.
     */
    val initscript: ScriptHandler
        get() = host.scriptHandler

    /**
     * Applies zero or more plugins or scripts.
     * <p>

        val fileTreeFromMap = """
            fileTree(mapOf("dir" to ".", "include" to listOf("*.txt")))
                .joinToString { it.name }
        """

        withFile("foo.txt")

        val initScript = withFile(
            "init.gradle.kts",
            """
            println("INIT: " + $fileTreeFromMap)
            """
        )

        withSettings(
            """

            executer.ignoreCleanupAssertions();
        }
        if (javaHome != null) {
            executer.withJavaHome(javaHome);
        }
        for (File initScript : initScripts) {
            executer.usingInitScript(initScript);
        }
        executer.withTasks(tasks);
        executer.withArguments(args);
        executer.withEnvironmentVars(environmentVars);

        then:
        succeeds 'check'

        where:
        source        | sourceFile
        "buildscript" | "build.gradle"
        "settings"    | "settings.gradle"
        "initscript"  | "init.gradle"
    }

    @ToBeFixedForConfigurationCache(because = "remote scripts skipped")
    def "can recover from failure to download cached #source resource by running with --offline"() {
        given: