Junit核心——测试类（TestCase）、测试集（TestSuite）、测试运行器（TestRunner）

首先，把这三个定义简单的说明一下：

1、测试类（TestCase）：一个包含一个或是多个测试的类，在Junit中就是指的是包含那些带有@Test注解的方法的类，同一样也被称作“测试用例”;

2、测试集（TestSuite）：测试集是把多个相关测试归入一个组的表达方式，在Junit中，如果我们没有明确的定义一个测试集，那么Juint会自动的提供一个测试集，一个测试集一般将同一个包的测试类归入一组；

3、测试运行器（TestRunner）：执行测试集的程序。

定义说完了，还有两个好理解的定义：断言（assert）和测试（Test），加上这两个定义，从断言到测试运行器就是从“原子”到“分子”的过程，“原子”组成“分子”的，“分子”包含若干”原子“。

关于测试类就比较好理解了，这里就不再拿出来说了，具体的说一说测试集与测试运行器吧。

一、测试运行器：

本文开篇已经说了关于测试运行器的概念，比较简单：执行测试集的程序，而在Junit中，我们使用测试运行器的方式也特别的简单，主要的是使用Junit的@RunnWith注解

1. import org.junit.runner.RunWith;
2. import org.junit.runners.JUnit4;
3. @RunWith(value=JUnit4.class)
4. public class TestRunner {
5. }

在此，我们定义了一个Junit4测试用例的运行器，Junit4包含下面4中测试运行器：

运行器	目的
org.junit.internal.runners.JUnit38ClassRunner	为了向后兼容Junit3.8的运行器
org.junit.runners.JUnit4	Junit4的测试运行器
org.junit.runners.Parameterized	可以使用不同参数来运行相同测试集的运行器
org.junit.runners.Suite	包含不同测试的容器

其中，JUnit38ClassRunner是用来告知运行器将要运行的的测试应该是在Junit3.8中运行；Suite 我们会在测试集进行介绍，而Parameterized是我们要详细介绍的

Parameterized（参数化）的测试运行器允许我们使用不同的参数多此运行同一个测试，

比如我们在测试一个提供乘法算数的方法时，我们可以为测试用例提供三组数据：4*5（两个正整数）、-4*5（一正一负）、0*5（0与正整数），提供多组数据可以让我们从不同的角度对同一个方法进行测试，

具体的实现如下：

1. package org.yezi.junit;
2. public class Calcaute {
3. public int ride(int a, int b){
4. return a * b;
5. }
6. }

1. package org.yezi.junit;
2. import static org.junit.Assert.*;
3. import java.util.ArrayList;
4. import java.util.Collection;
5. import java.util.List;
6. import org.junit.*;
7. import org.junit.runner.RunWith;
8. import org.junit.runners.Parameterized;
9. import org.junit.runners.Parameterized.Parameters;
10. @RunWith(value=Parameterized.class)
11. public class TestCalcaute {
12. private Calcaute calcaute = null;
13. private int expected;
14. private int valueOne;
15. private int valueTwo;
16. @Parameters
17. public static Collection<Integer[]> getTestParameters(){
18. List<Integer[]> list = new ArrayList<Integer[]>();
19. list.add(new Integer[]{20,4,5});  //expected,valueOne,valueTwo
20. list.add(new Integer[]{-20,-4,5});
21. list.add(new Integer[]{0,0,5});
22. return list;
23. }
24. public TestCalcaute(int expected, int valueOne, int valueTwo){
25. this.expected = expected;
26. this.valueOne = valueOne;
27. this.valueTwo = valueTwo;
28. }
29. @Before
30. public void setUp(){
31. calcaute = new Calcaute();
32. }
33. @Test
34. public void testAdd(){
35. int result = calcaute.ride(valueOne, valueTwo);
36. assertEquals(expected, result);
37. }
38. }

ok，功能实现了，但是，在此我们要说明几个必须：

1、实现参数化测试运行器，该类必须加上@RunWith(value=Parameterized.class)注解！否则运行Junit报java.lang.Exception: Test class should have exactly one public zero-argument constructor异常

2、必须把测试的期望结果、以及测试参数声明为全局的、私有的！

3、必须创建一个带期望结果、测试参数的构造方法！

4、必须创建一个返回若干个测试参数、期望结果组的静态方法，返回类型为Collection<Integer[]>，并且该方法加以@Parameters（ org.junit.runners.Parameterized.Parameters）注解！