单元测试JUnit 4(二)——keeps the bar green to keeps the code clean

1.Failure和Error

Failure是指测试失败  Error是指测试程序本身出错  (int a=10/0)

2.JUnit常用注解

2.1 @RunWith: 可以更改测试运行器（继承org.junit.runner.Runner）
2.2 @Test: 将一个普通的方法修饰成为一个测试方法
  Test有两个参数：
     expected 表示预期可能产生的异常，如果匹配则不报错
     timeout  表示超时时间，如果超过这个时间没有完成，则抛出TestTimedOutException

 @Test(expected=ArithmeticException.class,timeout=2000)//第一个参数是异常类的类类型，第二个参数是毫秒数

  2.3 全局的初始化和销毁：@BeforeClass和@AfterClass

@BeforeClass: 他会在所有的方法运行前被执行，static修饰，用来进行一些开销昂贵的初始化操作，比如连接数据库。
@AfterClass: 他会在所有的方法运行结束后被执行，static修饰
   注意这两个修饰符修饰的方法必须是public static void的，并且没有参数（no-arg）。
 Note:
     即便@BeforeClass修饰的方法抛出异常了，@AfterClass修饰的方法也会照常执行。
    基类的@BeforeClass方法会在子类的@BeforeClass方法之前进行；而基类的@AfterClass方法会在子类的@AfterClass方法之后进行。

2.4 这两个方法会在每一个测试用例的前后被调用，所以可以用来创建对象，对于每个测试用例来说都是一个新的对象。

@Before: 会在每一个测试方法被运行前执行一次
@After: 会在每一个测试方法运行后被执行一次

2.5 @Ignore注解可用于修饰测试类与测试方法，被@Ignore所修饰的方法或类中的测试（@Test修饰的测试）将不会被执行。

　　@Ignore中可以加上参数值，说明忽略测试的原因。

2.6 示例（以数值计算测试为例）

2.6.1 Calculator.java

package com.zang.junit4.test;

public class Calculator
{
    public int add(int a, int b)
    {
        return a + b;
    }

    public int subtract(int a, int b)
    {
        return a - b;
    }

    public int multiply(int a, int b)
    {
        return a * b;
    }

    public int divide(int a, int b) throws Exception
    {
        if (0 == b)
        {
            throw new Exception("除数不能为0");
        }
        return a / b;
    }
}

2.6.2 CalculatorTest.java

package com.zang.junit4.test;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

import static org.junit.Assert.assertEquals;//静态导入

public class CalculatorTest
{
    private Calculator cal = null;

    @BeforeClass
    public static void globalInit()
    {
        System.out.println("global Init invoked!");
    }

    @AfterClass
    public static void globalDestroy()
    {
        System.out.println("global Destroy invoked!");
    }

    @Before
    public void init()//setUp()
    {

        cal = new Calculator();
        System.out.println("init --> cal: " + cal);

    }

    @After
    public void destroy()//tearDown()
    {
        System.out.println("destroy");
    }

    @Test
    public void testAdd()
    {
        System.out.println("testAdd");
        int result = cal.add(3, 5);
        assertEquals(8, result);
    }

    @Test
    public void testSubtract()
    {
        System.out.println("testSubtract");
        int result = cal.subtract(1, 6);
        assertEquals(-5, result);

    }

    @Test
    public void testMultiply()
    {
        System.out.println("testMultiply");
        int result = cal.multiply(5, 9);
        assertEquals(45, result);
    }

}

2.6.3 Run As JUnit Test ——>控制台输出

2.7  JUnit运行流程

   1. @BeforeClass修饰的方法会在所有方法被调用前执行，而且该方法是静态的，所以当测试类被加载后接着就会运行它，而且在内存中它只会存在一份实例，
它比较适合加载配置文件
  2. @AfterClass所修饰的方法通常用来对资源的清理，如关闭数据库的连接
  3. @Before和@After会在每个测试方法的前后各执行一次

运行顺序：
@BeforeClass-> (@Before->@Test->@After) ...->@AfterClass

 3.运行多个测试

    3.1 Run Configurations

3.2  使用JUnit测试套件

测试套件就是组织测试类一起运行的
 3.2.1. 写一个作为测试套件的入口类，这个类里不包含其他的方法！！！
 3.2.2. 更改测试运行器Suite.class.
 3.2.3. 将要测试的类作为数组传入到Suite.SuiteClasses({})

package com.zang.junit4.test;

import static org.junit.Assert.*;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

     @RunWith(Suite.class) //将测试类改为测试套件类
     @SuiteClasses({TaskTest1.class,TaskTest2.class,TaskTest3.class}) //用数组的形式将测试的类添加到测试套件中
    public class SuiteTest {

            //要用public修饰，套件测试类要为空。不能有方法。
    }

注意:  遵守约定，比如：

a) 类放在test包中 b) 类名用XXXTest结尾  c) 方法用testMethod命名