自动化测试

public class NormalClassA {
  public int testAdd(int a, int b) {
    return a + b;
  }
}
public class NormalClassATest {
  @Test
  public void testAdd() {
    NormalClassA classA = new NormalClassA();
    Assert.assertEquals(5, classA.testAdd(1,4));
  }
}

public class NormalClassA {
  public NormalClassB mClassB = new NormalClassB();
  public int testPlus(int a, int b) {
      return mClassB.testPlus(a, b);
  }
}

public class NormalClassB {
  public int testPlus(int a, int b) {
      return a + b;
  }
}

public class NormalClassATest {
  @Test
  public void testPlusInvokeMock() {
    NormalClassA classA = new NormalClassA();
    classA.mClassB = Mockito.mock(NormalClassB.class);
    //验证返回值
    Assert.assertEquals(6,   classA.testPlus(3,3));
    //验证函数调用，并且参数是3，3
    Mockito.verify(classA.mClassB).testPlus(3, 3);
  }
}

public class JudgePresenter extends AbstractJudgePresenter {
    public JudgePresenter(IJudgeContract.IView mView, QuestionInfo mCurrentQuestionInfo) {
        super(mView, mCurrentQuestionInfo);
    }

    @Override
    public void initUIData() {
        mView.setBg();
        updateLiveViewerCount();
    }

    private void updateLiveViewerCount() {
        DataLoader.getLiveViewerBuilder(GlobalLocalData.getInstance().getArticleId())
                .response(new TNResponseCallBack<LiveViewersRet>())
                .build()
                .submit();
    }
}

@Test
public void initUIDataTest() {
  IJudgeContract.IView mockView = Mockito.mock(JudgeDialog.class);
  JudgePresenter presenter = new JudgePresenter(mockView, getFakeQuestionInfo());
  presenter.initUIData();
  Mockito.verify(mockView).setBg();
}

@Test
public void initUIDataTest() {
  IJudgeContract.IView mockView = Mockito.mock(JudgeDialog.class);
  JudgePresenter presenter = new JudgePresenter(mockView, getFakeQuestionInfo());
  PowerMockito.suppress(PowerMockito.method(JudgePresenter.class, "updateLiveViewerCount"));
  presenter.initUIData();
  Mockito.verify(mockView).setBg();
}

@Test
public void initUIDataTest() {
    IJudgeContract.IView mockView = Mockito.mock(JudgeDialog.class);
    JudgePresenter presenter = new JudgePresenter(mockView, getFakeQuestionInfo());
    PowerMockito.suppress(PowerMockito.method(JudgePresenter.class, "updateLiveViewerCount"));
    presenter.initUIData();
    Mockito.verify(mockView).setBg();
}

@RunWith(MockitoJUnitRunner.class)
public class NormalClassAMockitoTest {

    @Test
    public void testAPlusInvokeMock() {
        NormalClassA mockClassA = Mockito.mock(NormalClassA.class);
        mockClassA.testPlus(3,3);
        Mockito.verify(mockClassA).testPlus(3, 3);
    }
}

public class NormalClassB {

    public int testPlus(int a, int b) {
        return a + b;
    }

}

@Test
public void testPlusValueMock() {
    NormalClassA classA = new NormalClassA();
    classA.mClassB = Mockito.mock(NormalClassB.class);
    Assert.assertEquals(0, classA.testPlus(3, 3));
}

@Test
public void testPlusValueSpy() {
    NormalClassA classA = new NormalClassA();
    classA.mClassB = Mockito.spy(new NormalClassB());
    Assert.assertEquals(6, classA.testPlus(3, 3));
}

@Test
public void testPlusValueMockWithCallRealMethod() {
    NormalClassA classA = new NormalClassA();
    classA.mClassB = Mockito.mock(NormalClassB.class);
    doCallRealMethod().when(classA.mClassB).testPlus(Mockito.anyInt(), Mockito.anyInt());
    Assert.assertEquals(6, classA.testPlus(3, 3));
}

@Test
public void testPlusValueSpyWithDoReturn() {
    NormalClassA classA = new NormalClassA();
    classA.mClassB = Mockito.spy(NormalClassB.class);
    doReturn(0).when(classA.mClassB).testPlus(Mockito.anyInt(), Mockito.anyInt());
    Assert.assertEquals(0, classA.testPlus(3, 3));
}

@Test
public void testPlusValueSpyWithDoThrow() throws Exception {
    NormalClassA classA = new NormalClassA();
    classA.mClassB = Mockito.spy(NormalClassB.class);
    doNothing().when(classA.mClassB).voidMethod(Mockito.anyInt(), Mockito.anyInt());
}

