}

    def "adds user #initScriptName init script when it exits"() {
        given:
        def initScript = temporaryFolder.createFile(initScriptName)
        def sourceList = []

        when:
        finder.findScripts(sourceList)

        then:
        sourceList.size == 1
        sourceList[0] == initScript

        where:
        initScriptName << ['init.gradle', 'init.gradle.kts']
    }

import org.gradle.initialization.InitScript;

public class InitScriptTarget extends DefaultScriptTarget {
    public InitScriptTarget(GradleInternal target) {
        super(target);
    }

    @Override
    public String getId() {
        return "init";
    }

    @Override
    public Class<? extends BasicScript> getScriptClass() {
        return InitScript.class;
    }

    @Override

    def "is auto-applied when --scan is used despite init script"() {
        given:
        def pluginArtifactId = "com.gradle:develocity-gradle-plugin:${plugin.runtimeVersion}"
        def initScript = file("build-scan-init.gradle") << """
            initscript {
                repositories {
                    maven { url '${mavenRepo.uri}' }
                }
                dependencies {

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

        }
    }

    def "pluginManagement block is not supported in InitScripts"() {
        given:
        def initScript = file "definePluginRepos.gradle"
        initScript << """
            pluginManagement {}
        """
        args('-I', initScript.absolutePath)

        when:
        fails 'help'

        then:
        failure.assertHasLineNumber(2)

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