Switch the default mockmaker to the inline mockmaker on JDK 17+. Fixes …

…mockito#2589 Signed-off-by: Andriy Redko <drreta@gmail.com>
reta · Dec 31, 2022 · 30324fb · 30324fb
1 parent ffb294c
commit 30324fb
Show file tree

Hide file tree

Showing 12 changed files with 97 additions and 9 deletions.
diff --git a/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java b/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java
@@ -28,13 +28,14 @@ public class DefaultMockitoPlugins implements MockitoPlugins {
     static final String SUBCLASS_ALIAS = MockMakers.SUBCLASS;
     public static final Set<String> MOCK_MAKER_ALIASES = new HashSet<>();
     static final String MODULE_ALIAS = "member-accessor-module";
+    static final String REFLECTION_ALIAS = "member-accessor-reflection";
 
     static {
         // Keep the mapping: plugin interface name -> plugin implementation class name
         DEFAULT_PLUGINS.put(PluginSwitch.class.getName(), DefaultPluginSwitch.class.getName());
         DEFAULT_PLUGINS.put(
                 MockMaker.class.getName(),
-                "org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker");
+                "org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker");
         DEFAULT_PLUGINS.put(
                 StackTraceCleanerProvider.class.getName(),
                 "org.mockito.internal.exceptions.stacktrace.DefaultStackTraceCleanerProvider");
@@ -53,9 +54,11 @@ public class DefaultMockitoPlugins implements MockitoPlugins {
                 MockitoLogger.class.getName(), "org.mockito.internal.util.ConsoleMockitoLogger");
         DEFAULT_PLUGINS.put(
                 MemberAccessor.class.getName(),
-                "org.mockito.internal.util.reflection.ReflectionMemberAccessor");
+                "org.mockito.internal.util.reflection.ModuleMemberAccessor");
         DEFAULT_PLUGINS.put(
                 MODULE_ALIAS, "org.mockito.internal.util.reflection.ModuleMemberAccessor");
+        DEFAULT_PLUGINS.put(
+                REFLECTION_ALIAS, "org.mockito.internal.util.reflection.ReflectionMemberAccessor");
         DEFAULT_PLUGINS.put(
                 DoNotMockEnforcer.class.getName(),
                 "org.mockito.internal.configuration.DefaultDoNotMockEnforcer");

