* 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();

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

    options.release = provider {
        throw GradleException("This task '${name}' is not associated with a compilation. Associate it with a compilation on the '${JvmCompileExtension.NAME}' extension.")
    }
}

val gradleModule = the<GradleModuleExtension>()
the<JvmCompileExtension>().apply {
    compilations {
        configureEach {
            // Everything compiles to Java 17 by default
            targetJvmVersion = 17

 *
 * @since 4.0.0
 */
@Experimental
public enum JavaPathType implements PathType {
    /**
     * The path identified by the Java {@code --class-path} option.
     * Used for compilation, execution and Javadoc among others.
     * The Java tools location is {@link StandardLocation#CLASS_PATH}.
     *
     * <h4>Context-sensitive interpretation</h4>

    nums.add(3);
    Predicate<Integer> isThree = Predicates.in(nums);
    assertFalse(isThree.apply(3));
  }

  /*
   * Tests that compilation will work when applying explicit types.
   */
  @SuppressWarnings("unused") // compilation test
  public void testIn_compilesWithExplicitSupertype() {
    Collection<Number> nums = ImmutableSet.of();
    Predicate<Number> p1 = Predicates.in(nums);

    private static final double TIMING_TOLERANCE = 2.0; // 200% tolerance - JVM timing is inherently variable for timing variations

    @BeforeEach
    public void setUp() {
        // Warm up JVM to reduce JIT compilation effects
        for (int i = 0; i < 100; i++) {
            NtlmPasswordAuthenticator auth1 = new NtlmPasswordAuthenticator("testdomain", "testuser", "password123");

    "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" ]
      }
    } ]
  }, {

- plugin dependency metadata missing
- plugin dependency metadata retrieval problem
- plugin configuration problem
- plugin execution failure due to something that is known to possibly go wrong (like compilation failure)
- plugin execution error due to something that is not expected to go wrong (the compiler executable missing)
- asking to use a plugin for which you do not have a version defined - tools to easily select versions

      True, ('Would you like to override eigen strong inline for some C++ '
             'compilation to reduce the compilation time?'),
      'Eigen strong inline overridden.', 'Not overriding eigen strong inline, '
      'some compilations could take more than 20 mins.'):
    # Due to a known MSVC compiler issue
    # https://github.com/tensorflow/tensorflow/issues/10521

#ifdef __cplusplus
extern "C" {
#endif

// When `enable` is true, set
// tensorflow.ConfigProto.OptimizerOptions.global_jit_level to ON_1, and also
// set XLA flag values to prepare for XLA compilation. Otherwise set
// global_jit_level to OFF.
//
// This and the next API are syntax sugar over TF_SetConfig(), and is used by
// clients that cannot read/write the tensorflow.ConfigProto proto.