}

    def "captures gradle plugin"() {
        when:
        def initScript = file("init.gradle") << """
            class MyPlugin implements Plugin {
                void apply(t) {}
            }

            apply plugin: MyPlugin
        """

        succeeds("help", "-I", initScript.absolutePath)

        then:
        def ops = operations.all(ApplyPluginBuildOperationType) {

    }

    def "listener registered from init script can receive task completion events from buildSrc and main build"() {
        def initScript = initScriptFile
        loggingListener(initScript)
        initScript << """
            if (gradle.parent == null) {
                def listener = gradle.sharedServices.registerIfAbsent("listener", LoggingListener) { }

        executer.beforeExecute {
            def initScript = file("init.gradle")
            initScript.text = buildLogicForMinimumBuildTime(minimumBuildTimeMillis)
            withArgument("-I").withArgument(initScript.absolutePath)
        }
    }

    protected int getMinimumBuildTimeMillis() {
        2000
    }

            }
        """.stripIndent()

        when:
        executer.expectDeprecationWarnings(1)
        executer.usingInitScript(initScript)
        run '-s'

        then:
        output.contains("Initialization script '${initScript}': line 3")
        output.contains('init.gradle:3)')

        output.count(PLUGIN_DEPRECATION_MESSAGE) == 1

        output.count('\tat') == 1

        assumeTrue(toolChain != null)

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

    model {
          toolChains {
            ${toolChain.buildScriptConfig}
          }
    }
}
"""
        executer.beforeExecute({
            usingInitScript(initScript)
        })

        settingsFile << "rootProject.name = 'app'"

    }
}


private
fun buildInitScriptModel(initScript: File, rootProject: ProjectInternal): NonProjectScriptModel {
    val gradle = rootProject.gradle

    val (scriptHandler, scriptClassPath) = compilationClassPathForScriptPluginOf(
        target = gradle,
        scriptFile = initScript,
        baseScope = gradle.classLoaderScope,

 */
package org.gradle.configuration;

import org.gradle.groovy.scripts.ScriptSource;
import org.gradle.api.internal.GradleInternal;

public interface InitScriptProcessor {
    void process(ScriptSource initScript, GradleInternal gradle);

    @Issue('GRADLE-3553')
    @LeaksFileHandles
    def "init-script with project dependent classpath and included build"() {
        given:
        file('gradle-user-home/init.gradle') << """
            initscript {
                ${mavenCentralRepository()}

                File searchDir = gradle.startParameter.projectDir ?: gradle.startParameter.currentDir
                def version = new File(searchDir, 'version.txt').text

class KotlinDslAssignmentIntegrationTest : AbstractKotlinIntegrationTest() {

    @Test
    fun `can use assignment for properties in init scripts`() {
        val initScript = withInitScriptWithAssignment()

        // Expect
        build("-I", initScript.absolutePath).apply {
            assertOutputContains("Init property value: Hello world")
        }
    }

    @Test

        // In real builds (we do not redirect output normally), msbuild and VS do not hang like this.
        executer.requireIsolatedDaemons().requireDaemon()

        initScript << IdeCommandLineUtil.generateGradleProbeInitFile('visualStudio', 'msbuild')
        initScript << """
            allprojects { p ->
                p.plugins.withType(VisualStudioPlugin.class) {
                    p.tasks.withType(GenerateProjectFileTask) {