diff --git a/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java b/src/main/java/org/mockito/internal/creation/bytebuddy/InlineBytecodeGenerator.java
@@ -205,6 +205,7 @@ public <T> Class<? extends T> mockClass(MockFeatures<T> features) {
         boolean subclassingRequired =
                 !features.interfaces.isEmpty()
                         || features.serializableMode != SerializableMode.NONE
+                        || features.stripAnnotations
                         || Modifier.isAbstract(features.mockedType.getModifiers());
 
         checkSupportedCombination(subclassingRequired, features);
@@ -416,6 +417,7 @@ public synchronized void clearAllCaches() {
         }
         mocked.clear();
         flatMocked.clear();
+        subclassEngine.clearAllCaches();
         try {
             instrumentation.retransformClasses(types.toArray(new Class<?>[0]));
         } catch (UnmodifiableClassException e) {

diff --git a/src/main/java/org/mockito/internal/util/reflection/InstrumentationMemberAccessor.java b/src/main/java/org/mockito/internal/util/reflection/InstrumentationMemberAccessor.java
@@ -188,7 +188,16 @@ public Object newInstance(
                     onConstruction.invoke(
                             () -> {
                                 try {
-                                    return DISPATCHER.invokeWithArguments(handle, arguments);
+                                    // Use handle.asFixedArity() to handle varargs bindings properly
+                                    // (as by default Java will create method handle with
+                                    // asVarargsCollector), fe:
+                                    //
+                                    //   private static class Varargs {
+                                    //     Varargs(String whatever, Observer... observers) {
+                                    //     }
+                                    //   }
+                                    return DISPATCHER.invokeWithArguments(
+                                            handle.asFixedArity(), arguments);
                                 } catch (Throwable throwable) {
                                     thrown.set(true);
                                     return throwable;

diff --git a/src/test/java/org/mockito/MockitoTest.java b/src/test/java/org/mockito/MockitoTest.java
@@ -7,16 +7,21 @@
 import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.not;
 import static org.mockito.Mockito.times;
 import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
 
 import java.util.List;
 
+import org.junit.Assume;
 import org.junit.Test;
 import org.mockito.exceptions.base.MockitoException;
 import org.mockito.exceptions.misusing.NotAMockException;
 import org.mockito.exceptions.misusing.NullInsteadOfMockException;
+import org.mockito.internal.configuration.plugins.Plugins;
 import org.mockito.internal.creation.MockSettingsImpl;
+import org.mockito.plugins.InlineMockMaker;
 
 @SuppressWarnings("unchecked")
 public class MockitoTest {
@@ -99,6 +104,8 @@ public void shouldValidateMockWhenCreatingInOrderObject() {
     @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldGiveExplanationOnStaticMockingWithoutInlineMockMaker() {
+        Assume.assumeThat(Plugins.getMockMaker(), not(instanceOf(InlineMockMaker.class)));
+
         assertThatThrownBy(
                         () -> {
                             Mockito.mockStatic(Object.class);
@@ -114,6 +121,8 @@ public void shouldGiveExplanationOnStaticMockingWithoutInlineMockMaker() {
     @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldGiveExplanationOnConstructionMockingWithoutInlineMockMaker() {
+        Assume.assumeThat(Plugins.getMockMaker(), not(instanceOf(InlineMockMaker.class)));
+
         assertThatThrownBy(
                         () -> {
                             Mockito.mockConstruction(Object.class);
@@ -126,6 +135,20 @@ public void shouldGiveExplanationOnConstructionMockingWithoutInlineMockMaker() {
                         "Note that Mockito's inline mock maker is not supported on Android.");
     }
 
+    @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
+    @Test
+    public void shouldGiveExplanationOnConstructionMockingWithInlineMockMaker() {
+        Assume.assumeThat(Plugins.getMockMaker(), instanceOf(InlineMockMaker.class));
+
+        assertThatThrownBy(
+                        () -> {
+                            Mockito.mockConstruction(Object.class);
+                        })
+                .isInstanceOf(MockitoException.class)
+                .hasMessageContainingAll(
+                        "It is not possible to mock construction of the Object class to avoid inference with default object constructor chains");
+    }
+
     @Test
     public void shouldStartingMockSettingsContainDefaultBehavior() {
         // given

diff --git a/src/test/java/org/mockito/internal/configuration/plugins/DefaultMockitoPluginsTest.java b/src/test/java/org/mockito/internal/configuration/plugins/DefaultMockitoPluginsTest.java
@@ -10,7 +10,6 @@
 import static org.mockito.internal.configuration.plugins.DefaultMockitoPlugins.SUBCLASS_ALIAS;
 
 import org.junit.Test;
-import org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker;
 import org.mockito.internal.creation.bytebuddy.InlineByteBuddyMockMaker;
 import org.mockito.internal.util.ConsoleMockitoLogger;
 import org.mockito.plugins.InstantiatorProvider2;
@@ -35,7 +34,8 @@ public void provides_plugins() throws Exception {
                 "org.mockito.internal.creation.bytebuddy.ByteBuddyMockMaker",
                 DefaultMockitoPlugins.getDefaultPluginClass(SUBCLASS_ALIAS));
         assertEquals(
-                ByteBuddyMockMaker.class, plugins.getDefaultPlugin(MockMaker.class).getClass());
+                InlineByteBuddyMockMaker.class,
+                plugins.getDefaultPlugin(MockMaker.class).getClass());
         assertNotNull(plugins.getDefaultPlugin(InstantiatorProvider2.class));
         assertEquals(
                 ConsoleMockitoLogger.class,

diff --git a/src/test/java/org/mockitousage/annotation/SpyAnnotationTest.java b/src/test/java/org/mockitousage/annotation/SpyAnnotationTest.java
@@ -6,6 +6,8 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.not;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
@@ -22,6 +24,7 @@
 import java.util.LinkedList;
 import java.util.List;
 
+import org.junit.Assume;
 import org.junit.Rule;
 import org.junit.Test;
 import org.junit.rules.ExpectedException;
@@ -30,6 +33,8 @@
 import org.mockito.MockitoAnnotations;
 import org.mockito.Spy;
 import org.mockito.exceptions.base.MockitoException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.plugins.InlineMockMaker;
 import org.mockitoutil.TestBase;
 
 @SuppressWarnings("unused")
@@ -188,8 +193,21 @@ class WithSpy {
         }
     }
 
+    @Test
+    public void should_spy_private_inner() throws Exception {
+        Assume.assumeThat(Plugins.getMockMaker(), instanceOf(InlineMockMaker.class));
+
+        WithInnerPrivate inner = new WithInnerPrivate();
+        MockitoAnnotations.openMocks(inner);
+
+        when(inner.spy_field.lenght()).thenReturn(10);
+        assertEquals(10, inner.spy_field.lenght());
+    }
+
     @Test
     public void should_report_private_inner_not_supported() throws Exception {
+        Assume.assumeThat(Plugins.getMockMaker(), not(instanceOf(InlineMockMaker.class)));
+
         try {
             MockitoAnnotations.openMocks(new WithInnerPrivate());
             fail();
@@ -287,7 +305,11 @@ private class InnerPrivateConcrete extends InnerPrivateAbstract {}
     static class WithInnerPrivate {
         @Spy private InnerPrivate spy_field;
 
-        private class InnerPrivate {}
+        private class InnerPrivate {
+            int lenght() {
+                return 0;
+            }
+        }
 
         private class InnerPrivateSub extends InnerPrivate {}
     }

diff --git a/src/test/java/org/mockitousage/configuration/ClassCacheVersusClassReloadingTest.java b/src/test/java/org/mockitousage/configuration/ClassCacheVersusClassReloadingTest.java
@@ -74,7 +74,9 @@ private static SimplePerRealmReloadingClassLoader.ReloadClassPredicate reloadMoc
         return new SimplePerRealmReloadingClassLoader.ReloadClassPredicate() {
             public boolean acceptReloadOf(String qualifiedName) {
                 return (!qualifiedName.contains("net.bytebuddy")
-                        && qualifiedName.contains("org.mockito"));
+                        && qualifiedName.contains("org.mockito")
+                        && !qualifiedName.contains(
+                                "org.mockito.internal.creation.bytebuddy.inject"));
             }
         };
     }

diff --git a/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java b/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java
@@ -4,19 +4,25 @@
  */
 package org.mockitousage.misuse;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.hamcrest.CoreMatchers.instanceOf;
+import static org.hamcrest.CoreMatchers.not;
 import static org.mockito.Mockito.inOrder;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verifyNoInteractions;
 import static org.mockito.Mockito.verifyNoMoreInteractions;
 import static org.mockito.Mockito.when;
 
 import org.junit.After;
+import org.junit.Assume;
 import org.junit.Test;
 import org.mockito.InOrder;
 import org.mockito.Mock;
 import org.mockito.exceptions.base.MockitoException;
 import org.mockito.exceptions.misusing.MissingMethodInvocationException;
+import org.mockito.internal.configuration.plugins.Plugins;
+import org.mockito.plugins.InlineMockMaker;
 import org.mockitousage.IMethods;
 import org.mockitoutil.TestBase;
 
@@ -155,6 +161,8 @@ final class FinalClass {}
 
     @Test
     public void shouldNotAllowMockingFinalClassesIfDisabled() {
+        Assume.assumeThat(Plugins.getMockMaker(), not(instanceOf(InlineMockMaker.class)));
+
         assertThatThrownBy(
                         () -> {
                             mock(FinalClass.class);
@@ -166,6 +174,12 @@ public void shouldNotAllowMockingFinalClassesIfDisabled() {
                         " - final class");
     }
 
+    @Test
+    public void shouldAllowMockingFinalClassesIfEnabled() {
+        Assume.assumeThat(Plugins.getMockMaker(), instanceOf(InlineMockMaker.class));
+        assertThat(mock(FinalClass.class)).isInstanceOf(FinalClass.class);
+    }
+
     @SuppressWarnings({"CheckReturnValue", "MockitoUsage"})
     @Test
     public void shouldNotAllowMockingPrimitives() {

diff --git a/subprojects/android/src/main/resources/mockito-extensions/org.mockito.plugins.MemberAccessor b/subprojects/android/src/main/resources/mockito-extensions/org.mockito.plugins.MemberAccessor
@@ -0,0 +1 @@
+member-accessor-reflection
diff --git a/subprojects/module-test/src/test/java/org/mockito/moduletest/ReplicatingClassLoader.java b/subprojects/module-test/src/test/java/org/mockito/moduletest/ReplicatingClassLoader.java
@@ -53,4 +53,9 @@ public Class<?> loadClass(String name) throws ClassNotFoundException {
     protected URL findResource(String moduleName, String name) {
         return Mockito.class.getResource("/" + name);
     }
+
+    @Override
+    public InputStream getResourceAsStream(String name) {
+        return Mockito.class.getResourceAsStream("/" + name);
+    }
 }
diff --git a/.../ProgrammaticMockMakerAnnotationTest.java → .../ProgrammaticMockMakerAnnotationTest.java b/.../ProgrammaticMockMakerAnnotationTest.java → .../ProgrammaticMockMakerAnnotationTest.java
@@ -6,19 +6,25 @@
 
 import static org.junit.Assert.assertEquals;
 
+import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.MockMakers;
 import org.mockito.Mockito;
-import org.mockitoutil.TestBase;
+import org.mockito.MockitoAnnotations;
 
-public class ProgrammaticMockMakerAnnotationTest extends TestBase {
+public class ProgrammaticMockMakerAnnotationTest {
     @Mock(mockMaker = MockMakers.INLINE)
     ClassWithFinalMethod inlineMock;
 
     @Mock(mockMaker = MockMakers.SUBCLASS)
     ClassWithFinalMethod subclassMock;
 
+    @Before
+    public void init() {
+        MockitoAnnotations.openMocks(this);
+    }
+
     @Test
     public void test_mock_uses_given_mock_maker() {
         Mockito.when(inlineMock.finalMethodCallingNonFinal()).thenReturn("MOCKED");

diff --git a/subprojects/proxy/src/main/resources/mockito-extensions/org.mockito.plugins.MemberAccessor b/subprojects/proxy/src/main/resources/mockito-extensions/org.mockito.plugins.MemberAccessor
@@ -0,0 +1 @@
+member-accessor-reflection