@Test
public void testAPlusInvokeMock() {
    NormalClassA mockClassA = Mockito.mock(NormalClassA.class);
    mockClassA.testPlus(3,3);
    Mockito.verify(mockClassA).testPlus(3, 3);
    Mockito.verify(mockClassA, times(1)).testPlus(3, 3);
    Mockito.verify(mockClassA, atLeast(1)).testPlus(3, 3);
}

@RunWith(MockitoJUnitRunner.class)
public class NormalClassAMockitoTest {
    @Test
    public void testAPlusInvokeMock() {
        NormalClassA mockClassA = Mockito.mock(NormalClassA.class);
        mockClassA.testPlus(3,3);
        Mockito.verify(mockClassA).testPlus(3, 3);
    }
}

@RunWith(PowerMockRunner.class)
@PrepareForTest({NormalClassA.class})
public class NormalClassAPowerMockTest {
  @Test
  public void testPrivateMethod() throws Exception {
    NormalClassA classA = new NormalClassA();
    NormalClassA mockClassA = PowerMockito.spy(classA);
    mockClassA.publicAdd(2, 3);
    PowerMockito.verifyPrivate(mockClassA, times(1)).invoke("privateAdd",
    Mockito.anyInt(), Mockito.anyInt());
  }
}

public class ObjectWhiteBoxClass {
    private final List<String> mObjectList = new ArrayList<>();

    public void publicObjectAdd(String str) {
        mObjectList.add(str);
    }

    public List<String> getObjectList() {
        return mObjectList;
    }
}

@Test
public void testGetInternalState() {
    ObjectWhiteBoxClass objectWhiteBoxClass = new ObjectWhiteBoxClass();
    objectWhiteBoxClass.publicObjectAdd("test1str");
    objectWhiteBoxClass.publicObjectAdd("test2str");
    objectWhiteBoxClass.publicObjectAdd("test3str");

    List<String> list = Whitebox.getInternalState(objectWhiteBoxClass, "mObjectList");

    Assert.assertEquals(3, list.size());
    Assert.assertEquals("test3str", list.get(list.size()-1));
}

java
Copy code
public class MockPrivateObjectClass {
    private InnerClass innerClass;

    public MockPrivateObjectClass() {

    }

    public int doPlus(int a, int b) {
        return innerClass.plus(a, b);
    }

    public static class InnerClass {
        public int plus(int a, int b) {
            return a + b;
        }
    }
}

@RunWith(PowerMockRunner.class)
@PrepareForTest({MockPrivateObjectClass.class})
public class MockPrivateObjectClassTest {
    @Test
    public void doPlusTest() {
        MockPrivateObjectClass objectClass = new MockPrivateObjectClass();
        MockPrivateObjectClass.InnerClass mockInnerClass = Mockito.spy(MockPrivateObjectClass.InnerClass.class);
        Whitebox.setInternalState(objectClass, "innerClass", mockInnerClass);

        int ret = objectClass.doPlus(2, 3);
        Assert.assertEquals(5, ret);
        Mockito.verify(mockInnerClass).plus(2, 3);
    }
}

@RunWith(PowerMockRunner.class)
@PrepareForTest({MockPrivateObjectClass.class})
public class MockPrivateObjectClassTest {

    @Test
    public void doPlusMethod2Test() throws Exception {
        MockPrivateObjectClass objectClass = new MockPrivateObjectClass();
        MockPrivateObjectClass.InnerClass mockInnerClass = Mockito.spy(MockPrivateObjectClass.InnerClass.class);
        MemberModifier.field(MockPrivateObjectClass.class, "innerClass").set(objectClass, mockInnerClass);

        int ret = objectClass.doPlus(2, 3);
        Assert.assertEquals(5, ret);
        Mockito.verify(mockInnerClass).plus(2, 3);
    }
}

public class NormalClassA {
    public int publicAdd(int a, int b) {
        return privateAdd(a, b);
    }

    private int privateAdd(int a, int b) {
        return a + b;
    }
}

@RunWith(PowerMockRunner.class)
@PrepareForTest({NormalClassA.class})
public class NormalClassAPowerMockTest {
    @Test
    public void testPrivateMethod() throws Exception {
        NormalClassA classA = new NormalClassA();
        NormalClassA mockClassA = PowerMockito.spy(classA);

        mockClassA.publicAdd(2, 3);

        PowerMockito.verifyPrivate(mockClassA, times(1)).invoke("privateAdd", Mockito.anyInt(), Mockito.anyInt());
    }
}

