Android单元测试（三）：使用JUnit进行单元测试

timg.jpeg

初识Junit

JUnit是一个测试框架，它使用注解来标识指定测试的方法。JUnit是一个在Github上托管的开源项目。

如何在利用JUnit定义测试方法

JUnit测试是一个仅用于测试类中使用的方法，这被称为测试类。要定义某个方法是测试方法，需要使用 @Test 注解对其进行注释。

该方法用于执行测试中的代码。使用由JUnit或其他断言框架提供的断言方法来检查预期结果与实际结果。这些方法调用通常称为断言或断言语句。你需要提供一个有意义的断言结果。这使我们更容易的识别和解决问题。

JUnit测试的例子

第一篇文章我们其实已经通过JUnit简单的介绍了单元测试，现在我们再来详细介绍一下，待测试的类Calculator存在一个add(int, int)方法，以下代码显示了使用JUnit4测试这个类的方法。

import org.junit.Assert;
import org.junit.Test;

public class CalculatorTest {

    @Test
    public void testAdd() {
        int sum = Calculator.add(1, 2);
        Assert.assertEquals(3, sum);
    }
}

定义测试方法

JUnit使用注解将方法标记为测试方法并对其进行配置。下表概述了JUnit中4.x和5.x版本中最重要的注释。所有这些注释都可以用于方法。

JUnit4	描述
import org.junit.*	导入使用以下注释的语句
@Test	将方法标识为测试方法
@Before	每次测试前执行。它用于准备测试环境（例如，读取输入数据，初始化类）
@After	每次测试后执行。它用于清理测试环境（例如，删除临时数据，恢复默认值）。它还可以通过清理昂贵的内存结构来节省内存
@BeforeClass	在所有测试开始之前执行一次。它用于执行时间密集型活动，例如连接到数据库。用这个注释标记的方法需要被定义为static使用JUnit。
@AfterClass	在所有测试完成后执行一次。它用于执行清理活动，例如从数据库断开连接。使用此批注注释的方法需要定义为static使用JUnit。
@Ignore or @Ignore("Why disabled")	标记测试应该被禁用。当底层代码已被更改并且测试用例尚未被修改时，这很有用。或者如果这个测试的执行时间太长而不能包含。最好的做法是提供可选说明，为什么禁用测试。
@Test (expected = Exception.class)	如果方法不抛出指定的异常，则失败
@Test(timeout=100)	如果方法花费的时间超过100毫秒，则失败

Assert(断言)

JUnit通过Assert类提供一系列静态的方法来测试某些条件是否通过。这些断言方法通常以assert开头，它们允许您指定错误信息，预期结果和实际结果。一个断言方法比较通过测试返回预期值实际值。如果比较失败将会抛出AssertionException。

下表给出了这些方法的概述。[]括号中的参数是可选的，并且是String类型的

声明	描述
fail([message])	让方法失败。在测试代​​码被实现之前，可能用于检查代码的某个部分没有达到或有失败的测试。消息参数是可选的
assertTrue([message,] boolean condition)	检查boolean条件是否为真
assertFalse([message,] boolean condition)	检查b条oolean件是否为false
assertEquals([message,] expected, actual)	测试两个值是否相同。注意：对于数组，引用不被检查而是数组的内容
assertEquals([message,] expected, actual, tolerance)	测试float或double值是否匹配。容差是必须相同的小数位数
ssertNull([message,] object)	检查该对象是否为空
assertNotNull([message,] object)	检查该对象是否不为空
assertSame([message,] expected, actual)	检查两个变量是否指向同一个对象
assertNotSame([message,] expected, actual)	检查两个变量是否是不同的对象

