廖雪峰Java8JUnit單元測試-2使用JUnit-1使用Before和After

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創建的資源