public class ObjectWhiteBoxClass {
    private final List<String> mObjectList = new ArrayList<>();

    private void privateObjectAdd(String str) {
        mObjectList.add(str);
    }

    private void privateObjectRemove(String str) {
        mObjectList.remove(str);
    }

    public List<String> getObjectList() {
        return mObjectList;
    }
}

@Test
public void testInvokeMethod() throws Exception {
    ObjectWhiteBoxClass objectWhiteBoxClass = new ObjectWhiteBoxClass();

    Whitebox.invokeMethod(objectWhiteBoxClass, "privateObjectAdd", "test1");
    Whitebox.invokeMethod(objectWhiteBoxClass, "privateObjectAdd", "test2");

    Assert.assertEquals(2, objectWhiteBoxClass.getObjectList().size());

    Whitebox.invokeMethod(objectWhiteBoxClass, "privateObjectRemove", "test1");

    Assert.assertEquals(1, objectWhiteBoxClass.getObjectList().size());
}

public class MockPrivateObjectClass {
    public String stepName;

    public MockPrivateObjectClass() {

    }

    private void setStepName() {
        System.out.print("enter setStepName");
        stepName = "has set name";
    }

    public void testStepName() {
        setStepName();
        System.out.print(stepName);
    }
}

@Test
public void replacePrivateMethodTest() {
    MockPrivateObjectClass objectClass = new MockPrivateObjectClass();

    PowerMockito.replace(PowerMockito.method(MockPrivateObjectClass.class, "setStepName")).with(new InvocationHandler() {
        @Override
        public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
            Whitebox.setInternalState(o, "stepName", "modify step name");
            return null;
        }
    });

    objectClass.testStepName();
}

public class PrivateConstructorClass {
    private final List<String> mObjectList;

    private PrivateConstructorClass() {
        mObjectList = new ArrayList<>();
    }

    public void add(String str) {
        mObjectList.add(str);
    }

    public List<String> getObjectList() {
        return mObjectList;
    }
}

@Test
public void testInvokePrivateConstructor() throws Exception{
    PrivateConstructorClass object = Whitebox.invokeConstructor(PrivateConstructorClass.class);
    object.add("test1");
    Assert.assertEquals(1, object.getObjectList().size());
}

// 调用了私有的构造函数 PrivateConstructorClass()

public class NormalClassA {
    public String getClassBName() {
        NormalClassB b = new NormalClassB();
        return b.getName();
    }
}

public class NormalClassB {
    public String getName(){
        return "NormalClassB";
    }
}

public static class MockNormalClassB extends NormalClassB {
    @Override
    public String getName() {
        return "MockNormalClassB";
    }
}

@Test
public void testClassB() throws Exception {
    NormalClassA classA = new NormalClassA();
    String name = classA.getClassBName();
    System.out.println("before mock:" + name);
    Assert.assertEquals("NormalClassB", name);
    NormalClassB b = new MockNormalClassB();
    NormalClassB mockB = Mockito.spy(b);
    PowerMockito.whenNew(NormalClassB.class).withNoArguments().thenReturn(mockB);
    name = classA.getClassBName();
    System.out.println("after mock:" + name);
    Assert.assertEquals("MockNormalClassB", name);
    Mockito.verify(mockB).getName();
}

public class MockPrivateObjectClass {
    public String stepName;

    private void setStepName() {
        System.out.print("enter setStepName");
        stepName = "has set name";
    }

    public void testStepName() {
        setStepName();
        System.out.print(stepName);
    }
}

@Test
public void skipPrivateMethodTest() {
    MockPrivateObjectClass objectClass = new MockPrivateObjectClass();
    PowerMockito.suppress(PowerMockito.method(MockPrivateObjectClass.class, "setStepName"));
    objectClass.testStepName();
}

public class H5JsApiScriptInterface {
    private boolean shouldTriggerForAccount(int account) {
        return !isAccountValid(account) || !isMainAvailable();
    }
}

