起步
为了提升代码质量，准备很好的进行测试工作。最近研究了一下测试相关的内容，进行了一些整理。
简介
JUnit4使用了大量的注解，书写的测试类不再需要继承自TestCase，只需要在方法上注解@Test即可。
1. 简单的测试演示
public class Junit4TestCase {
@BeforeClass
public static void setUpBeforeClass() {
System.out.println("Set up before class");
}
@Before
public void setUp() throws Exception {
System.out.println("Set up");
}
@Test
public void testMathPow() {
System.out.println("Test Math.pow");
Assert.assertEquals(4.0, Math.pow(2.0, 2.0), 0.0);
}
@Test
public void testMathMin() {
System.out.println("Test Math.min");
Assert.assertEquals(2.0, Math.min(2.0, 4.0), 0.0);
}
// 期望此方法抛出NullPointerException异常
@SuppressWarnings("null")
@Test(expected = NullPointerException.class)
public void testException() {
System.out.println("Test exception");
Object obj = null;
obj.toString();
}
@Test(timeout = 1000) // 单位为毫秒
public void testSquareRoot() {
// cal.squareRoot(4);
}
// 忽略此测试方法
@Ignore
@Test
public void testMathMax() {
Assert.fail("没有实现");
}
// 使用“假设”来忽略测试方法
@Test
public void testAssume() {
System.out.println("Test assume");
// 当假设失败时，则会停止运行，但这并不会意味测试方法失败。
Assume.assumeTrue(false);
Assert.fail("没有实现");
}
@After
public void tearDown() throws Exception {
System.out.println("Tear down");
}
@AfterClass
public static void tearDownAfterClass() {
System.out.println("Tear down After class");
}
}
注解的含义自己理解吧。
2. 同时运行多个测试类
// 通过Java程序启动多个测试类
public class TestUtil {
public static void main(String[] args) {
org.junit.runner.JUnitCore.runClasses(
UserAssignServiceTest.class,
Junit4TestCase.class);
}
}
3. 运行器
运行器的定义方法如下
@RunWith(BlockJunit4ClassRunner.class)
public class BaseJunit4Test {
}
默认情况下，JUnit4的运行器是BlockJunit4ClassRunner.class，我们可以使用第三方的运行器来运行JUnit的测试类。
JUnit4提供了一个叫Suite.class的运行器，作用与启动多个测试类的效果类似
@RunWith(Suite.class)
@Suite.SuiteClasses({
UserAssignServiceTest.class,
Junit4TestCase.class
})
public class TestSuite {
}
Junit4编译器在执行TestCase的过程中利用反射机制，以便我们可以对测试的开始过程中进行一些预处理，如读取元数据信息，拦截异常，数据库操作等。
JUnit4还提供了几个运行器，有兴趣可以自己去看一下源码。
下文我们会进行spring-test的整合，spring提供了一个unit运行器SpringJUnit4ClassRunner
4. 参数化测试
有的测试用例，我们需要输入多组数据进行测试！每一次都改变输入值会很麻烦。这里可以使用如下的方法进行书写。
@RunWith(Parameterized.class)
public class HolidaySkedTestParameter {
private int D;
private boolean result;
// 这里的返回至少是二维数组
@Parameters
public static Collection data() {
Object[][] object = {{1, true}, {20, true}, {43, true}, {100, false}};
return Arrays.asList(object);
}
public HolidaySkedTestParameter(int D, boolean result) {
this.D = D;
this.result = result;
}
@Test
public void testholiday() {
HolidaySked holiday = new HolidaySked();
assertEquals(result, holiday.isHoliday(D));
}
}
上面的例子表示@Test会执行四次，每次的输入数据和期待的结构都由data()方法决定。
分析：
- 首先，你要为这种测试专门生成一个新的类，而不能与其他测试共用同一个类。然后，你要为这个类指定一个Runner，而不能使用默认的Runner了，因为特殊的功能要用特殊的Runner嘛。@RunWith(Parameterized.class)这条语句就是为这个类指定了一个ParameterizedRunner。
- 然后，定义一个待测试的类，并且定义两个变量，一个用于存放参数，一个用于存放期待的结果。接下来，定义测试数据的集合，也就是上述的data()方法，该方法可以任意命名，但是必须使用@Parameters标注进行修饰。
- 数据说明：每组两个数，一个是参数，一个是预期结果
- 构造函数
思考：如何进行封装，更有效的提供数据，比如以外部文本的方式，这样测试将更加灵活。
5. @Theory
这几乎是参数化测试的升级版本。参数化测试必须自己一个独立的类，而@Theory不用。说明一下作用：指定的数据集自动代入进行连续多次测试
使用JUnit Theories，你只需建立一次测试数据生成器，以用来创建所有更易产生问题的场景，然后在所有使用理论的测试中进行重用。
- 首先要在测试类上声明：@RunWith(Theories.class)
- 使用@DataPoint标记待用实参数据
// 数据集合
@DataPoints
public static int[] aa = {13,454,677,5};
// 单个数据
@DataPoint
public static String b = "bbbbbb";
- 使用@Theory标记单形参测试方法
@Theory
public void test(String ccc, int tt) {
System.out.println(ccc + " " + tt);
}
输出的结果会是提供数据的各种组合！
还可以在类中使用@Test注解测试方法
遗憾的是参数化测试需要使用指定的加载器Theories.class
-
Theory扩展
JUnit中自带一个默认的 Parameter Supplier 实现：@TestedOn(ints = int[])
@Theory
public final void test(@TestedOn(ints = { 0, 1, 2 }) int i) {
assertTrue(i >= 0);
}
输入的数据已经被限定！
更多好的细节请参考这篇文章JUnit4.11 理论机制 @Theory 完整解读
下面是一个完整的例子
@RunWith(Theories.class)
public class TheoriesTest {
@DataPoints
public static String[] a = {"aaaaaa","bbb","cccc"};
@DataPoints
public static int[] aa = {13,454,677,5};
@DataPoint
public static String b = "bbbbbb";
@Theory
public void multiplyIsInverseOfDivide(
@TestedOn(ints = {0, 5, 10}) int amount,
@TestedOn(ints = {0, 1, 2}) int m) {
System.out.println("amount->" + amount + " m ->" + m);
assumeThat(m, not(0));
System.out.println("m 是、 " + m + " 测试！");
assertThat((amount * m) / m, is(amount));
}
@Theory
public final void test(@TestedOn(ints = { 0, 1, 2 }) int i) {
System.out.println(SpringContextHellper.getInstance().getContext());
assertTrue(i >= 0);
}
@Theory
public void test(String ccc, int tt) {
System.out.println(ccc + " " + tt);
}
@Theory
public void test2(String b) {
System.out.println("====== " + b);
}
}
目标
下面是对这套文章的规划
- 第一步-简单整合: 进行spring + unit的整合
- 第二步-JUNIT自定义: 进行junit的功能扩展
- 第三步-使用hamcrest：讲解Hamcrest的简单使用和扩展
- 第四步-代码覆盖率：讲解代码覆盖率工具的使用
- 第五步-启动覆盖率测试：Web程序如何使用代码覆盖率
- 第六步-DB数据的准备：进行数据环境的准备和恢复
