yamlInfo, ok := runtime.SerializerInfoForMediaType(Codecs.SupportedMediaTypes(), runtime.ContentTypeYAML)
	if !ok {
		t.Fatalf("unable to locate encoder -- %q is not a supported media type", runtime.ContentTypeYAML)
	}
	jsonInfo, ok := runtime.SerializerInfoForMediaType(Codecs.SupportedMediaTypes(), runtime.ContentTypeJSON)
	if !ok {
		t.Fatalf("unable to locate encoder -- %q is not a supported media type", runtime.ContentTypeJSON)
	}

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

description = "Plugins for integration with native projects in XCode and Visual Studio IDEs"

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

dependencies {
    api(libs.groovy)
    api(libs.guava)
    api(libs.inject)
    api(libs.jsr305)

}

# Set up grafana
{
  # Generate all dynamic dashboards
  (
    pushd "${DASHBOARDS}" > /dev/null
    jb install
    for file in *.libsonnet; do
      dashboard="${file%.*}"
      jsonnet -J vendor -J lib "${file}" > "${dashboard}-dashboard.gen.json"
    done
  )
  helm3 template grafana grafana \
    --namespace istio-system \
    --version "${GRAFANA_VERSION}" \

            }
        """
        file("src/main/groovy/GroovyBar.groovy") << "public class GroovyBar { def bar() {} }"

        when:
        fails(":compileGroovy")

        then:
        // If the joint compilation is working correctly, we should exercise the JdkJavaCompiler and we should have detailed problems events
        verifyAll(receivedProblem(0)) {
            fqid == 'compilation:java:java-compilation-error'

	"ℭ":                         "\u212d",
	"Č":                          "\u010c",
	"Ç":                          "\u00c7",
	"Ĉ":                           "\u0108",
	"∰":                         "\u2230",
	"Ċ":                            "\u010a",
	"¸":                         "\u00b8",
	"·":                       "\u00b7",
	"ℭ":                             "\u212d",

 * that were not deleted by Gradle before annotation processing, would anyway result in full-recompilation, due to annotation processors limitations.
 * And in case of a Groovy/Java joint compilation, incremental compilation is anyway disabled, when annotation processing is present.
 */
public class CompilationClassBackupService {

    private final Set<String> classesToCompile;

@Deprecated
public interface GroovySourceSet {
    /**
     * Returns the source to be compiled by the Groovy compiler for this source set. Any Java source present in this set
     * will be passed to the Groovy compiler for joint compilation.
     *
     * @return The Groovy/Java source. Never returns null.
     */
    SourceDirectorySet getGroovy();

    /**
     * Configures the Groovy source for this set.
     *

        """.stripIndent()

        when:
        withBuildCache().run compilationTask

        then:
        compileIsNotCached()
    }

    def "joint Java and Groovy compilation can be cached"() {
        given:
        buildScript """
            plugins {
                id 'groovy'
            }

            dependencies {

import java.util.Properties

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

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

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

dependencies {
    api(project(":base-services")) {

        val extension = this.extensions.create<ErrorProneSourceSetExtension>("errorprone", project.objects.property<Boolean>())
        // Enable it only for the main source set by default, as incremental Groovy
        // joint-compilation doesn't work with the Error Prone annotation processor
        extension.enabled.convention(this.name == "main")

        project.dependencies.addProvider(
            annotationProcessorConfigurationName,