diff --git a/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java b/src/main/java/org/mockito/internal/configuration/plugins/DefaultMockitoPlugins.java index 14f52f3705..780742c64a 100644 --- 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 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 index ed12d2ffe2..009daa4ccb 100644 --- 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 Class mockClass(MockFeatures 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 index 13d8416586..d52676ccf6 100644 --- 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 index 168acb8f40..1ebbb89b80 100644 --- 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 index aa1835696e..61fc8e8ed1 100644 --- 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 index 01edd3c687..daa71bed33 100644 --- 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 index 7d9c95061f..6c08198864 100644 --- 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 index 35c135a62e..e4a8275be9 100644 --- a/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java +++ b/src/test/java/org/mockitousage/misuse/InvalidUsageTest.java @@ -4,7 +4,10 @@ */ 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; @@ -12,11 +15,14 @@ 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 new file mode 100644 index 0000000000..71111e3378 --- /dev/null +++ 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 index c9cf0a32d2..144ff98767 100644 --- 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/src/test/java/org/mockitousage/annotation/ProgrammaticMockMakerAnnotationTest.java b/subprojects/programmatic-test/src/test/java/org/mockitousage/annotation/ProgrammaticMockMakerAnnotationTest.java similarity index 85% rename from src/test/java/org/mockitousage/annotation/ProgrammaticMockMakerAnnotationTest.java rename to subprojects/programmatic-test/src/test/java/org/mockitousage/annotation/ProgrammaticMockMakerAnnotationTest.java index ad5f2a50ae..2d495bed00 100644 --- a/src/test/java/org/mockitousage/annotation/ProgrammaticMockMakerAnnotationTest.java +++ b/subprojects/programmatic-test/src/test/java/org/mockitousage/annotation/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 new file mode 100644 index 0000000000..71111e3378 --- /dev/null +++ b/subprojects/proxy/src/main/resources/mockito-extensions/org.mockito.plugins.MemberAccessor @@ -0,0 +1 @@ +member-accessor-reflection