val source = programSourceWith(" initscript { println(\"Stage 1\") } ")

        assertProgramOf(
            source,
            Program.Buildscript(source.fragment(1..10, 12..33)),
            programTarget = ProgramTarget.Gradle
        )
    }

    @Test
    fun `non empty Gradle script with initscript block`() {

        val source =

        def gradleUserHome = userHome.file(".gradle")

        and:
        gradleUserHome.file("gradle.properties") << 'myProp1=propertiesFile'
        gradleUserHome.file("init.gradle") << 'allprojects { ext.myProp2 = \'initScript\' }'

        and:
        buildScript """
            task check {
                doLast {
                    // Uses testkit dir

import static org.gradle.integtests.fixtures.RepoScriptBlockUtil.gradlePluginRepositoryMirrorUrl;

public class SetMirrorsSampleModifier implements SampleModifier {

    private final File initScript = RepoScriptBlockUtil.createMirrorInitScript();

    @Override
    public Sample modify(Sample sample) {
        if (sample.getId().contains("usePluginsInInitScripts")) {

    }

    void useXcodebuildTool() {
        executer.requireDaemon().requireIsolatedDaemons()

        def initScript = file("init.gradle")
        initScript << IdeCommandLineUtil.generateGradleProbeInitFile('xcode', 'xcodebuild')

        executer.beforeExecute({
            usingInitScript(initScript)
        })
    }

    // TODO: Use AbstractInstalledToolChainIntegrationSpec instead once Xcode test are sorted out

        settingsFile << """
            plugins {
                id("test.remote-settings-plugin").version("1.0")
            }
        """

        def initScript = file("init.gradle")
        initScript << """
            settingsEvaluated { settings ->
                settings.pluginManagement {
                    repositories {
                        exclusiveContent {

Init scripts can also declare dependencies with the `initscript()` method, passing in a closure that declares the init script classpath.

Declaring external dependencies for an init script:

====
include::sample[dir="snippets/initScripts/externalDependency/kotlin",files="init.gradle.kts[tags=declare-classpath]"]
include::sample[dir="snippets/initScripts/externalDependency/groovy",files="init.gradle[tags=declare-classpath]"]
====

    static AvailableToolChains.InstalledToolChain toolChain
    File initScript

    AvailableToolChains.InstalledToolChain getToolchainUnderTest() { toolChain }

    def setup() {
        initScript = file("init.gradle") << """
            allprojects { p ->
                apply plugin: ${toolChain.pluginClass}

                model {

            ProgramTarget.Settings -> arrayOf(buildscript, pluginManagement, plugins)
            ProgramTarget.Gradle -> arrayOf(initscript)
        }

        fun buildscriptIdFor(target: ProgramTarget) = when (target) {
            ProgramTarget.Gradle -> initscript
            ProgramTarget.Settings -> buildscript
            ProgramTarget.Project -> buildscript
        }
    }
}


internal

    }

    def "init scripts cannot have plugin blocks"() {
        def initScript = file("init.gradle")

        when:
        initScript << "plugins {}"

        then:
        args "-I", initScript.absolutePath
        fails "help"

        failure.assertHasLineNumber 1
        failure.assertHasFileName("Initialization script '$initScript.absolutePath'")

            task("dummy")
        """

        and:
        def initScript = file("init.gradle") << """
            beforeSettings {
                it.with { ${fixture.pluginManagement()} }
            }
        """

        fixture.publishDummyPlugin(executer)

        when:
        args("--${BuildScanOption.LONG_OPTION}", "-I", initScript.absolutePath)
        succeeds('dummy')

        then: