一、什么是单元测试？

在 Java 中，单元测试就是为了测试某一个类里的某一个方法是否正常执行，而编写的测试代码。

当我们需要对某一个类里的某一个方法进行单元测试时，首先要确认好以下几个问题：
① 这个方法的功能是什么？

• 参数（如果有的话）
• 返回值（如果有的话）
• 具体操作

② 测试方法应该做什么？

• 构造参数（如果需要的话）
• 构造返回值（如果需要的话）
• 验证结果

③ 什么是实际的输出？
④ 什么是预期的输出？

二、单元测试需要用到哪些框架？

JUnit：
JUnit 是一个 Java 编程语言的单元测试框架，能够方便开发人员快速编写单元测试代码。 JUnit 使用注解来识别测试方法（JUnit4），并提供断言机制来验证预期结果。JUnit 只能运行在本地开发环境的 Java 虚拟机上。

Mockito：
Mockito 是一个用于 Java 单元测试中的 mocking 框架，mock 就是模拟的意思。在编写单元测试代码时，有时候我们不需要某个对象真实执行某个方法的代码，只是需要该对象在调用该方法时按照我们的预期返回特定值即可，这时就可以 mock 一个对象出来使用，非常方便。

Robolectric：
JUnit 和 Mockito 都是针对 Java 平台的测试框架。对于 Android 应用开发来说，我们需要调用 Android SDK 的 API，开发好的应用程序需要打包成 APK 文件并安装到 Android 设备上才能运行测试，效率很低。
Robolectric 框架实现了一套在 Java 虚拟机上能运行的 Android SDK，从而使得 Android 应用程序能够脱离 Android 环境运行测试，提高了测试效率。

三、如何搭建单元测试环境？

① 在 module 的 build.gradle 中添加以下内容，并执行 Gradle 同步

dependencies {
    ...
    testImplementation 'junit:junit:4.13.2'
    testImplementation 'org.mockito:mockito-core:3.3.3'
    testImplementation "org.robolectric:robolectric:4.3.1"

    testImplementation 'androidx.test:core:1.0.0'
    ...
}

② 在 test 目录下新建一个 Java 文件

public class UnitTestRobolectricTestRunner extends RobolectricTestRunner {
    private static final int DEFAULT_SDK = 28;

    static {
        System.setProperty("robolectric.dependency.repo.id", "Samsung");
        System.setProperty("robolectric.dependency.repo.url", "http://IP:PORT/lm/content/groups/public/");
    }

    public UnitTestRobolectricTestRunner(Class<?> testClass) throws InitializationError {
        super(testClass);
    }

    @Override
    protected Config buildGlobalConfig() {
        return new Config.Builder()
                .setApplication(android.app.Application.class)
                .setSdk(DEFAULT_SDK)
                .build();
    }
}

③ 在 test 目录下再新建一个 Java 文件，并运行测试看是否执行成功

@RunWith(UnitTestRobolectricTestRunner.class)
public class MainActivityTest {
    @Test
    public void test_onCreate() {
        MainActivity activity = Robolectric.buildActivity(MainActivity.class).create().get();
        TextView textView = activity.findViewById(R.id.tv);
        Assert.assertEquals("Hello World!", textView.getText().toString());
    }
}

四、如何编写单元测试代码？

JUnit4 的基本使用

① 基础方法注解

@Test：被注解的方法是个测试方法。
@Before：被注解的方法会在每个测试方法执行前都调用一次。 
@After：被注解的方法会在每个测试方法执行后都调用一次。 
@BeforeClass：被注解的方法会在所有的测试方法执行前调用一次。
@AfterClass：被注解的方法会在所有的测试方法执行后调用一次。
@Ignore：被注解的方法会被忽略，不执行。

② 常用断言
JUnit 提供了一些辅助方法，用来帮助我们确定被测试方法是否按照预期正常执行，这些辅助方法称为断言。

assertEquals：验证两个值是否相等。
assertNotEquals：验证两个值是否不相等。
assertArrayEquals：验证两个数组是否相等。
assertSame：验证两个引用是否指向同一个对象。
assertNotSame：验证两个引用是否指向不同对象。
assertNull：验证某个对象是否为 null。
assertNotNull：验证某个对象是否不为 null。
assertTrue：验证某个条件是否为 true。
assertFalse：验证某个条件是否为 false。

③ Hamcrest 与 assertThat
JUnit 提供的断言验证的内容较为简单，如果需要验证较为复杂的内容可以使用 Hamcrest 表达式类库，它提供了一套匹配符。使用 Gradle 引入 JUnit4 时会同时引入 Hamcrest 相关类库，无需额外引入。

public static <T> void assertThat(T actual, Matcher<? super T> matcher)
==> 可以用来进行 字符串、数值、集合、对象、逻辑 等的匹配。

Mockito 的基本使用

