JUnit是java开发人员的一个主要的测试工具，做Android开发同样是离不开java的，所以Android单元测试依然可以基于JUnit来写测试。但是JUnit只能运行在纯java环境上，前面我们介绍过MVP架构下，可以将View层隔离开来，单独针对Presenter层、Model层来测试。

4.1 JUnit4配置

在build.gradle中加入依赖配置，采用JUnit4框架。

testCompile 'junit:junit:4.12'

JUnit文件夹在工程中的位置，工程创建后，在app -> src目录下，会有3个文件夹：androidTest, main, test。test文件目录就是JUnit单元测试默认的目录。

创建工程时，默认会生成一个单元测试例子ExampleUnitTest.java，且看看一个最简单的Junit单元测试是怎么写的：

public class ExampleUnitTest {
    @Test
    public void addition_isCorrect() throws Exception {
        assertEquals(4, 2 + 2);
    }
}

里面只有一个测试方法，方法上有一个@Test注解，选中方法名，右键选中“Run 'addition_isCorrect()'”执行单元测试，会出现执行结果：

“OK”表示单元测试运行通过，到这里我们已经在Android上执行了一次单元测试。

4.2 JUnit4基础方法注解

JUnit3是通过对测试类和测试方法的命名来确定是否是测试，如测试方法必须以test开头。而在JUnit4中，是通过注解来确定的。

• @Test
  说明该方法是测试方法。测试方法必须是public void，可以抛出异常。
• @Before
  它会在每个测试方法执行前都调用一次。
• @After
  与@Before对应，它会在每个测试方法执行完后都调用一次。
• @BeforeClass
  它会在所有的测试方法执行之前调用一次。与@Before的差别是：@Before注解的方法在每个方法执行前都会调用一次，有多少个测试方法就会掉用多少次；而@BeforeClass注解的方法只会执行一次，在所有的测试方法执行前调用一次。注意该注解的测试方法必须是public static void修饰的。
• @AfterClass
  与@BeforeClass对应，它会在所有的测试方法执行完成后调用一次。注意该注解的测试方法必须是public static void修饰的。
• @Ignore
  忽略该测试方法，有时我们不想运行某个测试方法时，可以加上该注解。
  以上这些注解都是针对测试方法而言的，并且是一些常用的注解，我们会频繁用到。我们写个测试类来运行一下，看看具体的执行顺序，代码如下：

public class TestJUnitLifeCycle {

    @BeforeClass
    public static void init() {
        System.out.println("------init()------");
    }

    @Before
    public void setUp() {
        System.out.println("------setUp()------");
    }

    @After
    public void tearDown() {
        System.out.println("------tearDown()------");
    }

    @AfterClass
    public static void finish() {
        System.out.println("------finish()------");
    }

    @Test
    public void test1() {
        System.out.println("------test1()------");
    }

    @Test
    public void test2() {
        System.out.println("------test2()------");
    }
}

执行后打印结果如下：

------init()------
------setUp()------
------test1()------
------tearDown()------
------setUp()------
------test2()------
------tearDown()------
------finish()------

4.3 JUnit4常用断言

JUnit提供了一些辅助函数，他们用来帮助我们确定被测试的方法是否按照预期正常执行，这些辅助函数我们称之为断言(Assertion)。JUnit4所有的断言都在org.junit.Assert类中，Assert类包含了一组静态的测试方法，用于验证期望值expected与实际值actual之间的逻辑关系是否正确，如果不符合我们的预期则表示测试未通过。

• assertEquals([message], expected, actual)
  验证期望值与实际值是否相等，如果相等则表示测试通过，不相等则表示测试未通过，并抛出异常AssertionError。message表示自定义错误信息，为可选参数，以下均雷同。
• assertNotEquals([message], unexpected, actual)
  验证期望值与实际值不相等。
• assertArrayEquals([message], expecteds, actuals)
  验证两个数组是否相同
• assertSame([message], expected, actual)
  断言两个引用指向同一个对象。
• assertNotSame([message], expected, actual)
  断言两个引用指向不同的对象。
• assertNull([message], object)
  断言某个对象为null。
• assertNotNull([message], object)
  断言对象不为null。
• assertTrue([message], condition)
  断言条件为真。
• assertFalse([message], condition)
  断言条件为假。

4.4 Hamcrest与assertThat

Hamcrest是一个表达式类库，它提供了一套匹配符Matcher，且看其官网的说明：

Hamcrest is a library of matchers, which can be combined in to create flexible expressions of intent in tests. They've also been used for other purposes.

前面提到的那些断言方法，大家使用起来会可能会碰到一个问题：

• 断言通常必须使用一个固定的expected值，如果测试数据稍微有一点变化，测试就可能不通过，这使得测试非常脆弱。例如我们断言assertEquals(0, code)，只能判断code是不是为0，如果code不等于0则测试失败，如果code = 0或者 code = 1都是符合我的预期的呢？那又该如何测试。

JUnit4结合Hamcrest提供了一个全新的断言语法：assertThat，结合Hamcrest提供的匹配符，可以表达全部的测试思想，上面提到的问题也迎刃而解。
使用gradle引入JUnit4.12时已经包含了hamcrest-core.jar、hamcrest-library.jar、hamcrest-integration.jar这三个jar包，所以我们无需额外再单独导入hamcrest相关类库。
assertThat定义如下：

public static <T> void assertThat(String reason, T actual,
            Matcher<? super T> matcher)

