Java单元测试(Junit+Mock+代码覆盖率)

快来打我* 2022-08-05 07:40 383阅读 0赞

单元测试是编写测试代码，用来检测特定的、明确的、细颗粒的功能。单元测试并不一定保证程序功能是正确的，更不保证整体业务是准备的。

单元测试不仅仅用来保证当前代码的正确性，更重要的是用来保证代码**修复**、**改进**或**重构**之后的正确性。

一般来说，单元测试任务包括

1.  接口功能测试：用来保证接口功能的正确性。
2.  局部数据结构测试（不常用）：用来保证接口中的数据结构是正确的
    
    1.  比如变量有无初始值
    2.  变量是否溢出
3.  边界条件测试
    
    1.  **变量没有赋值**（即为NULL）
    2.  变量是数值（或字符)
        
        1.  **主要边界**：最小值，最大值，无穷大（对于DOUBLE等）
        2.  **溢出边界**（期望异常或拒绝服务）：最小值-1，最大值+1
        3.  **临近边界**：最小值+1，最大值-1
    3.  变量是字符串
        
        1.  引用“字符变量”的边界
        2.  **空字符串**
        3.  对字符串长度应用“数值变量”的边界
    4.  变量是集合
        
        1.  **空集合**
        2.  **对集合的大小应用“数值变量”的边界**
        3.  **调整次序**：升序、降序
    5.  变量有规律
        
        1.  比如对于Math.sqrt，给出n^2-1，和n^2+1的边界
4.  所有独立执行通路测试：保证每一条代码，每个分支都经过测试
    
    1.  代码覆盖率
        
        1.  **语句覆盖**：保证每一个语句都执行到了
        2.  判定覆盖（分支覆盖）：保证每一个分支都执行到
        3.  条件覆盖：保证每一个条件都覆盖到true和false（即if、while中的条件语句）
        4.  路径覆盖：保证每一个路径都覆盖到
    2.  相关软件
        
        1.  Cobertura：语句覆盖
        2.  Emma: Eclipse插件Eclemma
5.  各条错误处理通路测试：保证每一个异常都经过测试

## JUNIT ##

JUnit是Java单元测试框架，已经在Eclipse中默认安装。目前主流的有JUnit3和JUnit4。JUnit3中，测试用例需要继承`TestCase`类。JUnit4中，测试用例无需继承`TestCase`类，只需要使用`@Test`等注解。

#### Junit3 ####

先看一个Junit3的样例

Java代码   ![收藏代码][icon_star.png]

1.  // 测试java.lang.Math  
2.  // 必须继承TestCase  
3.  public class Junit3TestCase extends TestCase \{  
4.      public Junit3TestCase() \{  
5.          super();  
6.      \}  
7.      
8.          // 传入测试用例名称  
9.      public Junit3TestCase(String name) \{  
10.         super(name);  
11.     \}  
12.    
13.         // 在每个Test运行之前运行  
14.     @Override  
15.     protected void setUp() throws Exception \{  
16.         System.out.println(“Set up”);  
17.     \}  
18.         // 测试方法。  
19.         // 方法名称必须以test开头，没有参数，无返回值，是公开的，可以抛出异常  
20.         // 也即类似public void testXXX() throws Exception \{\}  
21.     public void testMathPow() \{  
22.         System.out.println(“Test Math.pow”);  
23.         Assert.assertEquals(4.0, Math.pow(2.0, 2.0));  
24.     \}  
25.    
26.     public void testMathMin() \{  
27.         System.out.println(“Test Math.min”);  
28.         Assert.assertEquals(2.0, Math.min(2.0, 4.0));  
29.     \}  
30.    
31.         // 在每个Test运行之后运行  
32.     @Override  
33.     protected void tearDown() throws Exception \{  
34.         System.out.println(“Tear down”);  
35.     \}  
36. \}

如果采用默认的TestSuite，则测试方法必须是`public void testXXX() [throws Exception] {}`的形式，并且不能存在依赖关系，因为测试方法的调用顺序是不可预知的。  
上例执行后，控制台会输出

Text代码   ![收藏代码][icon_star.png]

1.  Set up  
2.  Test Math.pow  
3.  Tear down  
4.  Set up  
5.  Test Math.min  
6.  Tear down

从中，可以猜测到，对于每个测试方法，调用的形式是：

Java代码   ![收藏代码][icon_star.png]

1.  testCase.setUp();  
2.  testCase.testXXX();  
3.  testCase.tearDown();

##### 运行测试方法 #####

在Eclipse中，可以直接在类名或测试方法上右击，在弹出的右击菜单中选择Run As -> JUnit Test。  
在Mvn中，可以直接通过`mvn test`命令运行测试用例。  
也可以通过Java方式调用，创建一个`TestCase`实例，然后重载`runTest()`方法，在其方法内调用测试方法（可以多个）。

Java代码   ![收藏代码][icon_star.png]

