* mentioned in the method Javadoc does in fact compile.
   */

  @SuppressWarnings("unused") // compilation test
  public void testSampleCodeError1() {
    Optional<Integer> optionalInt = getSomeOptionalInt();
    // Number value = optionalInt.or(0.5); // error
  }

  @SuppressWarnings("unused") // compilation test
  public void testSampleCodeError2() {
    FluentIterable<? extends Number> numbers = getSomeNumbers();

and there are no missing null checks.

## Decision

Use "NullAway" in JSpecify mode to check for null-related errors in Java code.

Consider improper uses of `null` detected by NullAway a compilation error (not a warning, and not a separate CI job to test).

Do not suppress NullAway errors without a justification.

    // not needed when compiling with recent JDKs, e.g. 17
    options.compilerArgs.add("-Xlint:-requires-transitive-automatic")

    // Patch the compileKotlinJvm output classes into the compilation so exporting packages works correctly.
    options.compilerArgs.addAll(
      listOf(
        "--patch-module",
        "$moduleName=${compileKotlinTask.destinationDirectory.get().asFile}",
      ),
    )

val compileJavaModuleInfo by tasks.registering(JavaCompile::class) {
  val moduleName = "okhttp3"
  val compilation = kotlin.targets["jvm"].compilations["main"]
  val compileKotlinTask = compilation.compileTaskProvider.get() as KotlinJvmCompile
  val targetDir = compileKotlinTask.destinationDirectory.dir("../java9")
  val sourceDir = file("src/jvmMain/java9/")

        <dslContextParameter.branch>master</dslContextParameter.branch>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- https://kotlinlang.org/docs/maven.html#enable-incremental-compilation -->
        <kotlin.compiler.incremental>true</kotlin.compiler.incremental>
    </properties>
    <groupId>Gradle_Check</groupId>
    <artifactId>Gradle_Check_dsl</artifactId>
    <version>1.0-SNAPSHOT</version>

            // or restricted access to system resources. This is acceptable.
            // We primarily want to ensure the method can be called without compilation errors

            // Log the exception for debugging purposes but don't fail the test
            System.out.println("Expected exception in test environment: " + t.getClass().getSimpleName() + ": " + t.getMessage());

 */
val keepPatterns = mapOf(
    "it.unimi.dsi:fastutil" to setOf(
        // For persistence cache
        "it.unimi.dsi.fastutil.longs.Long2IntOpenHashMap",
        // For Java compilation incremental analysis
        "it.unimi.dsi.fastutil.ints.IntOpenHashSet",
        "it.unimi.dsi.fastutil.ints.IntSets",
        // For the embedded Kotlin compiler
        "it.unimi.dsi.fastutil.ints.Int2ObjectMap",

            "errorprone",
            project.objects.property<Boolean>()
        ).apply {
            // Enable it only for the main source set by default, as incremental Groovy
            // joint-compilation doesn't work with the Error Prone annotation processor
            enabled.convention(isMainSourceSet)
        }

        if (isMainSourceSet) {

                        classLoader.close();
                    } catch (final IOException closeEx) {
                        logger.warn("Failed to close GroovyClassLoader after compilation failure", closeEx);
                    }
                    throw e;
                }
            });
        } catch (final ExecutionException e) {
            throw (RuntimeException) e.getCause();

    "groups" : [ {
      "testProject" : "largeJavaMultiProject",
      "comment" : "We only test the multi-project here since for the monolithic project we would have no cache hits. This would mean we actually would test incremental compilation.",
      "coverage" : {
        "per_commit" : [ "linux" ]
      }
    } ]
  }, {