4.4.1 字符串相关匹配符

• startsWith
• endsWith
• containsString
• equalToIgnoringCase
• equalToIgnoringWhiteSpace

4.4.2 数值相关匹配符

• closeTo
• greaterThan
• lessThan
• lessThanOrEqualTo
• greaterThanOrEqualTo

4.4.3 集合相关匹配符

• hasEntry
• hasKey
• hasValue
• hasItem
• hasItems
• hasItemInArray

4.4.4 对象相关匹配符

• notNullValue
• nullValue
• sameInstance
• instanceOf
• hasProperty

4.4.5 组合等逻辑匹配符

• allOf
• anyOf
• both
• either
• is
• isA
• not
• any
• anything

//文本
assertThat("android studio", startsWith("and"));
assertThat("android studio", endsWith("dio"));
assertThat("android studio", containsString("android"));
assertThat("android studio", equalToIgnoringCase("ANDROID studio"));
assertThat("android studio ", equalToIgnoringWhiteSpace(" android studio "));

//数字
//测试数字在某个范围之类，10.6在[10.5-0.2, 10.5+0.2]范围之内
assertThat(10.6, closeTo(10.5, 0.2));
//测试数字大于某个值
assertThat(10.6, greaterThan(10.5));
//测试数字小于某个值
assertThat(10.6, lessThan(11.0));
//测试数字小于等于某个值
assertThat(10.6, lessThanOrEqualTo(10.6));
//测试数字大于等于某个值
assertThat(10.6, greaterThanOrEqualTo(10.6));

//集合类测试
Map<String, String> map = new HashMap<String, String>();
map.put("a", "hello");
map.put("b", "world");
map.put("c", "haha");
//测试map包含某个entry
assertThat(map, hasEntry("a", "hello"));
//测试map是否包含某个key
assertThat(map, hasKey("a"));
//测试map是否包含某个value
assertThat(map, hasValue("hello"));
List<String> list = new ArrayList<String>();
list.add("a");
list.add("b");
list.add("c");
//测试list是否包含某个item
assertThat(list, hasItem("a"));
assertThat(list, hasItems("a", "b"));
//测试数组是否包含某个item
String[] array = new String[]{"a", "b", "c", "d"};
assertThat(array, hasItemInArray("a"));

//测试对象
//测试对象不为null
assertThat(new Object(), notNullValue());
Object obj = null;
//测试对象为null
assertThat(obj, nullValue());
String str = null;
assertThat(str, nullValue(String.class));
obj = new Object();
Object obj2 = obj;
//测试2个引用是否指向的通一个对象
assertThat(obj, sameInstance(obj2));
str = "abc";
assertThat(str, instanceOf(String.class));

//测试JavaBean对象是否有某个属性
assertThat(new UserInfo(), hasProperty("name"));
assertThat(new UserInfo(), hasProperty("age"));

//-------组合逻辑测试--------
//两者都满足，a && b
assertThat(10.4, both(greaterThan(10.0)).and(lessThan(10.5)));
//所有的条件都满足，a && b && c...
assertThat(10.4, allOf(greaterThan(10.0), lessThan(10.5)));
//任一条件满足，a || b || c...
assertThat(10.4, anyOf(greaterThan(10.3), lessThan(10.4)));
//两者满足一个即可，a || b
assertThat(10.4, either(greaterThan(10.0)).or(lessThan(10.2)));
assertThat(10.4, is(10.4));
assertThat(10.4, is(equalTo(10.4)));
assertThat(10.4, is(greaterThan(10.3)));
str = new String("abc");
assertThat(str, is(instanceOf(String.class)));
assertThat(str, isA(String.class));
assertThat(10.4, not(10.5));
assertThat(str, not("abcd"));

assertThat(str, any(String.class));
assertThat(str, anything());

4.5 测试方法执行顺序

当我们运行一个测试类里的所有测试方法时，测试方法的执行顺序并不是固定的，JUnit4提供@ FixMethodOrder注解来配置执行顺序，其可选值有：MethodSorters.NAME_ASCENDING、MethodSorters.DEFAULT、MethodSorters.JVM

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class TestExecOrder {

    @Test
    public void testD() {
        System.out.println("DDDDD");
    }

    @Test
    public void testA() {
        System.out.println("AAAAA");
    }

    @Test
    public void testB() {
        System.out.println("BBBBB");
    }

    @Test
    public void testC() {
        System.out.println("CCCCC");
    }
    
}

@FixMethodOrder(MethodSorters.NAME_ASCENDING)执行结果（按名称升序排列）：
AAAAA
BBBBB
CCCCC
DDDDD

@FixMethodOrder(MethodSorters.JVM)执行结果（每次执行可能都不一样）：
CCCCC
DDDDD
AAAAA
BBBBB

4.6 小结

本文介绍了JUnit4在android开发中怎样配置，JUnit的基本用法，JUnit常用的断言机制，以及与Hamcrest结合起来的强大的assertThat断言，这些功能基本上能满足我们绝大部分的单元测试编写。
接下来还会再介绍JUnit里更好玩的、更高级的用法。

系列文章：
Android单元测试（一）：前言
Android单元测试（二）：什么是单元测试
Android单元测试（三）：测试难点及方案选择
Android单元测试（四）：JUnit介绍
Android单元测试（五）：JUnit进阶
Android单元测试（六）：Mockito学习
Android单元测试（七）：Robolectric介绍
Android单元测试（八）：怎样测试异步代码