com.android.dx.mockito.inline.extended

Class ExtendedMockito

java.lang.Object

org.mockito.ArgumentMatchers

org.mockito.Mockito

com.android.dx.mockito.inline.extended.ExtendedMockito

@UnstableApi
public class ExtendedMockito
extends org.mockito.Mockito

Mockito extended with the ability to stub static methods.

E.g.

     private class C {
         static int staticMethod(String arg) {
             return 23;
         }
     }

     @Test
     public void test() {
         // static mocking
         MockitoSession session = mockitoSession().staticSpy(C.class).startMocking();
         try {
             doReturn(42).when(() -> {return C.staticMethod(eq("Arg"));});
             assertEquals(42, C.staticMethod("Arg"));
             verify(() -> C.staticMethod(eq("Arg"));
         } finally {
             session.finishMocking();
         }
     }
 

It is possible to use this class for instance mocking too. Hence you can use it as a full replacement for Mockito.

This is a prototype that is intended to eventually be upstreamed into mockito proper. Some APIs might change. All such APIs are annotated with UnstableApi.

Field Summary

Fields inherited from class org.mockito.Mockito

CALLS_REAL_METHODS, RETURNS_DEEP_STUBS, RETURNS_DEFAULTS, RETURNS_MOCKS, RETURNS_SELF, RETURNS_SMART_NULLS

Constructor Summary

Constructors

Constructor and Description
ExtendedMockito()

Method Summary

Modifier and Type	Method and Description
static StaticCapableStubber	doAnswer(org.mockito.stubbing.Answer answer) Same as Mockito.doAnswer(Answer) but adds the ability to stub static method calls via StaticCapableStubber.when(MockedMethod) and StaticCapableStubber.when(MockedVoidMethod).
static StaticCapableStubber	doCallRealMethod() Same as Mockito.doCallRealMethod() but adds the ability to stub static method calls via StaticCapableStubber.when(MockedMethod) and StaticCapableStubber.when(MockedVoidMethod).
static StaticCapableStubber	doNothing() Same as Mockito.doNothing() but adds the ability to stub static method calls via StaticCapableStubber.when(MockedMethod) and StaticCapableStubber.when(MockedVoidMethod).
static StaticCapableStubber	doReturn(java.lang.Object toBeReturned) Same as Mockito.doReturn(Object) but adds the ability to stub static method calls via StaticCapableStubber.when(MockedMethod) and StaticCapableStubber.when(MockedVoidMethod).
static StaticCapableStubber	doReturn(java.lang.Object toBeReturned, java.lang.Object... toBeReturnedNext) Same as Mockito.doReturn(Object, Object...) but adds the ability to stub static method calls via StaticCapableStubber.when(MockedMethod) and StaticCapableStubber.when(MockedVoidMethod).
static StaticCapableStubber	doThrow(java.lang.Class<? extends java.lang.Throwable> toBeThrown) Same as Mockito.doThrow(Class) but adds the ability to stub static method calls via StaticCapableStubber.when(MockedMethod) and StaticCapableStubber.when(MockedVoidMethod).
static StaticCapableStubber	doThrow(java.lang.Class<? extends java.lang.Throwable> toBeThrown, java.lang.Class<? extends java.lang.Throwable>... toBeThrownNext) Same as Mockito.doThrow(Class, Class...) but adds the ability to stub static method calls via StaticCapableStubber.when(MockedMethod) and StaticCapableStubber.when(MockedVoidMethod).
static StaticCapableStubber	doThrow(java.lang.Throwable... toBeThrown) Same as Mockito.doThrow(Throwable...) but adds the ability to stub static method calls via StaticCapableStubber.when(MockedMethod) and StaticCapableStubber.when(MockedVoidMethod).
static StaticInOrder	inOrder(java.lang.Object... mocksAndMarkers) Same as Mockito.inOrder(Object...) but adds the ability to verify static method calls via StaticInOrder.verify(MockedMethod), StaticInOrder.verify(MockedVoidMethod), StaticInOrder.verify(MockedMethod, VerificationMode), and StaticInOrder.verify(MockedVoidMethod, VerificationMode).
static StaticMockitoSessionBuilder	mockitoSession() Same as Mockito.mockitoSession() but adds the ability to mock static methods calls via StaticMockitoSessionBuilder.mockStatic(Class), StaticMockitoSessionBuilder.mockStatic(Class, Answer), and StaticMockitoSessionBuilder.mockStatic(Class, MockSettings);
static void	spyOn(java.lang.Object toMock) Make an existing object a spy.
static java.lang.Object[]	staticMockMarker(java.lang.Class<?>... clazz) Same as staticMockMarker(Class) but for multiple classes at once.
static <T> T	staticMockMarker(java.lang.Class<T> clazz) Many methods of mockito take mock objects.
static void	verify(MockedMethod method) To be used for static mocks/spies in place of Mockito.verify(Object).
static void	verify(MockedMethod method, org.mockito.verification.VerificationMode mode) To be used for static mocks/spies in place of Mockito.verify(Object, VerificationMode).
static void	verify(MockedVoidMethod method) To be used for static mocks/spies in place of Mockito.verify(Object) when calling void methods.
static void	verify(MockedVoidMethod method, org.mockito.verification.VerificationMode mode) To be used for static mocks/spies in place of Mockito.verify(Object, VerificationMode) when calling void methods.

Methods inherited from class org.mockito.Mockito

after, atLeast, atLeastOnce, atMost, calls, clearInvocations, description, framework, ignoreStubs, mock, mock, mock, mock, mockingDetails, never, only, reset, spy, spy, timeout, times, validateMockitoUsage, verifyNoMoreInteractions, verifyZeroInteractions, when, withSettings

Methods inherited from class org.mockito.ArgumentMatchers

any, any, anyBoolean, anyByte, anyChar, anyCollection, anyCollectionOf, anyDouble, anyFloat, anyInt, anyIterable, anyIterableOf, anyList, anyListOf, anyLong, anyMap, anyMapOf, anyObject, anySet, anySetOf, anyShort, anyString, anyVararg, argThat, booleanThat, byteThat, charThat, contains, doubleThat, endsWith, eq, eq, eq, eq, eq, eq, eq, eq, eq, floatThat, intThat, isA, isNotNull, isNotNull, isNull, isNull, longThat, matches, matches, notNull, notNull, nullable, refEq, same, shortThat, startsWith

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

ExtendedMockito

public ExtendedMockito()

Method Detail

doAnswer

public static StaticCapableStubber doAnswer(org.mockito.stubbing.Answer answer)

Same as Mockito.doAnswer(Answer) but adds the ability to stub static method calls via StaticCapableStubber.when(MockedMethod) and StaticCapableStubber.when(MockedVoidMethod).

doCallRealMethod

public static StaticCapableStubber doCallRealMethod()

Same as Mockito.doCallRealMethod() but adds the ability to stub static method calls via StaticCapableStubber.when(MockedMethod) and StaticCapableStubber.when(MockedVoidMethod).

doNothing

public static StaticCapableStubber doNothing()

Same as Mockito.doNothing() but adds the ability to stub static method calls via StaticCapableStubber.when(MockedMethod) and StaticCapableStubber.when(MockedVoidMethod).

doReturn

public static StaticCapableStubber doReturn(java.lang.Object toBeReturned)

Same as Mockito.doReturn(Object) but adds the ability to stub static method calls via StaticCapableStubber.when(MockedMethod) and StaticCapableStubber.when(MockedVoidMethod).

doReturn

public static StaticCapableStubber doReturn(java.lang.Object toBeReturned,
                                            java.lang.Object... toBeReturnedNext)

Same as Mockito.doReturn(Object, Object...) but adds the ability to stub static method calls via StaticCapableStubber.when(MockedMethod) and StaticCapableStubber.when(MockedVoidMethod).

doThrow

public static StaticCapableStubber doThrow(java.lang.Class<? extends java.lang.Throwable> toBeThrown)

Same as Mockito.doThrow(Class) but adds the ability to stub static method calls via StaticCapableStubber.when(MockedMethod) and StaticCapableStubber.when(MockedVoidMethod).

doThrow

@SafeVarargs
public static StaticCapableStubber doThrow(java.lang.Class<? extends java.lang.Throwable> toBeThrown,
                                                        java.lang.Class<? extends java.lang.Throwable>... toBeThrownNext)

Same as Mockito.doThrow(Class, Class...) but adds the ability to stub static method calls via StaticCapableStubber.when(MockedMethod) and StaticCapableStubber.when(MockedVoidMethod).

doThrow

public static StaticCapableStubber doThrow(java.lang.Throwable... toBeThrown)

Same as Mockito.doThrow(Throwable...) but adds the ability to stub static method calls via StaticCapableStubber.when(MockedMethod) and StaticCapableStubber.when(MockedVoidMethod).

staticMockMarker

@UnstableApi
public static <T> T staticMockMarker(java.lang.Class<T> clazz)

Many methods of mockito take mock objects. To be able to call the same methods for static mocking, this method gets a marker object that can be used instead.

Parameters:

clazz - The class object the marker should be crated for

Returns:

A marker object. This should not be used directly. It can only be passed into other ExtendedMockito methods.

See Also:

inOrder(Object...), Mockito.clearInvocations(Object...), Mockito.ignoreStubs(Object...), Mockito.mockingDetails(Object), Mockito.reset(Object[]), Mockito.verifyNoMoreInteractions(Object...), Mockito.verifyZeroInteractions(Object...)

staticMockMarker

@UnstableApi
public static java.lang.Object[] staticMockMarker(java.lang.Class<?>... clazz)

Same as staticMockMarker(Class) but for multiple classes at once.

spyOn

@UnstableApi
public static void spyOn(java.lang.Object toMock)

Make an existing object a spy.

This does not clone the existing objects. If a method is stubbed on a spy converted by this method all references to the already existing object will be affected by the stubbing.

Parameters:

toMock - The existing object to convert into a spy

verify

public static void verify(MockedVoidMethod method)

To be used for static mocks/spies in place of Mockito.verify(Object) when calling void methods.

E.g.

     private class C {
         void instanceMethod(String arg) {}
         static void staticMethod(String arg) {}
     }

     @Test
     public void test() {
         // instance mocking
         C mock = mock(C.class);
         mock.instanceMethod("Hello");
         verify(mock).mockedVoidInstanceMethod(eq("Hello"));

         // static mocking
         MockitoSession session = mockitoSession().staticMock(C.class).startMocking();
         C.staticMethod("World");
         verify(() -> C.staticMethod(eq("World"));
         session.finishMocking();
     }
 

verify

@UnstableApi
public static void verify(MockedMethod method)

To be used for static mocks/spies in place of Mockito.verify(Object).

E.g. (please notice the 'return' in the lambda when verifying the static call)

     private class C {
         int instanceMethod(String arg) {
             return 1;
         }

         int static staticMethod(String arg) {
             return 2;
         }
     }

     @Test
     public void test() {
         // instance mocking
         C mock = mock(C.class);
         mock.instanceMethod("Hello");
         verify(mock).mockedVoidInstanceMethod(eq("Hello"));

         // static mocking
         MockitoSession session = mockitoSession().staticMock(C.class).startMocking();
         C.staticMethod("World");
         verify(() -> {return C.staticMethod(eq("World");});
         session.finishMocking();
     }
 

verify

@UnstableApi
public static void verify(MockedVoidMethod method,
                                       org.mockito.verification.VerificationMode mode)

To be used for static mocks/spies in place of Mockito.verify(Object, VerificationMode) when calling void methods.

See Also:

verify(MockedVoidMethod)

verify

@UnstableApi
public static void verify(MockedMethod method,
                                       org.mockito.verification.VerificationMode mode)

To be used for static mocks/spies in place of Mockito.verify(Object, VerificationMode).

See Also:

verify(MockedMethod)

inOrder

@UnstableApi
public static StaticInOrder inOrder(java.lang.Object... mocksAndMarkers)

Same as Mockito.inOrder(Object...) but adds the ability to verify static method calls via StaticInOrder.verify(MockedMethod), StaticInOrder.verify(MockedVoidMethod), StaticInOrder.verify(MockedMethod, VerificationMode), and StaticInOrder.verify(MockedVoidMethod, VerificationMode).

To verify static method calls, the result of staticMockMarker(Class) has to be passed to the mocksAndMarkers parameter. It is possible to mix static and instance mocking.

mockitoSession

public static StaticMockitoSessionBuilder mockitoSession()

Same as Mockito.mockitoSession() but adds the ability to mock static methods calls via StaticMockitoSessionBuilder.mockStatic(Class), StaticMockitoSessionBuilder.mockStatic(Class, Answer), and StaticMockitoSessionBuilder.mockStatic(Class, MockSettings);

All mocking spying will be removed once the session is finished.