}
        """
        buildFile << customTaskCode()

        expect:
        executer.withBuildCacheEnabled().usingInitScript(initScript)
        succeeds("customTask")
        !localBuildCache.empty
    }

    def "can enable with init script"() {
        def initScript = file("initBuildCache.gradle") << """
            gradle.startParameter.buildCacheEnabled = true
            gradle.settingsEvaluated { settings ->

        )
    }

    @Test
    fun `Gradle target - top-level - initscript block - non-empty body`() {

        val initscript = fragment("initscript", "...")
        val body = ProgramSource("init.gradle.kts", "...")

        val program = Program.Staged(
            Program.Stage1Sequence(null, Program.Buildscript(initscript), null),
            Program.Script(body)
        )

        assertThat(

            if (withReproducibleArchives) {
                AbstractIntegrationSpec instance = invocation.instance as AbstractIntegrationSpec
                def initScript = instance.testDirectory.file('reproducible-archives-init.gradle')
                initScript.text = """
                        rootProject { prj ->
                            allprojects {
                                tasks.withType(AbstractArchiveTask) {

    def 'init scripts passed on the command line are applied to buildSrc'() {
        given:
        settingsFile << "rootProject.name = 'hello'"
        createProject()
        file("init.gradle") << initScript()

        executer.usingInitScript(file('init.gradle'))

        when:
        succeeds 'hello'

        then:
        output.contains("Project buildSrc evaluated")

    }
}


/**
 * 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) {

              }
          }
        """
        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

        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)
    }

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