}
          }
        """
        args('-I', initScript.absolutePath)

        when:
        succeeds('pluginTask')

        then:
        output.contains('from plugin')
    }

    def "Can't modify rules after projects have been loaded"() {
        given:
        def initScript = file('definePluginRepo.gradle')
        initScript << """
          Settings mySettings

    }
}


/**
 * Base class for `initscript` block evaluation on scripts targeting Gradle.
 */
@ImplicitReceiver(Gradle::class)
open class CompiledKotlinInitscriptBlock(
    host: KotlinScriptHost<Gradle>
) : CompiledKotlinInitScript(host) {

    /**
     * Configures the classpath of the init script.
     */
    fun initscript(block: ScriptHandlerScope.() -> Unit) {

    private final File initScript

    BuildOperationNotificationsFixture(GradleExecuter executer, TestDirectoryProvider projectDir) {
        this.initScript = projectDir.testDirectory.file(FIXTURE_SCRIPT_NAME)
        this.initScript.text = injectNotificationListenerBuildLogic()
        executer.beforeExecute {
            it.usingInitScript(this.initScript)
        }
    }

        def initScript = initScript """
allprojects {
    throw new RuntimeException("broken")
}
"""
        when:
        executer.usingInitScript(initScript)
        fails "a"

        then:
        failure.assertHasDescription("broken")
                .assertHasNoCause()
                .assertHasFileName("Initialization script '$initScript'")
                .assertHasLineNumber(3)
    }

    def "init scripts see the root project before it is evaluated"() {
        given:
        settingsFile << """
            rootProject.name = 'root'
        """
        def initScript = file("init.gradle") << """
            rootProject { root ->
                if (root.state.executed) {
                    throw new IllegalStateException("Root project should not be evaluated too early")
                }

    def setup() {
        assumeTrue("Swift toolchain is available", swiftToolChain != null)
        assumeTrue("C++ toolchain is available", cppToolChain != null)

        File initScript = file("init.gradle") << """
        allprojects { p ->
            p.plugins.withType(${swiftToolChain.pluginClass}) {
                model {
                    toolChains {

        given:
        def events = ProgressEvents.create()
        settingsFile << "rootProject.name = 'single'"
        def initScript = file('init.gradle')
        buildFile << ""
        initScript << """
            apply plugin: ExamplePlugin

            class ExamplePlugin implements Plugin<Object> {
                void apply(Object target) { }
            }

        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")) {