class InternalBuildOperationEventsIntegrationTest extends AbstractIntegrationSpec {
    def "init script can inject listener via use internal API to subscribe to build operation events"() {
        def initScript = initScriptFile
        loggingListener(initScript)
        initScript << """
            def listener = gradle.sharedServices.registerIfAbsent("listener", LoggingListener) { }
            def registry = services.get(BuildEventsListenerRegistry)

        // <user-home>/init.d/init.gradle
        initScript(
            gradleUserHome.resolve("init.d/init.gradle"),
            "<init.d>"
        )
        // -I init.gradle
        val initScript = initScript(
            file("init.gradle"),
            "<command-line>"
        )

        // when: precompiled script plugin accessors are generated
        buildWithGradleUserHome(
            gradleUserHome,

        this.scriptHandlerFactory = scriptHandlerFactory;
    }

    @Override
    public void process(final ScriptSource initScript, GradleInternal gradle) {
        ClassLoaderScope baseScope = gradle.getClassLoaderScope();
        URI uri = initScript.getResource().getLocation().getURI();
        String id = uri == null ? idGenerator.generateId().toString() : uri.toString();

    private
    fun countUpToDatePrefixOf(
        previous: List<ConfigurationCacheFingerprint.InputFile>,
        current: List<File>
    ): Int = current.zip(previous)
        .takeWhile { (initScript, fingerprint) -> isFileUpToDate(initScript, fingerprint.hash) }
        .count()

    private
    fun checkFingerprintValueIsUpToDate(obtainedValue: ObtainedValue): InvalidationReason? {

    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 {

        final List<File> initScripts = gradle.getStartParameter().getAllInitScripts();
        if (initScripts.isEmpty()) {
            return;
        }

        buildOperationRunner.run(new RunnableBuildOperation() {
            @Override
            public void run(BuildOperationContext context) {
                for (File script : initScripts) {

        )
    }

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

        parameter.systemPropertiesArgs = [b: 'b']
        parameter.initScripts = [new File('init script'), new File("/path/to/another init script")]
        parameter.includedBuilds = [new File('participant'), new File("/path/to/another/participant")]

        when:
        def newInstance = parameter.newInstance()

        then:
        !parameter.initScripts.is(newInstance.initScripts)
        !parameter.taskNames.is(newInstance.taskNames)