// 注意：要增加 PrepareForTest
@PrepareForTest({LoginManager.class, H5JsApiScriptInterface.class})
public class H5JsApiScriptInterfaceTest extends MainTNUnitTest {
    // qq connect
    @Test
    public void testShowLoginWithType_1() throws Exception{
        PowerMockito.mockStatic(LoginManager.class);
        H5JsApiScriptInterface mockScriptInterface = PowerMockito.mock(H5JsApiScriptInterface.class);
        Mockito.doCallRealMethod().when(mockScriptInterface).showLoginWithType(Mockito.anyString(), Mockito.anyString());
        // 打桩对象私有方法，mock 对象私有方法
        // 注意：要增加 PrepareForTest
        PowerMockito.when(mockScriptInterface, PowerMockito.method(H5JsApiScriptInterface.class, "shouldTriggerForAccount", int.class)).withArguments(Mockito.anyInt()).thenReturn(true);
        mockScriptInterface.showLoginWithType("qqconnect", "callback");
        PowerMockito.verifyStatic(LoginManager.class, Mockito.times(1));
        LoginManager.triggerLogin(Mockito.eq(LOGIN_FROM_WEB_ONLY_QQCONNECT), Mockito.any(Subscriber.class));
    }
}

public class StaticWhiteBoxClass {
    private final static List<String> mStaticList = new ArrayList<>();

    public static void publicStaticAdd(String str) {
        mStaticList.add(str);
    }

    public static List<String> getStaticList() {
        return mStaticList;
    }
}

@Test
public void testGetInternalState() {
    StaticWhiteBoxClass.publicStaticAdd("test1str");
    StaticWhiteBoxClass.publicStaticAdd("test2str");
    StaticWhiteBoxClass.publicStaticAdd("test3str");

    List<String> list = Whitebox.getInternalState(StaticWhiteBoxClass.class, "mStaticList");

    Assert.assertEquals(3, list.size());
    Assert.assertEquals("test3str", list.get(list.size()-1));
}

public class StaticWhiteBoxClass {
    private final static List<String> mStaticList = new ArrayList<>();

    public static void publicStaticAdd(String str) {
        mStaticList.add(str);
    }

    public static List<String> getStaticList() {
        return mStaticList;
    }
}

@Test
public void testSetInternalState() {
    List<String> list = new ArrayList<>();
    list.add("outer1");
    list.add("outer2");
    list.add("outer3");

    Whitebox.setInternalState(StaticWhiteBoxClass.class, "mStaticList", list);

    List<String> objList = StaticWhiteBoxClass.getStaticList();

    Assert.assertEquals(3, objList.size());
    Assert.assertEquals("outer3", list.get(objList.size()-1));
}

public class StaticWhiteBoxClass {
    private final static List<String> mStaticList = new ArrayList<>();

    private static void privateStaticAdd(String str) {
        mStaticList.add(str);
    }

    public static List<String> getStaticList() {
        return mStaticList;
    }
}

@Test
public void testInvokeMethod() throws Exception{
    Whitebox.invokeMethod(StaticWhiteBoxClass.class, "privateStaticAdd", "test1");
    Whitebox.invokeMethod(StaticWhiteBoxClass.class, "privateStaticAdd", "test2");

    Assert.assertEquals(2, StaticWhiteBoxClass.getStaticList().size());
}

public class StaticWhiteBoxClass {
    public static void originalMethod(String name) {
        System.out.println("enter originalMethod name:" + name);
    }
}

@Test
public void replacePrivateMethodTest() {
    PowerMockito.replace(PowerMockito.method(StaticWhiteBoxClass.class, "originalMethod")).with(new InvocationHandler() {
        @Override
        public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
            System.out.println("enter modify method param:" + objects[0]);
            return null;
        }
    });

    StaticWhiteBoxClass.originalMethod("test replace");
}

public class StaticClass {
    public static String ask(){
        return "I'm Static class";
    }
}

@Test
public void should_mock_static_method() {
    final String value = "10";
    mockStatic(StaticClass.class);
    when(StaticClass.ask()).thenReturn(value);
    Assert.assertNotEquals("I'm Static class", StaticClass.ask());
}

public class H5JsApiScriptInterface {
    // 静态私有方法
    private static boolean isQQorWxAvailable() {
        return true;
    }
}

@PrepareForTest({LoginManager.class, H5JsApiScriptInterface.class})
public class H5JsApiScriptInterfaceTest extends MainTNUnitTest { // qq and wx
    @Test
    public void testShowLoginWithType_4() throws Exception{
        PowerMockito.mockStatic(LoginManager.class);
        PowerMockito.mockStatic(H5JsApiScriptInterface.class);
        H5JsApiScriptInterface mockScriptInterface = PowerMockito.mock(H5JsApiScriptInterface.class);
        Mockito.doCallRealMethod().when(mockScriptInterface).showLoginWithType(Mockito.anyString(), Mockito.anyString());
        // 打桩静态私有方法，mock静态私有方法，注意增加@PrepareForTest
        PowerMockito.doReturn(false).when(H5JsApiScriptInterface.class, "isQQorWxAvailable");
        mockScriptInterface.showLoginWithType("qqorweixin", "callback");
        PowerMockito.verifyStatic(LoginManager.class, Mockito.times(1));
        LoginManager.triggerLogin(Mockito.eq(LOGIN_FROM_WEB_BOTH_QQ_AND_WX), Mockito.any(Subscriber.class));
    }
}

