JaveEE测试：第零步-Junit4介绍

起步

为了提升代码质量，准备很好的进行测试工作。最近研究了一下测试相关的内容，进行了一些整理。

简介

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()方法决定。
分析：

1. 首先，你要为这种测试专门生成一个新的类，而不能与其他测试共用同一个类。然后，你要为这个类指定一个Runner，而不能使用默认的Runner了，因为特殊的功能要用特殊的Runner嘛。@RunWith(Parameterized.class)这条语句就是为这个类指定了一个ParameterizedRunner。
2. 然后，定义一个待测试的类，并且定义两个变量，一个用于存放参数，一个用于存放期待的结果。接下来，定义测试数据的集合，也就是上述的data()方法，该方法可以任意命名，但是必须使用@Parameters标注进行修饰。
3. 数据说明：每组两个数，一个是参数，一个是预期结果
4. 构造函数

思考：如何进行封装，更有效的提供数据，比如以外部文本的方式，这样测试将更加灵活。

5. @Theory

这几乎是参数化测试的升级版本。参数化测试必须自己一个独立的类，而@Theory不用。说明一下作用：指定的数据集自动代入进行连续多次测试
使用JUnit Theories，你只需建立一次测试数据生成器，以用来创建所有更易产生问题的场景，然后在所有使用理论的测试中进行重用。

1. 首先要在测试类上声明：@RunWith(Theories.class)
2. 使用@DataPoint标记待用实参数据

    //  数据集合 
    @DataPoints
    public static int[] aa = {13,454,677,5};
    //  单个数据
    @DataPoint
    public static String b = "bbbbbb";

3. 使用@Theory标记单形参测试方法

    @Theory
    public void test(String ccc, int tt) {
        System.out.println(ccc + " " + tt);
    }

输出的结果会是提供数据的各种组合！
还可以在类中使用@Test注解测试方法
遗憾的是参数化测试需要使用指定的加载器Theories.class

4. 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数据的准备：进行数据环境的准备和恢复