Run CI on Java 17

.github/workflows/ci.yml

@@ -26,7 +26,7 @@ jobs:
     # Definition of the build matrix
     strategy:
       matrix:
-        java: [8, 11, 15]
+        java: [8, 11, 17]
         mock-maker: ['mock-maker-default', 'mock-maker-inline']
 
     # All build steps
@@ -41,7 +41,7 @@ jobs:
     - name: 2. Set up Java ${{ matrix.java }}
       uses: actions/setup-java@v2
       with:
-        distribution: 'adopt'
+        distribution: 'zulu'
         java-version: ${{ matrix.java }}
 
     - name: 3. Validate Gradle wrapper

gradle/root/coverage.gradle

@@ -19,7 +19,7 @@ task mockitoCoverage(type: JacocoReport) {
             apply plugin: "jacoco"
 
             jacoco {
-                toolVersion = '0.8.6'
+                toolVersion = '0.8.7'
 
                 if (currentProject != rootProject) {   //already automatically enhanced in mockito main project as "java" plugin was applied before
                     applyTo test

settings.gradle.kts

@@ -19,7 +19,7 @@ include("deprecatedPluginsTest",
     "junitJupiterParallelTest",
     "osgi-test")
 
-if (System.getenv("ANDROID_SDK_ROOT") != null || File(".local.properties").exists()) {
+if (!JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_17) && (System.getenv("ANDROID_SDK_ROOT") != null || File(".local.properties").exists())) {
     include("androidTest")
 } else {
     logger.info("Not including android test project due to missing SDK configuration")

src/test/java/org/mockito/internal/creation/bytebuddy/SubclassByteBuddyMockMakerTest.java

@@ -4,13 +4,6 @@
  */
 package org.mockito.internal.creation.bytebuddy;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.util.Observable;
-import java.util.Observer;
-
 import net.bytebuddy.ByteBuddy;
 import net.bytebuddy.ClassFileVersion;
 import net.bytebuddy.description.modifier.TypeManifestation;
@@ -19,6 +12,13 @@
 import org.mockito.internal.creation.MockSettingsImpl;
 import org.mockito.plugins.MockMaker;
 
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.util.Observable;
+import java.util.Observer;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
 public class SubclassByteBuddyMockMakerTest
         extends AbstractByteBuddyMockMakerTest<SubclassByteBuddyMockMaker> {
 
@@ -35,22 +35,16 @@ public void is_type_mockable_excludes_primitive_wrapper_classes() {
 
     @Test
     public void is_type_mockable_excludes_sealed_classes() {
-        // is only supported on Java 17 and later
         if (ClassFileVersion.ofThisVm().isAtMost(ClassFileVersion.JAVA_V16)) {
             return;
         }
-        DynamicType.Builder<Object> base = new ByteBuddy().subclass(Object.class);
-        DynamicType.Unloaded<Object> dynamic =
-                new ByteBuddy()
-                        .subclass(Object.class)
-                        .permittedSubclass(base.toTypeDescription())
-                        .make();
+        DynamicType.Builder<?> base = new ByteBuddy().subclass(Object.class);
+        DynamicType.Builder<?> subclass =
+                new ByteBuddy().subclass(base.toTypeDescription()).merge(TypeManifestation.FINAL);
         Class<?> type =
-                new ByteBuddy()
-                        .subclass(base.toTypeDescription())
-                        .merge(TypeManifestation.FINAL)
+                base.permittedSubclass(subclass.toTypeDescription())
                         .make()
-                        .include(dynamic)
+                        .include(subclass.make())
                         .load(null)
                         .getLoaded();
         MockMaker.TypeMockability mockable = mockMaker.isTypeMockable(type);

src/test/java/org/mockito/internal/util/reflection/GenericMetadataSupportTest.java

@@ -116,16 +116,16 @@ public void can_get_raw_type_from_ParameterizedType() {
     public void can_get_type_variables_from_Class() {
         assertThat(inferFrom(GenericsNest.class).actualTypeArguments().keySet())
                 .hasSize(1)
-                .extracting("name")
+                .extracting(TypeVariable::getName)
                 .contains("K");
         assertThat(inferFrom(ListOfNumbers.class).actualTypeArguments().keySet()).isEmpty();
         assertThat(inferFrom(ListOfAnyNumbers.class).actualTypeArguments().keySet())
                 .hasSize(1)
-                .extracting("name")
+                .extracting(TypeVariable::getName)
                 .contains("N");
         assertThat(inferFrom(Map.class).actualTypeArguments().keySet())
                 .hasSize(2)
-                .extracting("name")
+                .extracting(TypeVariable::getName)
                 .contains("K", "V");
         assertThat(inferFrom(Serializable.class).actualTypeArguments().keySet()).isEmpty();
         assertThat(inferFrom(StringList.class).actualTypeArguments().keySet()).isEmpty();
@@ -153,21 +153,21 @@ public void can_get_type_variables_from_ParameterizedType() {
                                 .actualTypeArguments()
                                 .keySet())
                 .hasSize(2)
-                .extracting("name")
+                .extracting(TypeVariable::getName)
                 .contains("K", "V");
         assertThat(
                         inferFrom(ListOfAnyNumbers.class.getGenericInterfaces()[0])
                                 .actualTypeArguments()
                                 .keySet())
                 .hasSize(1)
-                .extracting("name")
+                .extracting(TypeVariable::getName)
                 .contains("E");
         assertThat(
                         inferFrom(Integer.class.getGenericInterfaces()[0])
                                 .actualTypeArguments()
                                 .keySet())
                 .hasSize(1)
-                .extracting("name")
+                .extracting(TypeVariable::getName)
                 .contains("T");
         assertThat(
                         inferFrom(StringBuilder.class.getGenericInterfaces()[0])

src/test/java/org/mockitousage/serialization/AcrossClassLoaderSerializationTest.java

@@ -11,6 +11,7 @@
 import java.util.List;
 import java.util.concurrent.Callable;
 
+import net.bytebuddy.ClassFileVersion;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mockito;
@@ -31,6 +32,10 @@ public void reproduce_CCE_by_creating_a_mock_with_IMethods_before() throws Excep
     @Test
     public void check_that_mock_can_be_serialized_in_a_classloader_and_deserialized_in_another()
             throws Exception {
+        // No longer supported starting with JDK 16+
+        if (!ClassFileVersion.ofThisVm().isAtMost(ClassFileVersion.JAVA_V16)) {
+            return;
+        }
         byte[] bytes = create_mock_and_serialize_it_in_class_loader_A();
 
         Object the_deserialized_mock = read_stream_and_deserialize_it_in_class_loader_B(bytes);

src/test/java/org/mockitoutil/SimpleSerializationUtil.java

@@ -6,7 +6,12 @@
 
 import static org.junit.Assert.assertNotNull;
 
-import java.io.*;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 
 public abstract class SimpleSerializationUtil {
 

subprojects/memory-test/memory-test.gradle

@@ -15,5 +15,4 @@ tasks.javadoc.enabled = false
 
 test {
     maxHeapSize = "128m"
-    jvmArgs = ["-XX:MaxPermSize=128m"]
 }