public class StaticClass {
    public static int add(int a, int b) {
        return a + b;
    }
    public static int sum() {
        int ret = 0;
        for (int i = 0; i < 10; i++) {
            ret = add(i, i+1);
        }
        return ret;
    }
}

@Test
public void call_mock_sum_static_method() {
    mockStatic(StaticClass.class);
    // 如果不用 spy，就用 thenCallRealMethod 也可以
    when(StaticClass.sum()).thenCallRealMethod();
    when(StaticClass.add(Mockito.anyInt(),Mockito.anyInt())).thenCallRealMethod();
    int sum = StaticClass.sum();
    Assert.assertEquals(19, sum);
}

public class StaticClass {
    public static int add(int a, int b) {
        return a + b;
    }
    public static int sum() {
        int ret = 0;
        for (int i = 0; i < 10; i++) {
            ret = add(i, i+1);
        }
        return ret;
    }
}

@Test
public void call_spy_sum_static_method() {
    mockStatic(StaticClass.class);
    // mock 的话，函数都是空的切记，如果需要用到函数逻辑，要用 spy
    spy(StaticClass.class);
    int sum = StaticClass.sum();
    Assert.assertEquals(19, sum);
}

public class StaticClass {
    public static int add(int a, int b) {
        return a + b;
    }
    public static int sum() {
        int ret = 0;
        for (int i = 0; i < 10; i++) {
            ret = add(i, i+1);
        }
        return ret;
    }
}

@Test
public void call_spy_sum_static_method() {
    mockStatic(StaticClass.class);
    // mock 的话，函数都是空的切记，如果需要用到函数逻辑，要用 spy
    spy(StaticClass.class);
    int sum = StaticClass.sum();
    Assert.assertEquals(19, sum);
    verifyStatic(StaticClass.class, Mockito.times(10)); // 验证调用了 10 次
    StaticClass.add(Mockito.anyInt(),Mockito.anyInt()); // 验证的是 add 方法
}

public class StaticClass {
    public static int dec(int total) {
        int ret = total;
        for (int i = 0; i < 10; i++) {
            ret = sub(ret, i);
        }
        return ret;
    }
    private static int sub(int a, int b) {
        return a - b;
    }
}

@Test
public void call_private_dec_static_method() throws Exception {
    mockStatic(StaticClass.class);
    spy(StaticClass.class);
    int ret = StaticClass.dec(100);
    Assert.assertEquals(55, ret);
    verifyPrivate(StaticClass.class, Mockito.atLeastOnce()).invoke("sub",
            Mockito.anyInt(), Mockito.anyInt());
}

public class StaticClass {
    public static String mStepName;
    public static void testStepName() {
        setStepName();
    }
    private static void setStepName() {
        System.out.println("enter setStepName");
        mStepName = "setStepName";
    }
}

@Test
public void skipStaticMethodTest() {
    PowerMockito.suppress(PowerMockito.method(StaticClass.class, "setStepName"));
    StaticClass.testStepName();
    System.out.println("step name:" + StaticClass.mStepName);
}

public final class FinalClassA {
    public final String finalMethod() {
        return "finalMethod";
    }
}

@Test
public final void mockPowerFinalClassTest() {
    FinalClassA instance = new FinalClassA();
    FinalClassA mock = PowerMockito.mock(FinalClassA.class);
    Mockito.when(mock.finalMethod()).thenReturn("mock method");
    Assert.assertNotEquals(instance.finalMethod(), mock.finalMethod());
}

public class NormalClassA {
    public void setAbsCallback() {
        AbsCallback callback = new AbsCallback() {
            @Override
            void call() {
                System.out.println("impl AbsCallback");
            }
        };
        callback.call();
    }
    public static class AbsCallback {
        public AbsCallback() {
        }
        void call(){
            System.out.println("impl default AbsCallback");
        };
    }
    public static class MockAbsCallback extends NormalClassA.AbsCallback {
        @Override
        void call() {
            System.out.println("mock impl AbsCallback");
        }
    }
}