JUnit test suites(测试套件）

如果你有几个测试类都涉及某个类，且这个类发生了变化，你可以将它们组合成一个测试套件。运行测试套件以指定的顺序执行该套件中的所有测试类。测试套件还可以包含其他测试套件。

以下示例代码演示了测试套件的用法。它包含两个测试类（ExampleUnitTest和CalculatorTest）。如果你想添加另一个测试类，你可以将它添加到@Suite.SuiteClasses语句中。

@RunWith(Suite.class)
@SuiteClasses({ExampleUnitTest.class, CalculatorTest.class})
public class AllTests {

}

Parameterized test（参数化测试）

JUnit允许你在测试类中使用参数。该类可以包含一个测试方法，并且此方法使用提供的不同参数执行。
将测试类标记为带@RunWith(Parameterized.class)注释的参数化测试。

这样的测试类必须包含一个用@Parameters注释标注的静态方法。该方法生成并返回一组数组。此集合中的每个项目都用作测试方法的参数。可以@Parameter在公共字段上使用注释来获取测试中注入的测试值。

以下代码显示了参数化测试的示例:

@RunWith(Parameterized.class)
public class ParameterizedFiledTest {

    // fields used together with @Parameter must be public
    @Parameter(0)
    public int m1;
    @Parameter(1)
    public int m2;
    @Parameter(2)
    public int result;

    // creates the test data
    @Parameters
    public static Collection<Object[]> data() {
        Object[][] data = new Object[][]{{1, 2, 3}, {5, 3, 15}};
        return Arrays.asList(data);
    }

    @Test
    public void testAdd() {
        assertEquals(result, Calculator.add(m1, m2));
    }
}

或者提供类的构造函数，测试值通过构造函数传递给类

@RunWith(Parameterized.class)
public class ParameterizedConstructorTest {

    private int m1;
    private int m2;
    private int result;

    public ParameterizedConstructorTest(int m1, int m2, int result) {
        this.m1 = m1;
        this.m2 = m2;
        this.result = result;
        System.out.println("ParameterizedConstructorTest");
    }

    // creates the test data
    @Parameters
    public static Collection<Object[]> data() {
        Object[][] data = new Object[][]{{1, 2, 3}, {5, 3, 8}};
        return Arrays.asList(data);
    }

    @Test
    public void testAdd() {
        Assert.assertEquals(result, Calculator.add(m1, m2));
    }
}

JUnit Rules

Rules允许在测试类中非常灵活地添加或重新定义每个测试方法的行为。测试人员可以重用或扩展下面提供的Rules之一，或者自己编写Rules。

• Verifier: 验证测试执行结果的正确性。
• ErrorCollector: 收集测试方法中出现的错误信息，测试不会中断，如果有错误发生测试结束后会标记失败。
• ExpectedException: 提供灵活的异常验证功能。
• Timeout: 用于测试超时的Rule。
• ExternalResource: 外部资源管理。
• TemporaryFolder: 在JUnit的测试执行前后，创建和删除新的临时目录。
• TestWatcher: 监视测试方法生命周期的各个阶段。
• TestName: 在测试方法执行过程中提供获取测试名字的能力。

简单的说就是提供了测试用例执行过程中一些通用功能的共享的能力，使我们不必重复编写一些功能类似的代码。JUnit用于标注Rule的注解包括@Rule和@ClassRule，区别在于作用域不同@Rule的作用域是测试方法，@ClassRule则是测试Class。

以下代码显示了实现的使用Verifier:

public class RuleTest {

    private static String sequence;

    public static class UsesVerifier {
        @Rule
        public Verifier collector = new Verifier() {
            @Override
            protected void verify() {
                sequence += "verify ";
            }
        };

        @Test
        public void example() {
            sequence += "test ";
        }
    }

    @Test
    public void verifierRunsAfterTest() {
        sequence = "";
        assertThat(testResult(UsesVerifier.class), isSuccessful());
        assertEquals("test verify ", sequence);
    }
}

有关现有Rules的更多示例，请参阅https://github.com/junit-team/junit4/wiki/Rules

自定义JUnit Rules

要编写自定义规则，需要实现TestRule接口。这个接口定义了一个apply(Statement, Description)方法Statement。Statement代表JUnit运行时内的测试，Statement＃evaluate（）运行这些测试。说明描述了单个测试。它允许通过反射来读取关于测试的信息。

以下是在测试执行之前和之后添加日志语句的一个简单示例：

public class CustomRule implements TestRule {

    private Description description;

    @Override
    public Statement apply(Statement base, Description description) {
        this.description = description;
        return new MyStatement(base);
    }

    public class MyStatement extends Statement {

        public final Statement base;

        public MyStatement(Statement statement) {
            this.base = statement;
        }

        @Override
        public void evaluate() throws Throwable {
            System.out.println("CustomRule" + description.getMethodName() + "Started");
            try {
                base.evaluate();
            } finally {
                System.out.println("CustomRule" + description.getMethodName() + "Finished");
            }
        }
    }
}

要使用这个规则，简单地添加一个注解@Rule到你的测试类的字段。

@Rule
public CustomRule customRule = new CustomRule();

Categories

Category继承自Suit，Category似乎是Suit的加强版，它和Suit一样提供了将若干测试用例类组织成一组的能力，除此以外它可以对各个测试用例进行分组，使你有机会只选择需要的部分用例。
具体示例如下：

public interface FastTests {
}

public interface SlowTests { 
}

public class A {
    @Test
    public void a() {
        fail();
    }

    @Category(SlowTests.class)
    @Test
    public void b() {
    }
}

@Category({ SlowTests.class, FastTests.class })
public class B {
    @Test
    public void c() {
    }
}

@RunWith(Categories.class)
@IncludeCategory(SlowTests.class)
@SuiteClasses({ A.class, B.class })
public class SlowTestSuite {
    // 运行 A.b 和 B.c, 不会运行 A.a
}

@RunWith(Categories.class)
@IncludeCategory(SlowTests.class)
@ExcludeCategory(FastTests.class)
@SuiteClasses({ A.class, B.class })
public class SlowTestSuite {
    // 运行 A.b, 不会运行 A.a 和 B.c
}

Theories

Theories继承自BlockJUnit4ClassRunner，提供了除Parameterized之外的另一种参数测试解决方案——似乎更强大。Theories不再需要使用带有参数的Constructor而是接受有参的测试方法，修饰的注解也从@Test变成了@Theory，而参数的提供则变成了使用@DataPoint或者@Datapoints来修饰的变量，两者的唯一不同是前者代表一个数据后者代表一组数据。Theories会尝试所有类型匹配的参数作为测试方法的入参（有点排列组合的意思）。看一个使用Theories的例子：

@RunWith(Theories.class)
public class TheoriesTest {

    @DataPoint
    public static String nameValue1 = "Tony";

    @DataPoint
    public static String nameValue2 = "Jim";

    @DataPoint
    public static int ageValue1 = 10;

    @DataPoint
    public static int ageValue2 = 20;

    @Theory
    public void testMethod(String name, int age) {
        System.out.println(String.format("%s's age is %s", name, age));
    }
}

输出结果：
Tony's age is 10
Tony's age is 20
Jim's age is 10
Jim's age is 20

同样使用@DataPoints可以获得一样的效果：

@RunWith(Theories.class)
public class TheoriesTest2 {

    @DataPoints
    public static String[] names = {"Tony", "Jim"};

    @DataPoints
    public static int[] ageValue1 = {10, 20};

    @Theory
    public void testMethod(String name, int age) {
        System.out.println(String.format("%s's age is %s", name, age));
    }
}

除此以外Theories还可以支持自定义数据提供的方式，需要继承JUnit的ParameterSupplier类。下面的代码使用ParameterSupplier实现上述例子：

public class NameSupplier extends ParameterSupplier {

    @Override
    public List<PotentialAssignment> getValueSources(ParameterSignature sig) throws Throwable {
        PotentialAssignment nameAssignment1 = PotentialAssignment.forValue("name", "Tony");
        PotentialAssignment nameAssignment2 = PotentialAssignment.forValue("name", "Jim");
        return Arrays.asList(nameAssignment1, nameAssignment2);
    }
}

public class AgeSupplier extends ParameterSupplier {

    @Override
    public List<PotentialAssignment> getValueSources(ParameterSignature sig) throws Throwable {
        PotentialAssignment ageAssignment1 = PotentialAssignment.forValue("age", 10);
        PotentialAssignment ageAssignment2 = PotentialAssignment.forValue("age", 20);
        return Arrays.asList(ageAssignment1, ageAssignment2);
    }
}

@RunWith(Theories.class)
public class TheoriesTest3 {

    @Theory
    public void testMethod(@ParametersSuppliedBy(NameSupplier.class) String name, @ParametersSuppliedBy(AgeSupplier.class) int age) {
        System.out.println(String.format("%s's age is %s", name, age));
    }
}

Assume

Assume直译为假设，是JUnit提供的一套用于判断测试用例的入参是否有业务含义的工具，如果入参不符合预期时会抛出AssumptionViolatedException，默认的BlockJUnit4ClassRunner及其子类会捕获这个异常并跳过当前测试，如果使用自定义的Runner则无法保证行为，视Runner的实现而定。

Assume提供的验证方法包括： assumeTrue/assumeFalse、 assumeNotNull、 assumeThat、 assumeNoException 。具体含义都比较简单。

假设我们有一个打印姓名和年龄的测试用例，使用Theories提供多套参数测试，由于实际年龄不存在负数所以使用Assume排除不合理的数据：

@RunWith(Theories.class)
public class AssumeTest {

    @DataPoints
    public static String[] names = {"LiLei", "HanMeiMei"};

    @DataPoints
    public static int[] ages = {10, -2, 12};

    @Theory
    public void printAge(String name, int age) {
        Assume.assumeTrue(age > 0);
        System.out.println(String.format("%s's Age is %s.", name, age));
    }
}

输出结果为：
LiLei's Age is 10.
LiLei's Age is 12.
HanMeiMei's Age is 10.
HanMeiMei's Age is 12.

JUnit生命周期

JUnit提供了@Before、@BeforeClass、@After、@AfterClass注解，这些方法的执行顺序是怎样的？通过下面的代码来演示JUnit的生命周期：

public class JUnitLifeCycleTest {

    public JUnitLifeCycleTest() {
        super();
        System.out.println("<<Person Constructor>>");
    }

    @BeforeClass
    public static void beforeClassM() {
        System.out.println("<<Before Class>>");
    }


    @Before
    public void beforeM() {
        System.out.println("<<Before>>");
    }


    @AfterClass
    public static void afterClassM() {
        System.out.println("<<After Class>>");
    }

    @After
    public void after() {
        System.out.println("<<After>>");
    }

    @Test
    public void testMethod1() {
        System.out.println("Test Method 1.");
    }

    @Test
    public void testMethod2() {
        System.out.println("Test Method 2.");
    }

}

输出结果：
<<Before Class>>
<<Person Constructor>>
<<Before>>
Test Method 1.
<<After>>
<<Person Constructor>>
<<Before>>
Test Method 2.
<<After>>
<<After Class>>

@BeforeClass：修饰static的方法，在整个类执行之前执行该方法一次。比如你的测试用例执行前需要一些高开销的资源（连接数据库）可以用@BeforeClass搞定。值得注意的是如果测试用例类的父类中也存在@BeforeClass修饰的方法，它将在子类的@BeforeClass之前执行。

@AfterClass：同样修饰static的方法，在整个类执行结束前执行一次。如果你用@BeforeClass创建了一些资源现在是时候释放它们了。
@Before：修饰public void的方法，在每个测试用例（方法）执行时都会执行。

@After：修饰public void的方法，在每个测试用例执行结束后执行。

Constructor：每个测试用例都会重新创建当前的Class实例，可以看到Constructor执行了两次。

小结

这篇文字大概简单介绍了JUnit的使用，相对来说是比较简单，也是比较容易理解的，希望能帮助到大家，后续计划再有一篇记录自己在阅读JUnit4源码码的一些收获和感想。

Assert可以帮我们验证一个方法的返回结果。然而，这些只能帮我们测试有返回值的那些方法。一个类的方法分两种，一是有返回值的方法，这些可以通过我们今天讲的JUnit来做测试。而另外一种没有返回值的方法，即void方法，则要通过另外一个框架，Mockito，来验证它的正确性。至于怎么样验证void方法的正确性，以及Mockito的使用，请关注后续文章。

参考：
http://www.vogella.com/tutorials/JUnit/article.html