① mock
创建一个模拟对象，Mockito 会记住它所 mock 对象的所有调用，为后续的验证做准备。
默认情况下，调用 mock 对象的方法是不会真实执行的，对于带返回值的方法会返回默认值，比如 null、0 或者 false 等。当然我们也可以让 mock 对象真实执行方法。

② when
当 mock 对象调用其方法时，开发人员可以根据测试需要指定相应的响应，比如返回特定的值、抛出异常或者真实执行方法等。

when(...).thenReturn(...)：当调用某个方法时返回特定值。
when(...).thenThrow(...)：当调用某个方法时抛出异常。

doReturn(...).when(...)：返回特定值当调用某个方法时。
doThrow(...).when(...)：抛出异常当调用某个方法时。
doNothing(...).when(...)：不做任何事情当调用某个方法时。
doCallRealMethod(...).when(...)：真实执行方法当调用某个方法时。
doAnswer(desiredAnswer).when(mockObject).targetMethod(args)

③ verify
负责验证 mock 对象是否调用了相应的方法。

Robolectric 的基本使用

① Activity 测试

@Deprecated
public static <T extends Activity> T setupActivity(Class<T> activityClass)
==> 创建一个 Activity，创建后的 Activity 会经历 onCreate、onStart、onResume 这几个生命周期。

public static <T extends Activity> ActivityController<T> buildActivity(Class<T> activityClass)
==> 创建一个ActivityController，然后需要自己手动控制 Activity 的生命周期。

② Button 测试

public boolean performClick()
==> 执行 Button 点击操作。

public boolean performLongClick() 
==> 执行 Button 长按操作。

③ Shadow
Shadow 是影子的意思，Robolectric 定义了很多 Shadow 类，用来修改或者扩展 Android SDK 中类的行为。
当一个 Android SDK 中的类被实例化时，Robolectric 会去寻找对应的影子类，如果找到了则会创建一个影子对象并与实例对象相关联。当实例对象中的方法被调用时，Robolectric 会保证影子对象中相应的方法被调用。

@Implements(Activity.class)
public class ShadowActivity extends ShadowContextThemeWrapper 
    @RealObject
    protected Activity realActivity;

自定义 Shadow：

public class NetworkUtil {
    public static boolean isNetworkConnected(Context context) {
        ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (cm == null) {
            return false;
        }
        NetworkInfo networkInfo = cm.getActiveNetworkInfo();
        return networkInfo != null && networkInfo.isConnected();
    }
}

@Implements(NetworkUtil.class)
public class ShadowNetworkUtil {
    private static boolean sNetworkConnected;

    @Implementation
    public static boolean isNetworkConnected(Context context) {
        return sNetworkConnected;
    }

    public static void setNetworkConnected(boolean networkConnected) {
        sNetworkConnected = networkConnected;
    }
}

@RunWith(UnitTestRobolectricTestRunner.class)
public class RobolectricShadowTest {
    private RobolectricShadow mRobolectricShadow;
    private NetworkManager mNetworkManager;

    @Before
    public void setUp() {
        mNetworkManager = mock(NetworkManager.class);
        mRobolectricShadow = new RobolectricShadow(mNetworkManager);
    }

    @After
    public void tearDown() {
        mRobolectricShadow = null;
    }

    @Config(shadows = {ShadowNetworkUtil.class})
    @Test
    public void test_isNetworkRequestSuccess() {
        String strUrl = null;
        Assert.assertFalse(mRobolectricShadow.isNetworkRequestSuccess(strUrl));
        verify(mNetworkManager, never()).doNetworkRequest(anyString());

        strUrl = "testUrl";
        Assert.assertFalse(mRobolectricShadow.isNetworkRequestSuccess(strUrl));
        verify(mNetworkManager, never()).doNetworkRequest(anyString());

        strUrl = "https://testUrl";

        //将 Shadow 类的网络连接状态设置为 false
        ShadowNetworkUtil.setNetworkConnected(false);
        System.out.println("isNetworkConnected_1: " + NetworkUtil.isNetworkConnected(ApplicationProvider.getApplicationContext()));
        Assert.assertFalse(mRobolectricShadow.isNetworkRequestSuccess(strUrl));
        verify(mNetworkManager, never()).doNetworkRequest(anyString());

        //将 Shadow 类的网络连接状态设置为 true
        ShadowNetworkUtil.setNetworkConnected(true);
        System.out.println("isNetworkConnected_2: " + NetworkUtil.isNetworkConnected(ApplicationProvider.getApplicationContext()));
        doReturn("response").when(mNetworkManager).doNetworkRequest(anyString());
        Assert.assertTrue(mRobolectricShadow.isNetworkRequestSuccess(strUrl));
        verify(mNetworkManager).doNetworkRequest(strUrl);

        reset(mNetworkManager);
        doReturn(null).when(mNetworkManager).doNetworkRequest(anyString());
        Assert.assertFalse(mRobolectricShadow.isNetworkRequestSuccess(strUrl));
        verify(mNetworkManager).doNetworkRequest(strUrl);
    }
}

