廖雪峰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("	setUp");
    }
    @After
    public void tearDown() throws Exception{
        System.out.println("	tearDown");
    }
    @Test
    public void test1() throws Exception{
        System.out.println("		方法1");
    }
    @Test
    public void test2() throws Exception{
        System.out.println("		方法2");
    }
    @Test
    public void test3() throws Exception{
        System.out.println("		方法3");
    }
}

3.总结：

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