前面一章介绍了JUnit的一些基本用法，本章来介绍关于JUnit更高级的用法，这些功能我们可能并不一定会用到，但是了解它，对JUnit会有更深刻的认识。
5.1 Test runners
大家刚开始使用JUnit的时候，可能会跟我一样有一个疑问，JUnit没有main()方法，那它是怎么开始执行的呢？众所周知，不管是什么程序，都必须有一个程序执行入口，而这个入口通常是main()方法。显然，JUnit能直接执行某个测试方法，那么它肯定会有一个程序执行入口。没错，其实在org.junit.runner包下，有个JUnitCore.java类，这个类有一个标准的main()方法，这个其实就是JUnit程序的执行入口，其代码如下：
public static void main(String... args) {
Result result = new JUnitCore().runMain(new RealSystem(), args);
System.exit(result.wasSuccessful() ? 0 : 1);
}
通过分析里面的runMain()方法，可以找到最终的执行代码如下：
public Result run(Runner runner) {
Result result = new Result();
RunListener listener = result.createListener();
notifier.addFirstListener(listener);
try {
notifier.fireTestRunStarted(runner.getDescription());
runner.run(notifier);
notifier.fireTestRunFinished(result);
} finally {
removeListener(listener);
}
return result;
}
可以看到，所有的单元测试方法都是通过Runner来执行的。Runner只是一个抽象类，它是用来跑测试用例并通知结果的，JUnit提供了很多Runner的实现类，可以根据不同的情况选择不同的test runner。
5.1.1 @RunWith
通过@RunWith注解，可以为我们的测试用例选定一个特定的Runner来执行。
- 默认的test runner是 BlockJUnit4ClassRunner。
- @RunWith(JUnit4.class)，使用的依然是默认的test runner，实质上JUnit4继承自BlockJUnit4ClassRunner。
5.1.2 Suite
Suite翻译过来是测试套件，意思是让我们将一批其他的测试类聚集在一起，然后一起执行，这样就达到了同时运行多个测试类的目的。
如上图所示，假设我们有3个测试类：TestLogin, TestLogout, TestUpdate，使用Suite编写一个TestSuite类，我们可以将这3个测试类组合起来一起执行。TestSuite类代码如下：
@RunWith(Suite.class)
@Suite.SuiteClasses({
TestLogin.class,
TestLogout.class,
TestUpdate.class
})
public class TestSuite {
//不需要有任何实现方法
}
执行运行TestSuite，相当于同时执行了这3个测试类。
Suite还可以进行嵌套，即一个测试Suite里包含另外一个测试Suite。
@RunWith(Suite.class)
@Suite.SuiteClasses(TestSuite.class)
public class TestSuite2 {
}
5.1.3 Parameterized
我们常规的测试方法都是public void修饰的，不能带有任何输入参数。但是有时我们需要在测试方法里输入参数，甚至可能需要指定批量的参数，如果使用常规的模式，那就需要为每一种参数写一个测试方法，这显然不是我们所期望的。使用Parameterized这个test runner就能实现这个目的。
我们有一个待测试类，菲波那切函数，代码如下：
public class Fibonacci {
public static int compute(int n) {
int result = 0;
if(n <= 1) {
result = n;
} else {
result = compute(n -1) + compute(n - 2);
}
return result;
}
}
针对这个函数，我们需要多个输入参数来验证是否正确，来看看怎么实现这个目的。
- 使用构造函数来注入参数值
//指定Parameterized作为test runner
@RunWith(Parameterized.class)
public class TestParams {
//这里是配置参数的数据源，该方法必须是public static修饰的，且必须返回一个可迭代的数组或者集合
//JUnit会自动迭代该数据源，自动为参数赋值，所需参数以及参数赋值顺序由构造器决定。
@Parameterized.Parameters
public static List getParams() {
return Arrays.asList(new Integer[][]{
{ 0, 0 }, { 1, 1 }, { 2, 1 }, { 3, 2 }, { 4, 3 }, { 5, 5 }, { 6, 8 }
});
}
private int input;
private int expected;
//在构造函数里，指定了2个输入参数，JUnit会在迭代数据源的时候，自动传入这2个参数。
//例如：当获取到数据源的第3条数据{2，1}时，input=2，expected=1
public TestParams(int input, int expected) {
this.input = input;
this.expected = expected;
}
@Test
public void testFibonacci() {
System.out.println(input + "," + expected);
Assert.assertEquals(expected, Fibonacci.compute(input));
}
}
执行该测试类，可以看到执行过程中的打印结果：
0,0
1,1
2,1
3,2
4,3
5,5
6,8
- 使用@Parameter注解来注入参数值
@RunWith(Parameterized.class)
public class TestParams2 {
@Parameterized.Parameters
public static List getParams() {
return Arrays.asList(new Integer[][]{
{ 0, 0 }, { 1, 1 }, { 2, 1 }, { 3, 2 }, { 4, 3 }, { 5, 5 }, { 6, 8 }
});
}
//这里必须是public，不能是private
@Parameterized.Parameter
public int input;
//注解括号里的参数，用来指定参数的顺序，默认为0
@Parameterized.Parameter(1)
public int expected;
@Test
public void testFibonacci() {
System.out.println(input + "," + expected);
Assert.assertEquals(expected, Fibonacci.compute(input));
}
}
5.1.4 Categories
Categories继承自Suite，但是比Suite功能更加强大，它能对测试类中的测试方法进行分类执行。当你想把不同测试类中的测试方法分在一组，Categories就很管用。
- 先定义category marker类，它们只是用来标记类别的，并不承担任何业务逻辑。
public interface CategoryMarker {
public interface FastTests {
/* category marker */
}
public interface SlowTests {
/* category marker */
}
}
- 通过@Category注解来标记测试方法的类别
public class A {
@Test
public void a() {
System.out.println("method a() called in class A");
}
//标记该测试方法的类别
@Category(CategoryMarker.SlowTests.class)
@Test
public void b() {
System.out.println("method b() called in class A");
}
}
- 通过@Category注解来标记测试类的类别
@Category({CategoryMarker.FastTests.class, CategoryMarker.SlowTests.class})
public class B {
@Test
public void c() {
System.out.println("method c() called in class B");
}
}
- 分类执行
@RunWith(Categories.class)
@Categories.IncludeCategory(CategoryMarker.SlowTests.class)
@Suite.SuiteClasses({A.class, B.class}) //Categories本身继承自Suite
public class SlowTestSuite {
//如果不加@Categories.IncludeCategory注解，效果与Suite一样
}
//执行结果，打印信息如下：
method b() called in class A
method c() called in class B
@RunWith(Categories.class)
@Categories.IncludeCategory({CategoryMarker.SlowTests.class}) //指定包含的类别
@Categories.ExcludeCategory({CategoryMarker.FastTests.class}) //需要排除的类别
@Suite.SuiteClasses({A.class, B.class})
public class SlowTestSuite2 {
}
//执行结果，打印信息如下：
method b() called in class A
5.2 @Test的属性
5.2.1 timeout
timeout用来测试一个方法能不能在规定时间内完成，当为一个测试方法指定了timeout属性后，该方法会运行在一个单独的线程里执行。如果测试方法运行时间超过了指定的timeout时间，测试则会失败，并且JUnit会中断执行该测试方法的线程。
//该方法会在一个单独的线程中执行，单位为毫秒，这里超时时间为2秒
@Test(timeout = 2000)
public void testTimeout() {
System.out.println("timeout method called in thread " + Thread.currentThread().getName());
}
//该方法默认会在主线程中执行
@Test
public void testNormalMethod() {
System.out.println("normal method called in thread " + Thread.currentThread().getName());
}
//该方法指定了timeout时间为1秒，实际运行时会超过1秒，该方法测试无法通过
@Test(timeout = 1000)
public void testTimeout2() {
try {
Thread.sleep(1200);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
执行后打印结果如下：
timeout method called in thread Time-limited test
normal method called in thread main
5.2.2 expected
expected属性是用来测试异常的。例如：
new ArrayList<Object>().get(0);
这段代码应该抛出一个IndexOutOfBoundsException异常信息，如果我们想验证这段代码是否抛出了异常，我们可以这样写：
@Test(expected = IndexOutOfBoundsException.class)
public void empty() {
new ArrayList<Object>().get(0);
}
5.3 Rules
@Rule是JUnit4的新特性，它能够灵活地扩展每个测试方法的行为，为他们提供一些额外的功能。下面是JUnit提供的一些基础的的test rule，所有的rule都实现了TestRule这个接口类。除此外，可以自定义test rule。
5.3.1 TestName Rule
在测试方法内部能知道当前的方法名。
public class NameRuleTest {
//用@Rule注解来标记一个TestRule，注意必须是public修饰的
@Rule
public final TestName name = new TestName();
@Test
public void testA() {
assertEquals("testA", name.getMethodName());
}
@Test
public void testB() {
assertEquals("testB", name.getMethodName());
}
}
5.3.2 Timeout Rule
与@Test注解里的属性timeout类似，但这里是针对同一测试类里的所有测试方法都使用同样的超时时间。
public class TimeoutRuleTest {
@Rule
public final Timeout globalTimeout = Timeout.millis(20);
@Test
public void testInfiniteLoop1() {
for(;;) {}
}
@Test
public void testInfiniteLoop2() {
for(;;) {}
}
}
5.3.3 ExpectedException Rules
与@Test的属性expected作用类似，用来测试异常，但是它更灵活方便。
public class ExpectedExceptionTest {
@Rule
public final ExpectedException exception = ExpectedException.none();
//不抛出任何异常
@Test
public void throwsNothing() {
}
//抛出指定的异常
@Test
public void throwsIndexOutOfBoundsException() {
exception.expect(IndexOutOfBoundsException.class);
new ArrayList<String>().get(0);
}
@Test
public void throwsNullPointerException() {
exception.expect(NullPointerException.class);
exception.expectMessage(startsWith("null pointer"));
throw new NullPointerException("null pointer......oh my god.");
}
}
5.3.4 TemporaryFolder Rule
该rule能够创建文件以及文件夹，并且在测试方法结束的时候自动删除掉创建的文件，无论测试通过或者失败。
public class TemporaryFolderTest {
@Rule
public final TemporaryFolder folder = new TemporaryFolder();
private static File file;
@Before
public void setUp() throws IOException {
file = folder.newFile("test.txt");
}
@Test
public void testFileCreation() throws IOException {
System.out.println("testFileCreation file exists : " + file.exists());
}
@After
public void tearDown() {
System.out.println("tearDown file exists : " + file.exists());
}
@AfterClass
public static void finish() {
System.out.println("finish file exists : " + file.exists());
}
}
测试执行后打印结果如下：
testFileCreation file exists : true
tearDown file exists : true
finish file exists : false //说明最后文件被删除掉了
5.3.5 ExternalResource Rules
实现了类似@Before、@After注解提供的功能，能在方法执行前与结束后做一些额外的操作。
public class UserExternalTest {
@Rule
public final ExternalResource externalResource = new ExternalResource() {
@Override
protected void after() {
super.after();
System.out.println("---after---");
}
@Override
protected void before() throws Throwable {
super.before();
System.out.println("---before---");
}
};
@Test
public void testMethod() throws IOException {
System.out.println("---test method---");
}
}
执行后打印结果如下：
---before---
---test method---
---after---
5.3.6 Custom Rules
自定义rule必须实现TestRule接口。
下面我们来写一个能够让测试方法重复执行的rule：
public class RepeatRule implements TestRule {
//这里定义一个注解，用于动态在测试方法里指定重复次数
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface Repeat {
int count();
}
@Override
public Statement apply(final Statement base, final Description description) {
Statement repeatStatement = new Statement() {
@Override
public void evaluate() throws Throwable {
Repeat repeat = description.getAnnotation(Repeat.class);
//如果有@Repeat注解，则会重复执行指定次数
if(repeat != null) {
for(int i=0; i < repeat.count(); i++) {
base.evaluate();
}
} else {
//如果没有注解，则不会重复执行
base.evaluate();
}
}
};
return repeatStatement;
}
}
public class RepeatTest {
@Rule
public final RepeatRule repeatRule = new RepeatRule();
//该方法重复执行5次
@RepeatRule.Repeat(count = 5)
@Test
public void testMethod() throws IOException {
System.out.println("---test method---");
}
@Test
public void testMethod2() throws IOException {
System.out.println("---test method2---");
}
}
执行结果如下：
---test method2---
---test method---
---test method---
---test method---
---test method---
---test method---
5.4 小结
本文主要介绍了JUnit自身提供的几个主要的test runner，还有@Test的timeout跟expected属性，最后介绍了一些常规的Rules使用方法。test runner是一个很重要的概念，因为在Android中进行单元测试时，通常都是JUnit结合其他测试框架来一起完成，例如mockito、robolectric，它们都有自己实现的一套test runner，我们必须使用这些框架提供的test runner才能发挥这些框架的最大作用。
系列文章：
Android单元测试（一）：前言
Android单元测试（二）：什么是单元测试
Android单元测试（三）：测试难点及方案选择
Android单元测试（四）：JUnit介绍
Android单元测试（五）：JUnit进阶
Android单元测试（六）：Mockito学习
Android单元测试（七）：Robolectric介绍
Android单元测试（八）：怎样测试异步代码
