}
            }
        """)
        def pluginJar = file("plugin.jar")
        pluginBuilder.publishTo(executer, pluginJar)

        initScript """
            initscript {
                dependencies {
                    classpath files("${pluginJar.name}")
                }
            }
            beforeSettings {
                it.plugins.apply(test.SettingsPlugin)

            writer.write(value, trace)
        }

        fun initScripts(initScripts: List<File>) {
            capturedFiles.addAll(initScripts)
            write(
                ConfigurationCacheFingerprint.InitScripts(
                    initScripts.map(::inputFile)
                )
            )
        }
    }

    private
    class ProjectScopedSink(

    }

    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