PowerMock学习

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));
    }
}