Note: this class automatically spy on {@link Log} and {@link Slog} and fail tests that * all any of their {@code wtf()} methods. If a test is expect to call {@code wtf()}, it should be * annotated with {@link ExpectWtf}. * *
Note: when using this class, you must include the following * dependencies on {@code Android.bp} (or {@code Android.mk}: *
jni_libs: [
"libdexmakerjvmtiagent",
"libstaticjvmtiagent",
],
LOCAL_JNI_SHARED_LIBRARIES := \
libdexmakerjvmtiagent \
libstaticjvmtiagent \
* This can prevent pending Handler tasks of one test from affecting another. This does not
* work if the message is posted with delay.
*/
protected void completeAllHandlerThreadTasks() {
beginTrace("completeAllHandlerThreadTasks");
Set Typically, it should be overridden when mocking static methods.
*/
protected void onSessionBuilder(@NonNull CustomMockitoSessionBuilder session) {
if (VERBOSE) Log.v(TAG, getLogPrefix() + "onSessionBuilder()");
}
/**
* Changes the value of the session created by
* {@link #onSessionBuilder(CustomMockitoSessionBuilder)}.
*
* By default it's set to {@link Strictness.LENIENT}, but subclasses can overwrite this
* method to change the behavior.
*/
@NonNull
protected Strictness getSessionStrictness() {
return Strictness.LENIENT;
}
/**
* Mocks a call to {@link ActivityManager#getCurrentUser()}.
*
* @param userId result of such call
*
* @throws IllegalStateException if class didn't override {@link #newSessionBuilder()} and
* called {@code spyStatic(ActivityManager.class)} on the session passed to it.
*/
protected final void mockGetCurrentUser(@UserIdInt int userId) {
if (VERBOSE) Log.v(TAG, getLogPrefix() + "mockGetCurrentUser(" + userId + ")");
assertSpied(ActivityManager.class);
beginTrace("mockAmGetCurrentUser-" + userId);
AndroidMockitoHelper.mockAmGetCurrentUser(userId);
endTrace();
}
/**
* Mocks a call to {@link UserManager#isHeadlessSystemUserMode()}.
*
* @param mode result of such call
*
* @throws IllegalStateException if class didn't override {@link #newSessionBuilder()} and
* called {@code spyStatic(UserManager.class)} on the session passed to it.
*/
protected final void mockIsHeadlessSystemUserMode(boolean mode) {
if (VERBOSE) Log.v(TAG, getLogPrefix() + "mockIsHeadlessSystemUserMode(" + mode + ")");
assertSpied(UserManager.class);
beginTrace("mockUmIsHeadlessSystemUserMode");
AndroidMockitoHelper.mockUmIsHeadlessSystemUserMode(mode);
endTrace();
}
/**
* Starts a tracing message.
*
* MUST be followed by a {@link #endTrace()} calls.
*
* Ignored if {@value #VERBOSE} is {@code false}.
*/
protected final void beginTrace(@NonNull String message) {
if (mTracer == null) return;
Log.d(TAG, getLogPrefix() + message);
mTracer.traceBegin(message);
}
/**
* Ends a tracing call.
*
* MUST be called after {@link #beginTrace(String)}.
*
* Ignored if {@value #VERBOSE} is {@code false}.
*/
protected final void endTrace() {
if (mTracer == null) return;
mTracer.traceEnd();
}
private void interceptWtfCalls() {
doAnswer((invocation) -> {
return addWtf(invocation);
}).when(() -> Log.wtf(anyString(), anyString()));
doAnswer((invocation) -> {
return addWtf(invocation);
}).when(() -> Log.wtf(anyString(), anyString(), notNull()));
doAnswer((invocation) -> {
return addWtf(invocation);
}).when(() -> Slog.wtf(anyString(), anyString()));
doAnswer((invocation) -> {
return addWtf(invocation);
}).when(() -> Slog.wtf(anyString(), anyString(), notNull()));
}
private Object addWtf(InvocationOnMock invocation) {
String message = "Called " + invocation;
Log.d(TAG, message); // Log always, as some test expect it
mWtfs.add(new IllegalStateException(message));
return null;
}
private void verifyWtfLogged() {
Preconditions.checkState(!mWtfs.isEmpty(), "no wtf() called");
}
private void verifyWtfNeverLogged() {
int size = mWtfs.size();
switch (size) {
case 0:
return;
case 1:
throw mWtfs.get(0);
default:
StringBuilder msg = new StringBuilder("wtf called ").append(size).append(" times")
.append(": ").append(mWtfs);
throw new AssertionError(msg.toString());
}
}
@NonNull
private MockitoSessionBuilder newSessionBuilder() {
// TODO (b/155523104): change from mock to spy
StaticMockitoSessionBuilder builder = mockitoSession()
.strictness(getSessionStrictness())
.mockStatic(Settings.Global.class)
.mockStatic(Settings.System.class)
.mockStatic(Settings.Secure.class);
CustomMockitoSessionBuilder customBuilder =
new CustomMockitoSessionBuilder(builder, mStaticSpiedClasses)
.spyStatic(Log.class)
.spyStatic(Slog.class);
onSessionBuilder(customBuilder);
if (VERBOSE) Log.v(TAG, "spied classes" + customBuilder.mStaticSpiedClasses);
return builder.initMocks(this);
}
/**
* Gets a prefix for {@link Log} calls
*/
protected String getLogPrefix() {
return getClass().getSimpleName() + ".";
}
/**
* Asserts the given class is being spied in the Mockito session.
*/
protected void assertSpied(Class clazz) {
Preconditions.checkArgument(mStaticSpiedClasses.contains(clazz),
"did not call spyStatic() on %s", clazz.getName());
}
/**
* Custom {@code MockitoSessionBuilder} used to make sure some pre-defined mock stations
* (like {@link AbstractExtendedMockitoTestCase#mockGetCurrentUser(int)} fail if the test case
* didn't explicitly set it to spy / mock the required classes.
*
* NOTE: for now it only provides simple {@link #spyStatic(Class)}, but more methods
* (as provided by {@link StaticMockitoSessionBuilder}) could be provided as needed.
*/
public static final class CustomMockitoSessionBuilder {
private final StaticMockitoSessionBuilder mBuilder;
private final List