if (customSettingsFile != null) {
            validateIsFileAndExists(customSettingsFile, "settings file");
        }
        for (File initScript : startParameter.getInitScripts()) {
            validateIsFileAndExists(initScript, "initialization script");
        }

        return delegate.execute(action, actionParameters, requestContext);
    }

        file("settings$settingScriptExtension") << use
        def initScript = file("init.gradle") << """
            settingsEvaluated {
                println it.buildscript.classLoader.loadClass("${pluginBuilder.packageName}.TestSettingsPlugin").name
            }
        """

        when:
        executer.usingInitScript(initScript)
        succeeds 'help'

        then:

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