Bump versions.errorprone from 2.10.0 to 2.11.0

build.gradle

@@ -52,8 +52,10 @@ allprojects { proj ->
         mavenCentral()
         google()
     }
-    plugins.withId('java') {
-        proj.apply from: "$rootDir/gradle/errorprone.gradle"
+    if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_11)) {
+        plugins.withId('java') {
+            proj.apply from: "$rootDir/gradle/errorprone.gradle"
+        }
     }
     tasks.withType(JavaCompile) {
         //I don't believe those warnings add value given modern IDEs

gradle/dependencies.gradle

@@ -6,7 +6,7 @@ def versions = [:]
 
 versions.bytebuddy = '1.12.7'
 versions.junitJupiter = '5.8.2'
-versions.errorprone = '2.10.0'
+versions.errorprone = '2.11.0'
 
 libraries.junit4 = 'junit:junit:4.13.2'
 libraries.junitJupiterApi = "org.junit.jupiter:junit-jupiter-api:${versions.junitJupiter}"

settings.gradle.kts

@@ -14,11 +14,16 @@ include("inline",
     "junitJupiterInlineMockMakerExtensionTest",
     "module-test",
     "memory-test",
-    "errorprone",
     "junitJupiterParallelTest",
     "osgi-test",
     "bom")
 
+if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_11)) {
+    include("errorprone")
+} else {
+    logger.info("Not including errorprone, which requires minimum JDK 11+")
+}
+
 if (!JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_17) && (System.getenv("ANDROID_SDK_ROOT") != null || File(".local.properties").exists())) {
     include("androidTest")
 } else {

src/test/java/org/mockitousage/stubbing/StubbingWithThrowablesTest.java

@@ -24,6 +24,7 @@
 import java.util.Map;
 
 import org.assertj.core.api.Assertions;
+import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.exceptions.base.MockitoException;
@@ -248,34 +249,34 @@ public void shouldNotAllowSettingNullThrowableArray() {
                 .hasMessageContaining("Cannot stub with null throwable");
     }
 
-    @Test
-    public void shouldNotAllowSettingNullThrowableClass() {
-        assertThatThrownBy(
-                        () -> {
-                            when(mock.isEmpty()).thenThrow((Class) null);
-                        })
+    private void assertExceptionTypeCanNotBeNull(ThrowingCallable throwingCallable) {
+        assertThatThrownBy(throwingCallable)
                 .isInstanceOf(MockitoException.class)
                 .hasMessageContaining("Exception type cannot be null");
     }
 
+    @Test
+    public void shouldNotAllowSettingNullThrowableClass() {
+        assertExceptionTypeCanNotBeNull(
+                () -> {
+                    when(mock.isEmpty()).thenThrow((Class) null);
+                });
+    }
+
     @Test
     public void shouldNotAllowSettingNullThrowableClasses() {
-        assertThatThrownBy(
-                        () -> {
-                            when(mock.isEmpty()).thenThrow(RuntimeException.class, (Class[]) null);
-                        })
-                .isInstanceOf(MockitoException.class)
-                .hasMessageContaining("Exception type cannot be null");
+        assertExceptionTypeCanNotBeNull(
+                () -> {
+                    when(mock.isEmpty()).thenThrow(RuntimeException.class, (Class[]) null);
+                });
     }
 
     @Test
     public void shouldNotAllowSettingNullVarArgThrowableClass() {
-        assertThatThrownBy(
-                        () -> {
-                            when(mock.isEmpty()).thenThrow(RuntimeException.class, (Class) null);
-                        })
-                .isInstanceOf(MockitoException.class)
-                .hasMessageContaining("Exception type cannot be null");
+        assertExceptionTypeCanNotBeNull(
+                () -> {
+                    when(mock.isEmpty()).thenThrow(RuntimeException.class, (Class) null);
+                });
     }
 
     @Test

subprojects/errorprone/src/main/java/org/mockito/errorprone/bugpatterns/MockitoAnyIncorrectPrimitiveType.java

@@ -49,7 +49,7 @@ public class MockitoAnyIncorrectPrimitiveType extends AbstractMockitoAnyForPrimi
   };
 
   private static final Matcher<ExpressionTree> METHOD_MATCHER =
-      staticMethod().onClassAny(CLASS_NAMES).withNameMatching(METHOD_NAME_PATTERN).withParameters();
+      staticMethod().onClassAny(CLASS_NAMES).withNameMatching(METHOD_NAME_PATTERN).withNoParameters();
 
   @Override
   protected Matcher<? super MethodInvocationTree> matcher() {