then:
        thrown(BuildException)
        listener.problems.size() == 0
    }

    @ToolingApiVersion(">=8.7 <8.9")
    @TargetGradleVersion("=8.7")
    def "Can serialize groovy compilation error"() {
        buildFile """
            tasks.register("foo) {
        """

        given:
        def listener = new ProblemProgressListener()

        when:
        withConnection {

        return false;
    }

    private void buildProblemFrom(RuntimeException ex, ProblemSpec spec) {
        spec.severity(Severity.ERROR);
        spec.id("initialization-failed", "Java compilation initialization error", GradleCoreProblemGroup.compilation().java());
        spec.details(ex.getLocalizedMessage());
        spec.withException(ex);
    }

plugins {
    id("gradlebuild.distribution.api-java")
}

description = "Plugins and integration with code quality (Checkstyle, PMD, CodeNarc)"

sourceSets {
    main {
        // Incremental Groovy joint-compilation doesn't work with the Error Prone annotation processor
        errorprone.enabled = false
    }
}

dependencies {
    api(projects.stdlibJavaExtensions)
    api(project(":base-services"))

plugins {
    id("gradlebuild.internal.java")
}

description = "Collection of test fixtures for performance tests, internal use only"

sourceSets {
    main {
        // Incremental Groovy joint-compilation doesn't work with the Error Prone annotation processor
        errorprone.enabled = false
    }
}

val reports by configurations.creating
val flamegraph by configurations.creating

     * {@code [varInitializer, processCreator, expectedPwdSuffix, expectedEnvVar]}.
     * @return the list of test cases
     */
    abstract def testCases()

    /**
     * Produces a list of indy compilation modes. Each test case from {@link #testCases()} will run in every mode from the returned list.
     * @return the list of indy modes
     */
    def indyModes() {
        return [true, false]
    }

                }
            }
        """)

        val result = buildAndFail("classes")

        result.assertHasFailure("Execution failed for task ':compileKotlin'.") {
            it.assertHasCause("Compilation error. See log for more details")
        }
        result.assertHasErrorOutput("src/main/kotlin/code.kt:7:25 Unresolved reference. None of the following candidates is applicable because of receiver type mismatch")
    }

        throw ((InternalProblems) getProblemsService()).getInternalReporter().throwing(builder -> builder
            .id(TextUtil.screamingSnakeToKebabCase("compilation-failed"), "Groovy DSL script compilation problem", GradleCoreProblemGroup.compilation().groovyDsl())
            .contextualLabel(message)
            .lineInFileLocation(source.getFileName(), lineNumber)
            .severity(Severity.ERROR)

        ''                         | null            | ''                                          | null
    }

    def "Can serialize groovy compilation error"() {
        buildFile """
            tasks.register("foo) {
        """

        given:
        def listener = new ProblemProgressListener()

        when:
        withConnection {

        assertToolchainUsages(events1, jdkMetadata1, "JavaLauncher")
        assertToolchainUsages(events2, jdkMetadata2, "JavaLauncher")
    }

    def "emits toolchain usages for compilation that configures #option via fork options"() {
        JvmInstallationMetadata curJdk = AvailableJavaHomes.getJvmInstallationMetadata(Jvm.current())

import javax.annotation.OverridingMethodsMustInvokeSuper;
import java.io.File;
import java.util.Map;

import static java.util.Objects.requireNonNull;

/**
 * A base class that represents a work for compilation for Kotlin and Groovy build scripts.
 * This work unit first compiles the build script to a directory, and then instruments the directory for configuration cache and returns instrumented output.
 */