1.  TestCase test = new Junit3TestCase(“mathPow”) \{  
2.          // 重载  
3.      protected void runTest() throws Throwable \{  
4.          testMathPow();  
5.      \};  
6.  \};  
7.  test.run();

更加便捷地，可以在创建`TestCase`实例时直接传入测试方法名称，JUnit会自动调用此测试方法，如

Java代码   ![收藏代码][icon_star.png]

1.  TestCase test = new Junit3TestCase(“testMathPow”);  
2.  test.run();

##### Junit TestSuite #####

TestSuite是测试用例套件，能够运行过个测试方法。如果不指定TestSuite，会创建一个默认的TestSuite。默认TestSuite会扫描当前内中的所有测试方法，然后运行。  
如果不想采用默认的TestSuite，则可以自定义TestSuite。在TestCase中，可以通过静态方法`suite()`返回自定义的suite。

Java代码   ![收藏代码][icon_star.png]

1.  import junit.framework.Assert;  
2.  import junit.framework.Test;  
3.  import junit.framework.TestCase;  
4.  import junit.framework.TestSuite;  
5.     
6.  public class Junit3TestCase extends TestCase \{  
7.          //…  
8.      public static Test suite() \{  
9.          System.out.println(“create suite”);  
10.         TestSuite suite = new TestSuite();  
11.         suite.addTest(new Junit3TestCase(“testMathPow”));  
12.         return suite;  
13.     \}  
14. \}

允许上述方法，控制台输出

写道

create suite  
Set up  
Test Math.pow  
Tear down

并且只运行了`testMathPow`测试方法，而没有运行`testMathMin`测试方法。通过显式指定测试方法，可以控制测试执行的顺序。

也可以通过Java的方式创建TestSuite，然后调用TestCase，如

Java代码   ![收藏代码][icon_star.png]

1.  // 先创建TestSuite，再添加测试方法  
2.  TestSuite testSuite = new TestSuite();  
3.  testSuite.addTest(new Junit3TestCase(“testMathPow”));  
4.     
5.  // 或者 传入Class，TestSuite会扫描其中的测试方法。  
6.  TestSuite testSuite = new TestSuite(Junit3TestCase.class,Junit3TestCase2.class,Junit3TestCase3.class);  
7.     
8.  // 运行testSuite  
9.  TestResult testResult = new TestResult();  
10. testSuite.run(testResult);

testResult中保存了很多测试数据，包括运行测试方法数目(`runCount`)等。

#### JUnit4 ####

与JUnit3不同，JUnit4通过注解的方式来识别测试方法。目前支持的主要注解有：

*  `@BeforeClass` 全局只会执行一次，而且是第一个运行
 *  `@Before` 在测试方法运行之前运行
 *  `@Test` 测试方法
 *  `@After` 在测试方法运行之后允许
 *  `@AfterClass` 全局只会执行一次，而且是最后一个运行
 *  `@Ignore` 忽略此方法

下面举一个样例：

Java代码   ![收藏代码][icon_star.png]

1.  import org.junit.After;  
2.  import org.junit.AfterClass;  
3.  import org.junit.Assert;  
4.  import org.junit.Before;  
5.  import org.junit.BeforeClass;  
6.  import org.junit.Ignore;  
7.  import org.junit.Test;  
8.     
9.  public class Junit4TestCase \{  
10.    
11.     @BeforeClass  
12.     public static void setUpBeforeClass() \{  
13.         System.out.println(“Set up before class”);  
14.     \}  
15.    
16.     @Before  
17.     public void setUp() throws Exception \{  
18.         System.out.println(“Set up”);  
19.     \}  
20.    
21.     @Test  
22.     public void testMathPow() \{  
23.         System.out.println(“Test Math.pow”);  
24.         Assert.assertEquals(4.0, Math.pow(2.0, 2.0), 0.0);  
25.     \}  
26.    
27.     @Test  
28.     public void testMathMin() \{  
29.         System.out.println(“Test Math.min”);  
30.         Assert.assertEquals(2.0, Math.min(2.0, 4.0), 0.0);  
31.     \}  
32.    
33.         // 期望此方法抛出NullPointerException异常  
34.     @Test(expected = NullPointerException.class)  
35.     public void testException() \{  
36.         System.out.println(“Test exception”);  
37.         Object obj = null;  
38.         obj.toString();  
39.     \}  
40.    
41.         // 忽略此测试方法  
42.     @Ignore  
43.     @Test  
44.     public void testMathMax() \{  
45.           Assert.fail(“没有实现”);  
46.     \}  
47.         // 使用“假设”来忽略测试方法  
48.     @Test  
49.     public void testAssume()\{  
50.         System.out.println(“Test assume”);  
51.                 // 当假设失败时，则会停止运行，但这并不会意味测试方法失败。  
52.         Assume.assumeTrue(false);  
53.         Assert.fail(“没有实现”);  
54.     \}  
55.    
56.     @After  
57.     public void tearDown() throws Exception \{  
58.         System.out.println(“Tear down”);  
59.     \}  
60.    
61.     @AfterClass  
62.     public static void tearDownAfterClass() \{  
63.         System.out.println(“Tear down After class”);  
64.     \}  
65.    
66. \}

