public class MyClass {
public static void main(String[] args)
{
MyClass myClass=new MyClass();
int result=myClass.test_private_method(1);
System.out.println(result);
}
final private int private_method(int a) {
System.out.println("the inputParam of private_method is "+ a);
return a;
}
public int test_private_method(int a) {
System.out.println("the inputParam of test_private_method is "+ a);
return private_method(a);
}
public static int static_return_method() {
return 1;
}
void void_method() {
throw new IllegalStateException("should not go here");
}
public static void static_void_method() {
throw new IllegalStateException("should not go here");
}
public static void staticMethod(String a) {
throw new IllegalStateException(a);
}
}
###############################
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
@RunWith(PowerMockRunner.class)
@PrepareForTest({ MyClass.class})
public class StaticClassSampleTest {
@Test
public void testPrivateMethod() throws Exception {
// 模拟 private的方法
MyClass spy = PowerMockito.spy(new MyClass());
PowerMockito.doReturn(3).when(spy, "private_method", 1);
int realResult=spy.test_private_method(1);
System.out.println(realResult);
Assert.assertEquals(3, realResult);
//校验私有方法
PowerMockito.verifyPrivate(spy, Mockito.times(1)).invoke("private_method", 1);
}
@Test
public void testStaticReturnMethod() throws Exception {
// 模拟 静态有返回值的方法
PowerMockito.mockStatic(MyClass.class);
Mockito.when(MyClass.static_return_method()).thenReturn(2);
Assert.assertEquals(2, MyClass.static_return_method());
}
@Test
public void testVoidMethod() throws Exception {
// 模拟 不执行void的方法
MyClass spy = PowerMockito.spy(new MyClass());
PowerMockito.doNothing().when(spy).void_method();
spy.void_method();
}
@Test
public void testStaticMethod1() throws Exception {
// 模拟 不执行没参数的静态void的方法
PowerMockito.mockStatic(MyClass.class);
PowerMockito.doNothing().when(MyClass.class, "static_void_method");
MyClass.static_void_method();
}
@Test
public void testStaticMethod2() throws Exception {
// 模拟 不执行带参数的静态void的方法
PowerMockito.mockStatic(MyClass.class);
PowerMockito.doNothing().when(MyClass.class, "staticMethod", "123");
MyClass.staticMethod("123");
PowerMockito.doNothing().when(MyClass.class, "staticMethod", Mockito.anyString());
MyClass.staticMethod("456");
}
}
#############################
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.junit.Assert.*;
public class MyClassTest
{
@Before
public void setUp() throws Exception
{
}
@After
public void tearDown() throws Exception
{
}
@Test
public void test_private_method() throws Exception
{
}
@Test
public void static_return_method() throws Exception
{
}
@Test
public void void_method() throws Exception
{
}
@Test
public void static_void_method() throws Exception
{
}
@Test
public void staticMethod() throws Exception
{
}
}
<dependencies>
<!-- https://mvnrepository.com/artifact/org.powermock/powermock-module-junit4 -->
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-module-junit4</artifactId>
<version>1.7.4</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mockito/mockito-all -->
<dependency>
<groupId>org.mockito</groupId>
<artifactId>mockito-all</artifactId>
<version>1.10.19</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.powermock/powermock-api-mockito -->
<dependency>
<groupId>org.powermock</groupId>
<artifactId>powermock-api-mockito</artifactId>
<version>1.7.4</version>
<scope>test</scope>
</dependency>
</dependencies>
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package org.powermock.api.mockito;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import org.mockito.MockSettings;
import org.mockito.Mockito;
import org.mockito.internal.progress.MockingProgress;
import org.mockito.internal.stubbing.answers.CallsRealMethods;
import org.mockito.internal.stubbing.answers.DoesNothing;
import org.mockito.internal.stubbing.answers.Returns;
import org.mockito.internal.stubbing.answers.ThrowsException;
import org.mockito.stubbing.Answer;
import org.mockito.stubbing.OngoingStubbing;
import org.mockito.verification.VerificationMode;
import org.powermock.api.mockito.expectation.ConstructorExpectationSetup;
import org.powermock.api.mockito.expectation.PowerMockitoStubber;
import org.powermock.api.mockito.expectation.WithOrWithoutExpectedArguments;
import org.powermock.api.mockito.internal.PowerMockitoCore;
import org.powermock.api.mockito.internal.expectation.ConstructorAwareExpectationSetup;
import org.powermock.api.mockito.internal.expectation.DefaultConstructorExpectationSetup;
import org.powermock.api.mockito.internal.expectation.DefaultMethodExpectationSetup;
import org.powermock.api.mockito.internal.mockcreation.DefaultMockCreator;
import org.powermock.api.mockito.internal.stubbing.answers.ChainReturns;
import org.powermock.api.mockito.internal.verification.DefaultConstructorArgumentsVerfication;
import org.powermock.api.mockito.internal.verification.DefaultPrivateMethodVerification;
import org.powermock.api.mockito.internal.verification.VerifyNoMoreInteractions;
import org.powermock.api.mockito.verification.ConstructorArgumentsVerification;
import org.powermock.api.mockito.verification.PrivateMethodVerification;
import org.powermock.api.support.membermodification.MemberModifier;
import org.powermock.core.MockRepository;
import org.powermock.core.spi.NewInvocationControl;
import org.powermock.reflect.Whitebox;
public class PowerMockito extends MemberModifier {
private static final String NO_OBJECT_CREATION_ERROR_MESSAGE_TEMPLATE = "No instantiation of class %s was recorded during the test. Note that only expected object creations (e.g. those using whenNew(..)) can be verified.";
private static final PowerMockitoCore POWERMOCKITO_CORE = new PowerMockitoCore();
public PowerMockito() {
}
public static synchronized void mockStatic(Class<?> type, Class... types) {
DefaultMockCreator.mock(type, true, false, (Object)null, (MockSettings)null, (Method[])null);
if (types != null && types.length > 0) {
Class[] var2 = types;
int var3 = types.length;
for(int var4 = 0; var4 < var3; ++var4) {
Class<?> aClass = var2[var4];
DefaultMockCreator.mock(aClass, true, false, (Object)null, (MockSettings)null, (Method[])null);
}
}
}
public static void mockStatic(Class<?> classMock, Answer defaultAnswer) {
mockStatic(classMock, Mockito.withSettings().defaultAnswer(defaultAnswer));
}
public static void mockStatic(Class<?> classToMock, MockSettings mockSettings) {
DefaultMockCreator.mock(classToMock, true, false, (Object)null, mockSettings, (Method[])null);
}
public static synchronized <T> T mock(Class<T> type) {
return DefaultMockCreator.mock(type, false, false, (Object)null, (MockSettings)null, (Method[])null);
}
public static <T> T mock(Class<T> classToMock, Answer defaultAnswer) {
return mock(classToMock, Mockito.withSettings().defaultAnswer(defaultAnswer));
}
public static <T> T mock(Class<T> classToMock, MockSettings mockSettings) {
return DefaultMockCreator.mock(classToMock, false, false, (Object)null, mockSettings, (Method[])null);
}
public static synchronized <T> T spy(T object) {
return DefaultMockCreator.mock(Whitebox.getType(object), false, true, object, (MockSettings)null, (Method[])null);
}
public static synchronized <T> void spy(Class<T> type) {
DefaultMockCreator.mock(type, true, true, type, (MockSettings)null, (Method[])null);
}
/** @deprecated */
@Deprecated
public static synchronized void verifyStatic() {
verifyStatic(Mockito.times(1));
}
public static synchronized <T> void verifyStatic(Class<T> mockedClass) {
verifyStatic(mockedClass, Mockito.times(1));
}
/** @deprecated */
@Deprecated
public static synchronized void verifyStatic(VerificationMode verificationMode) {
((MockingProgress)Whitebox.getInternalState(Mockito.class, MockingProgress.class)).verificationStarted(POWERMOCKITO_CORE.wrapInStaticVerificationMode(verificationMode));
}
public static synchronized <T> void verifyStatic(Class<T> mockedClass, VerificationMode verificationMode) {
((MockingProgress)Whitebox.getInternalState(Mockito.class, MockingProgress.class)).verificationStarted(POWERMOCKITO_CORE.wrapInStaticVerificationMode(mockedClass, verificationMode));
}
public static PrivateMethodVerification verifyPrivate(Object object) throws Exception {
return verifyPrivate(object, Mockito.times(1));
}
public static PrivateMethodVerification verifyPrivate(Object object, VerificationMode verificationMode) throws Exception {
((MockingProgress)Whitebox.getInternalState(Mockito.class, MockingProgress.class)).verificationStarted(POWERMOCKITO_CORE.wrapInMockitoSpecificVerificationMode(object, verificationMode));
return new DefaultPrivateMethodVerification(object);
}
public static PrivateMethodVerification verifyPrivate(Class<?> clazz) throws Exception {
return verifyPrivate((Object)clazz);
}
public static PrivateMethodVerification verifyPrivate(Class<?> clazz, VerificationMode verificationMode) throws Exception {
return verifyPrivate((Object)clazz, verificationMode);
}
public static synchronized <T> ConstructorArgumentsVerification verifyNew(Class<T> mock) {
if (mock == null) {
throw new IllegalArgumentException("Class to verify cannot be null");
} else {
NewInvocationControl<?> invocationControl = MockRepository.getNewInstanceControl(mock);
if (invocationControl == null) {
throw new IllegalStateException(String.format("No instantiation of class %s was recorded during the test. Note that only expected object creations (e.g. those using whenNew(..)) can be verified.", Whitebox.getType(mock).getName()));
} else {
invocationControl.verify(new Object[0]);
return new DefaultConstructorArgumentsVerfication(invocationControl, mock);
}
}
}
public static <T> ConstructorArgumentsVerification verifyNew(Class<?> mock, VerificationMode mode) {
if (mock == null) {
throw new IllegalArgumentException("Class to verify cannot be null");
} else if (mode == null) {
throw new IllegalArgumentException("Verify mode cannot be null");
} else {
NewInvocationControl<?> invocationControl = MockRepository.getNewInstanceControl(mock);
MockRepository.putAdditionalState("VerificationMode", POWERMOCKITO_CORE.wrapInMockitoSpecificVerificationMode(mock, mode));
if (invocationControl == null) {
throw new IllegalStateException(String.format("No instantiation of class %s was recorded during the test. Note that only expected object creations (e.g. those using whenNew(..)) can be verified.", Whitebox.getType(mock).getName()));
} else {
try {
invocationControl.verify(new Object[0]);
} finally {
MockRepository.removeAdditionalState("VerificationMode");
}
return new DefaultConstructorArgumentsVerfication(invocationControl, mock);
}
}
}
public static <T> OngoingStubbing<T> when(Object instance, String methodName, Object... arguments) throws Exception {
return Mockito.when(Whitebox.invokeMethod(instance, methodName, arguments));
}
public static <T> WithOrWithoutExpectedArguments<T> when(Object instance, Method method) throws Exception {
return new DefaultMethodExpectationSetup(instance, method);
}
public static <T> WithOrWithoutExpectedArguments<T> when(Class<?> cls, Method method) throws Exception {
return new DefaultMethodExpectationSetup(cls, method);
}
public static <T> OngoingStubbing<T> when(Object instance, Object... arguments) throws Exception {
return Mockito.when(Whitebox.invokeMethod(instance, arguments));
}
public static <T> OngoingStubbing<T> when(Class<?> clazz, String methodToExpect, Object... arguments) throws Exception {
return Mockito.when(Whitebox.invokeMethod(clazz, methodToExpect, arguments));
}
public static <T> OngoingStubbing<T> when(Class<?> klass, Object... arguments) throws Exception {
return Mockito.when(Whitebox.invokeMethod(klass, arguments));
}
public static <T> OngoingStubbing<T> when(T methodCall) {
return Mockito.when(methodCall);
}
public static synchronized <T> WithOrWithoutExpectedArguments<T> whenNew(Constructor<T> ctor) {
return new ConstructorAwareExpectationSetup(ctor);
}
public static synchronized <T> ConstructorExpectationSetup<T> whenNew(Class<T> type) {
return new DefaultConstructorExpectationSetup(type);
}
public static synchronized <T> ConstructorExpectationSetup<T> whenNew(String fullyQualifiedName) throws Exception {
Class<T> forName = Class.forName(fullyQualifiedName);
return new DefaultConstructorExpectationSetup(forName);
}
public static void verifyNoMoreInteractions(Object... mocks) {
VerifyNoMoreInteractions.verifyNoMoreInteractions(mocks);
}
public static void verifyZeroInteractions(Object... mocks) {
VerifyNoMoreInteractions.verifyNoMoreInteractions(mocks);
}
public static PowerMockitoStubber doAnswer(Answer<?> answer) {
return POWERMOCKITO_CORE.doAnswer(answer);
}
public static PowerMockitoStubber doThrow(Throwable toBeThrown) {
return POWERMOCKITO_CORE.doAnswer(new ThrowsException(toBeThrown));
}
public static PowerMockitoStubber doCallRealMethod() {
return POWERMOCKITO_CORE.doAnswer(new CallsRealMethods());
}
public static PowerMockitoStubber doNothing() {
return POWERMOCKITO_CORE.doAnswer(new DoesNothing());
}
public static PowerMockitoStubber doReturn(Object toBeReturned) {
return POWERMOCKITO_CORE.doAnswer(new Returns(toBeReturned));
}
public static PowerMockitoStubber doReturn(Object toBeReturned, Object... othersToBeReturned) {
return othersToBeReturned != null && othersToBeReturned.length == 0 ? doReturn(toBeReturned) : POWERMOCKITO_CORE.doAnswer(new ChainReturns(toBeReturned, othersToBeReturned));
}
}