五、单元测试是如何跑起来的？

① 程序入口

java.lang.RuntimeException: Just a test
at com.tomorrow.unittestdemo.HowToRunTest.test(HowToRunTest.java:9)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:498) ==> 反射调用，执行测试方法
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:59)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:56)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)
at org.junit.runners.BlockJUnit4ClassRunner$1.evaluate(BlockJUnit4ClassRunner.java:100)
at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:366)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:103)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:63)
at org.junit.runners.ParentRunner$4.run(ParentRunner.java:331)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:79)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:329)
at org.junit.runners.ParentRunner.access$100(ParentRunner.java:66)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:293)
at org.junit.runners.ParentRunner$3.evaluate(ParentRunner.java:306)
at org.junit.runners.ParentRunner.run(ParentRunner.java:413) ==> Test Runner：BlockJUnit4ClassRunner
at org.junit.runner.JUnitCore.run(JUnitCore.java:137) ==> 导入的 JUnit 库程序入口
at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
at com.intellij.rt.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:33)
at com.intellij.rt.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:230)
at com.intellij.rt.junit.JUnitStarter.main(JUnitStarter.java:58) ==> 集成开发工具的 JUnit 插件相关代码

② Test Runner
Test Runner 是一个用于执行测试代码和输出测试结果的组件。
JUnit4 默认使用的是 BlockJUnit4ClassRunner。另外，也可以使用 @RunWith 指定 Test Runner，比如当程序中调用了 Android SDK 的代码或者需要使用 Shadow 机制时就要指定为 RobolectricTestRunner。

③ 运行时注解

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Test {
}

④ 反射调用

@Override
protected Object runReflectiveCall() throws Throwable {
    return method.invoke(target, params);
}

六、ApprovalTests 库

对于 JavaBean 和 POJO 的单元测试，推荐使用 ApprovalTests 库。

① 添加依赖

testImplementation 'com.approvaltests:approvaltests:9.3.0'

② 重写 toString() 方法
一般我们重写类的 toString() 方法，是使用 Alt + Insert，然后选择 toString() 来重写，但是自带的模板生成的 toString() 不能通过 ApprovalTests 库的测试。
我们可以通过自定义 toString() 模板来解决，新建模板的方法： ALt + Insert -> toString() -> Settings -> Templates -> 新建模板，比如命名为 MyToStringTemlate，模板内容可参考如下：

@NonNull
public java.lang.String toString() {
final java.lang.StringBuilder sb = new java.lang.StringBuilder("$classname{");
#set ($i = 0)
#foreach ($member in $members)#if ($i == 0)
sb.append("#####
#else
sb.append(",####
#end#if ($member.string || $member.date)
\"$member.name\":\"")####
#else
\"$member.name\":")####
#end#if ($member.primitiveArray || $member.objectArray)
.append(java.util.Arrays.toString($member.name));
#elseif ($member.string || $member.date)
.append($member.accessor).append('\"');
#else
.append($member.accessor);
#end#set ($i = $i + 1)
#end
sb.append('}');
return sb.toString();
}

例子：

//JavaBean（可以使用 Alt + Insert，选择 Getter and Setter，自动生成 Getter 跟 Setter 方法）
public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

//使用默认 toString() 模板
@Override
public String toString() {
    return "Person{" +
            "name='" + name + '\'' +
            ", age=" + age +
            '}';
}
==> Person{name='Android', age=10}

//使用自定义 toString() 模板
@Override
@NonNull
public String toString() {
    final StringBuilder sb = new StringBuilder("Person{");
    sb.append("\"name\":\"").append(name).append('\"');
    sb.append(",\"age\":").append(age);
    sb.append('}');
    return sb.toString();
}
==> Person{"name":"Android","age":10}

//使用 Getter 方法替代直接使用属性名，目的是测试 Getter 方法
@Override
@NonNull
public String toString() {
    final StringBuilder sb = new StringBuilder("Person{");
    sb.append("\"name\":\"").append(getName()).append('\"');
    sb.append(",\"age\":").append(getAge());
    sb.append('}');
    return sb.toString();
}
==> Person{"name":"Android","age":10}

③ 运行测试

public class PeopleTest {
    @Test
    public void testJavaBean() {
        Person person = new Person();
        person.setName("Android");
        person.setAge(10);
        Approvals.verify(person);
    }
}

第一次运行会失败，ApprovalTests 库会生成一个文件：PeopleTest.testJavaBean.received.txt，需要将该文件的名字改为：PeopleTest.testJavaBean.approved.txt，再次运行即可成功。

七、参考链接

Android单元测试
Mockito
Robolectric
PowerMock