Java单元测试工具：JUnit4（四）——JUnit测试套件使用及参数化设置

（四）JUnit测试套件使用及参数化设置

        这篇笔记记录JUnit测试套件的使用，即批量运行测试类；以及JUnit中的参数化设置。

        @RunWith
　　当类被@RunWith注解修饰，或者类继承了一个被该注解修饰的类，JUnit将会使用这个注解所指明的运行器（runner）来运行测试，而不是JUnit默认的运行器。

1.JUnit测试套件

        如果在测试类不端增加的情况下，如何运行所有的单元测试代码类？一个个测试类的执行吗？显然繁琐且费劲。
        将要运行的测试类集成在我们的测试套件中，比如一个系统功能对应一个测试套件，一个测试套件中包含多个测试类，每次测试系统功能时，只要执行一次测试套件就可以了。

1.1 测试类及测试套件代码

        新建3个测试任务类：

[java]   view plain  copy

1. package jtzen9.util;  
2. import org.junit.Test;  
3. public class TaskTest1 {  
4.   
5.     @Test  
6.     public void test() {  
7.         System.out.println("this is TaskTest1...");  
8.     }  
9.   
10. }  
11.   
12.   
13. package jtzen9.util;  
14. import org.junit.Test;  
15. public class TaskTest2 {  
16.   
17.     @Test  
18.     public void test() {  
19.         System.out.println("this is TaskTest2...");  
20.     }  
21.   
22. }  
23.   
24.   
25. package jtzen9.util;  
26. import org.junit.Test;  
27. public class TaskTest3 {  
28.   
29.     @Test  
30.     public void test() {  
31.         System.out.println("this is TaskTest3...");  
32.     }  
33. }  

        新建一个套件类，包含以上三个任务类：

[java]   view plain  copy

1. package jtzen9.util;  
2.   
3. import org.junit.runner.RunWith;  
4. import org.junit.runners.Suite;  
5.   
6. @RunWith(Suite.class)  
7. @Suite.SuiteClasses({TaskTest1.class,TaskTest2.class,TaskTest3.class})  
8. public class SuiteTest {  
9.     /* 
10.      * 1.测试套件就是组织测试类一起运行的 
11.      *  
12.      * 写一个作为测试套件的入口类，这个类里不包含其他的方法 
13.      * 更改测试运行器Suite.class 
14.      * 将要测试的类作为数组传入到Suite.SuiteClasses（{}） 
15.      */  
16. }  

运行结果：

1.2 说明

        ①使用@RunWith注解，修改测试运行器。例如@RunWith(Suite.class)，这个类就成为测试套件的入口类。

        ②@Suite.SuiteClasses()中放入测试套件的测试类，以数组的形式{class1,class2,......}作为参数

2.JUnit参数化设置

        如果测试代码大同小异，代码结构都是相同的，不同的只是测试的数据和预期值，那么有没有更好的办法将相同的代码结构提取出来，提高代码的重用度呢？

        解决：进行参数化测试。

        步骤：

　　①要进行参数化测试，需要在类上面指定如下的运行器：@RunWith (Parameterized.class)
　　②然后，在提供数据的方法上加上一个@Parameters注解，这个方法必须是静态static的，并且返回一个集合Collection。
　　③在测试类的构造方法中为各个参数赋值，（构造方法是由JUnit调用的），最后编写测试类，它会根据参数的组数来运行测试多次。

2.1 代码：

[java]   view plain  copy

1. package jtzen9.util;  
2.   
3. import static org.junit.Assert.*;  
4.   
5. import java.util.Arrays;  
6. import java.util.Collection;  
7.   
8. import org.junit.Test;  
9. import org.junit.runner.RunWith;  
10. import org.junit.runners.Parameterized;  
11. import org.junit.runners.Parameterized.Parameters;  
12.   
13. @RunWith(Parameterized.class)   //1.更改默认的测试运行器为RunWith(Parameterized.class)  
14. public class ParameterTest {  
15.       
16.     //2.声明变量存放预期值和测试数据  
17.     int expected =0;  
18.     int input1 = 0;  
19.     int input2 = 0;  
20.       
21.     //3.声明一个返回值 为Collection的公共静态方法，并使用@Parameters进行修饰  
22.     @Parameters  
23.     public static Collection<Object[]><object> data() {  
24.         return Arrays.asList(new Object[][]{  
25.                 {3,1,2},  
26.                 {4,2,2}  
27.         }) ;  
28.     }  
29.       
30.     //4.为测试类声明一个带有参数的公共构造函数，并在其中为之声明变量赋值  
31.     public ParameterTest(int expected,int input1,int input2) {  
32.         this.expected = expected;  
33.         this.input1 = input1;  
34.         this.input2 = input2;  
35.     }  
36.       
37.     //5.运行测试方法，即可完成对多组数据的测试  
38.     @Test  
39.     public void testAdd() {  
40.         assertEquals(expected, new Calculate().add(input1, input2));  
41.     }  
42.   
43. }</object>  

2.2 运行结果

看了慕课网的JUnit视频教程： http://www.imooc.com/learn/356，总结笔记。

结束语：

        以前测试自己写的代码都是新建一个main方法，然后sysout输出控制台观察结果，繁琐又麻烦！学习了JUnit测试之后，感觉方便了很多，当然JUnit还有很多方法需要在使用的过程中不断的总结。