/** {@inheritDoc} */
public void notifyAfterTestMethod(boolean successful) {
final Object test = MockRepository.getAdditionalState(Keys.CURRENT_TEST_INSTANCE);
final Method testMethod = (Method) MockRepository.getAdditionalState(Keys.CURRENT_TEST_METHOD);
final Object[] testArguments =
(Object[]) MockRepository.getAdditionalState(Keys.CURRENT_TEST_METHOD_ARGUMENTS);
final TestMethodResult testResult =
new TestMethodResultImpl((successful ? Result.SUCCESSFUL : Result.FAILED));
notifyAfterTestMethod(test, testMethod, testArguments, testResult);
}
/** {@inheritDoc} */
public void notifyBeforeTestMethod(Object testInstance, Method testMethod, Object[] arguments) {
MockRepository.putAdditionalState(Keys.CURRENT_TEST_INSTANCE, testInstance);
MockRepository.putAdditionalState(Keys.CURRENT_TEST_METHOD, testMethod);
MockRepository.putAdditionalState(Keys.CURRENT_TEST_METHOD_ARGUMENTS, arguments);
for (int i = 0; i < powerMockTestListeners.length; i++) {
final PowerMockTestListener testListener = powerMockTestListeners[i];
try {
testListener.beforeTestMethod(testInstance, testMethod, arguments);
} catch (Exception e) {
throw new RuntimeException(
String.format(ERROR_MESSAGE_TEMPLATE, "beforeTestMethod", testListener), e);
}
}
}
@Override
protected <T> T createMock(
Class<T> type,
boolean isStatic,
boolean isSpy,
Object delegator,
MockSettings mockSettings,
Method... methods) {
if (type == null) {
throw new IllegalArgumentException("The class to mock cannot be null");
}
validateType(type, isStatic, isSpy);
final String mockName = toInstanceName(type, mockSettings);
MockRepository.addAfterMethodRunner(new MockitoStateCleanerRunnable());
final Class<T> typeToMock;
if (isFinalJavaSystemClass(type)) {
typeToMock = (Class<T>) new ClassReplicaCreator().createClassReplica(type);
} else {
typeToMock = type;
}
final MockData<T> mockData =
createMethodInvocationControl(
mockName, typeToMock, methods, isSpy, delegator, mockSettings);
T mock = mockData.getMock();
if (isFinalJavaSystemClass(type) && !isStatic) {
mock = Whitebox.newInstance(type);
DefaultFieldValueGenerator.fillWithDefaultValues(mock);
}
if (isStatic) {
MockRepository.putStaticMethodInvocationControl(type, mockData.getMethodInvocationControl());
} else {
MockRepository.putInstanceMethodInvocationControl(
mock, mockData.getMethodInvocationControl());
}
if (isSpy) {
new LenientCopyTool().copyToMock(delegator, mock);
}
return mock;
}
/**
* Add a method that should be intercepted and return another value ( <code>returnObject</code>)
* (i.e. the method is stubbed).
*/
public static void stubMethod(Class<?> declaringClass, String methodName, Object returnObject) {
if (declaringClass == null) {
throw new IllegalArgumentException("declaringClass cannot be null");
}
if (methodName == null || methodName.length() == 0) {
throw new IllegalArgumentException("methodName cannot be empty");
}
Method[] methods = Whitebox.getMethods(declaringClass, methodName);
if (methods.length == 0) {
throw new MethodNotFoundException(
String.format(
"Couldn't find a method with name %s in the class hierarchy of %s",
methodName, declaringClass.getName()));
} else if (methods.length > 1) {
throw new TooManyMethodsFoundException(
String.format(
"Found %d methods with name %s in the class hierarchy of %s.",
methods.length, methodName, declaringClass.getName()));
}
MockRepository.putMethodToStub(methods[0], returnObject);
}
/**
* Add a method that should be intercepted and return another value ( <code>returnObject</code>)
* (i.e. the method is stubbed).
*/
public static void stubMethod(Method method, Object returnObject) {
MockRepository.putMethodToStub(method, returnObject);
}