如果细心的话，会发现Junit3的package是`junit.framework`，而Junit4是`org.junit`。  
执行此用例后，控制台会输出

写道

Set up before class  
Set up  
Test Math.pow  
Tear down  
Set up  
Test Math.min  
Tear down  
Set up  
Test exception  
Tear down  
Set up  
Test assume  
Tear down  
Tear down After class

可以看到，执行次序是`@BeforeClass` -> `@Before` -> `@Test` -> `@After` -> `@Before` -> `@Test` -> `@After` -> `@AfterClass`。`@Ignore`会被忽略。

##### 运行测试方法 #####

与Junit3类似，可以在Eclipse中运行，也可以通过`mvn test`命令运行。

#### Assert ####

Junit3和Junit4都提供了一个Assert类（虽然package不同，但是大致差不多）。Assert类中定义了很多静态方法来进行断言。列表如下：

*  assertTrue(String message, boolean condition) 要求condition == true
 *  assertFalse(String message, boolean condition) 要求condition == false
 *  fail(String message) 必然失败，同样要求代码不可达
 *  assertEquals(String message, XXX expected,XXX actual) 要求expected.equals(actual)
 *  assertArrayEquals(String message, XXX\[\] expecteds,XXX \[\] actuals) 要求expected.equalsArray(actual)
 *  assertNotNull(String message, Object object) 要求object!=null
 *  assertNull(String message, Object object) 要求object==null
 *  assertSame(String message, Object expected, Object actual) 要求expected == actual
 *  assertNotSame(String message, Object unexpected,Object actual) 要求expected != actual
 *  assertThat(String reason, T actual, Matcher matcher) 要求matcher.matches(actual) == true

## Mock/Stub ##

Mock和Stub是两种测试代码功能的方法。Mock测重于对功能的模拟。Stub测重于对功能的测试重现。比如对于List接口，Mock会直接对List进行模拟，而Stub会新建一个实现了List的TestList，在其中编写测试的代码。  
强烈建议优先选择Mock方式，因为Mock方式下，模拟代码与测试代码放在一起，易读性好，而且扩展性、灵活性都比Stub好。  
比较流行的Mock有：

*  [JMock][]
 *  [EasyMock][]
 *  [Mockito][]
 *  [powermock][]

其 中EasyMock和Mockito对于Java接口使用接口代理的方式来模拟，对于Java类使用继承的方式来模拟（也即会创建一个新的Class 类）。Mockito支持spy方式，可以对实例进行模拟。但它们都不能对静态方法和final类进行模拟，powermock通过修改字节码来支持了此 功能。

#### EasyMock ####

IBM上有几篇介绍EasyMock使用方法和原理的文章：[EasyMock 使用方法与原理剖析][EasyMock 1]，[使用 EasyMock 更轻松地进行测试][EasyMock 2]。  
EasyMock把测试过程分为三步：录制、运行测试代码、验证期望。  
录制过程大概就是：期望method(params)执行times次（默认一次），返回result（可选），抛出exception异常（可选）。  
验证期望过程将会检查方法的调用次数。  
一个简单的样例是：

Java代码   ![收藏代码][icon_star.png]

1.  @Test  
2.  public void testListInEasyMock() \{  
3.      List list = EasyMock.createMock(List.class);  
4.      // 录制过程  
5.     
6.      // 期望方法list.set(0,1)执行2次，返回null，不抛出异常  
7.      expect1: EasyMock.expect(list.set(0, 1)).andReturn(null).times(2);  
8.      // 期望方法list.set(0,1)执行1次，返回null，不抛出异常  
9.      expect2: EasyMock.expect(list.set(0, 1)).andReturn(1);  
10.    
11.     // 执行测试代码  
12.     EasyMock.replay(list);  
13.         // 执行list.set(0,1)，匹配expect1期望，会返回null  
14.     Assert.assertNull(list.set(0, 1));  
15.         // 执行list.set(0,1)，匹配expect1（因为expect1期望执行此方法2次），会返回null  
16.     Assert.assertNull(list.set(0, 1));  
17.         // 执行list.set(0,1)，匹配expect2，会返回1  
18.     Assert.assertEquals(1, list.set(0, 1));  
19.    
20.     // 验证期望  
21.     EasyMock.verify(list);  
22. \}

[icon_star.png]: /images/20220805/f1999979f03c421aaec7f05f78320370.png
[JMock]: http://jmock.org/
[EasyMock]: http://www.easymock.org/
[Mockito]: http://blog.thihy.info/post/mockito.googlecode.com
[powermock]: http://code.google.com/p/powermock/
[EasyMock 1]: http://www.ibm.com/developerworks/cn/opensource/os-cn-easymock/
[EasyMock 2]: http://www.ibm.com/developerworks/cn/java/j-easymock.html