1. @Before和@After

同一个单元测试内的多个测试方法：

• 测试前都需要初始化某些对象
• 测试后可能需要清理资源fileInputStream.close()

    @Test

    public void testCalcAdd2Number(){

        Main calc = new Main();

        int r = calc.calculate("1+2");

        assertEquals(3,r);

    }

    @Test

    public void testCalcAdd3Number(){

        Main calc = new Main();

        int r = calc.calculate("1+2+5");

        assertEquals(8,r);

    }

JUnit可以使用@Before和@After：

• 在@Before方法中初始化测试资源
• 在@After方法中释放测试资源
• @Before方法初始化的对象要放在实例字段中，因为实例字段的状态不会影响下一个@Test

public class MainTest {

    Main calc;//@Before方法初始化的对象放在实例字段中

    @Before

    public void setUp(){

        calc = new Main();

    }

    @Test

        /**

     *     JUnit对于每个@Test方法

     *     1.实例化MainTest对象，如MainTest  test = new MainTest();

     *     2.执行@Before方法 test.serUp();

     *     3.执行@Test方法 test.test();

     *     4.执行@After方法 test.tearDown();

     */

    public void testCalcAdd2Number(){

        int r = calc.calculate("1+2");

        assertEquals(3,r);

    }

    @After

    public void tearDown(){

        calc = null;

    }

    @Test

    public void testCalcAdd3Number(){

        Main calc = new Main();//实例字段的状态不会受上次测试的，同样也不会影响到本次测试

        int r = calc.calculate("1+2+5");

        assertEquals(8,r);

    }

    @After

    public void tearDown(){

        calc = null;

    }

}

示例

Calculator.java

public class Calculator {

    public int calculator(String expression){

        String[] ss = expression.split("\\+");

        int sum = 0;

        for(String s:ss){

            sum = sum + Integer.parseInt(s.trim());

        }

        return sum;

    }

}

CalculatorTest.java

package com.testList;

import org.junit.After;

import org.junit.Before;

import org.junit.Test;

import java.util.Calendar;

import static org.junit.Assert.*;

public class CalculatorTest {

    Calculator calc;

    @Before

    public void setUp(){

        calc = new Calculator();

    }

    @Test

    public void testCalcAdd2Numbers(){

        int r = calc.calculator("1+2");

        assertEquals(3,r);

    }

    @Test

    public void testCalcAdd3Numbers(){

        int r = calc.calculator("1+2+5");

        assertEquals(8,r);

    }

    @Test

    public void testCalcAddLargeNumber() {

        int r = calc.calculator("123+456");

        assertEquals(579,r);

    }

    @Test

    public void testCalcWithWhiteSpace(){

        int r = calc.calculator("1 + 5 + 10 ");

        assertEquals(16,r);

    }

    @After

    public void tearDown(){

        calc = null;

    }

}

因此，使用@Before和@After可以保证：
* 单个@Test方法执行前会创建新的XxxTest示例，变量的状态不会传递给下一个@Test方法
* 单个@Test方法执行前后会执行@Before和@After方法

2.@BeforeClass和@AfterClass静态方法：

• 1.在执行所有@Test方法前执行@BeforeClass静态方法
• 2.执行所有测试
• 3.在执行所有@Test方法后执行@AfterClass静态方法
• @BeforeClass静态方法初始化的对象只能存放在静态字段中，而静态字段的状态会影响到所有@Test

public class MainTest{

    static Main mainer;

    @BeforeClass

    public static void beforeClass(){

        mainer = new Main();

    }

}

JUnit执行逻辑：

• @BeforeClass
• @setUp @Test @tearDown
• @setUp @Test @tearDown
• ...
• @AfterClass

初始化测试资源称为Fixture（设备，不能移动之物）

• @Before：初始化测试对象，例如：input = new FileInputStream()
• @After：销毁@Before创建的测试对象，例如：input.close()
• @BeforeClass：初始化非常耗时的资源，例如连接数据库
• @AfterClass：清理@BeforeClass创建的资源，例如断开数据库连接

import org.junit.*;

public class SequenceTest {

    @BeforeClass

    public static void setUpBeforeClass() throws Exception{

        System.out.println("setUpBeforeClass");

    }

    @AfterClass

    public static void tearDownBeforeClass() throws Exception{

        System.out.println("earDownBeforeClass");

    }

    @Before

    public void setUp() throws Exception{

        System.out.println("\tsetUp");

    }

    @After

    public void tearDown() throws Exception{

        System.out.println("\ttearDown");

    }

    @Test

    public void test1() throws Exception{

        System.out.println("\t\t方法1");

    }

    @Test

    public void test2() throws Exception{

        System.out.println("\t\t方法2");

    }

    @Test

    public void test3() throws Exception{

        System.out.println("\t\t方法3");

    }

}

3.总结：

• 理解JUnit执行测试的生命周期
• @Before用于初始化测试对象，测试对象以实例变量存放
• @After用于清理@Before创建的对象
• @BeforeClass用于初始化耗时资源
• @AfterClass用于清理@BeforeClass创建的资源