JUnit 4 简介

测试框架是最流行的 Java 单元测试框架。JUnit 被用来开发对 Java 类的单元测试。它就是一个类包，提供了各种方法来测试 Java 类中的方法(method)。

JUnit 4 特性

1. 简单的注解，提供书写 JUnit 测试的基本特性
2. 断言方法(Assert Methods)比较测试的方法执行结果值和期望值
3. @Ignore 注解，忽略测试方法或者测试类的执行
4. 期望异常测试
5. 超时测试,测试方法的执行时间
6. 测试组件，一起运行一些测试类
7. 参数化测试，以不同的输入参数值测试方法

Eclipse 中的 JUnit 视图窗口

1. ① Runs：显示了执行了的 jUnit 测试用例(方法)总数
2. ② Errors：显示结果为 error/exception 的测试用例总数
3. ③ Failures：显示测试用例执行失败总数
4. ④ Failure Trace：展示 error/exception or failure trace
5. ⑤ Show Failures Only：只显示失败的用例信息
6. ⑥ Scroll Lock：scroll lock
7. ⑦ Rerun Test：重新运行测试用例
8. ⑧ Rerun Test – Failure First：重新运行测试用例，先执行失败了的测试用例
9. ⑨ Stop JUnit Test Run：停止单元测试
10. ⑩ Test Run History：显示测试用例运行历史

JUnit4 注解

@BeforeClass注解

被 @BeforeClass 注解的方法会是：只被执行一次，运行 JUnit 测试类时第一个被执行的方法。

这样的方法被用作执行计算代价很大的任务，如打开数据库连接。被 @BeforeClass 注解的方法应该是静态的（即 static 类型的）。

@AfterClass注解

被 @AfterClass 注解的方法应是：只被执行一次，运行 JUnit 测试类是最后一个被执行的方法

该类型的方法被用作执行类似关闭数据库连接的任务。被 @AfterClass 注解的方法应该是静态的（即 static类型的）。

@Before注解

被 @Before 注解的方法应是：JUnit 测试类中的任意一个测试方法执行前都会执行此方法。

该类型的方法可以被用来为测试方法初始化所需的资源。

@After注解

被 @After 注解的方法应是：JUnit 测试类中的任意一个测试方法执行后都会执行此方法, 即使被 @Test 或 @Before 修饰的测试方法抛出异常

该类型的方法被用来关闭由 @Before 注解修饰的测试方法打开的资源。

@Test 注解

被 @Test 注解的测试方法包含了真正的测试代码，并且会被 JUnit 应用为要测试的方法。@Test 注解有两个可选的参数：

1. expected 表示此测试方法执行后应该抛出的异常，（值是异常名）。
2. timeout 检测测试方法的执行时间。

import static org.junit.Assert.assertEquals;

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

public class ArithmeticTest {

    @BeforeClass
    public static void setUpClass() {
        // one time setup method
        System.out.println("@BeforeClass - executed only one time and is first method to be executed");
    }

    @AfterClass
    public static void tearDownClass() {
        // one time tear down method
        System.out.println("@AfterClass - executed only one time and is last method to be executed");
    }

    @Before
    public void setUp() {
        // set up method executed before every test method
        System.out.println("@Before - executed before every test method");
    }

    @After
    public void tearDown() {
        // tear down method executed after every test method
        System.out.println("@After - executed after every test method");
    }

    @Test
    public void testAdd() {
        Arithmetic arithmetic = new Arithmetic();
        int actualResult = arithmetic.add(3, 4);
        int expectedResult = 7;
        assertEquals(expectedResult, actualResult);
        System.out.println("@Test - defines test method");
    }

    // 多个Test 会多次执行 @Before @After
    @Test
    public void testAdd2() {
        System.out.println("@Test - testAdd2 method");
    }
}

class Arithmetic {
    public int add(int i, int j) {
        return i + j;
    }
}

控制台打印结果：

@BeforeClass - executed only one time and is first method to be executed
@Before - executed before every test method
@Test - testAdd method
@After - executed after every test method
@Before - executed before every test method
@Test - testAdd2 method
@After - executed after every test method
@AfterClass - executed only one time and is last method to be executed

@Ignore 注解

这个注释是用来忽略有关不需要执行的测试的。可以在方法上，也可以在类上。

JUnit 4 断言方法

JUnit 4 断言方法允许检查测试方法的期望结果值和真实返回值。JUnit 的 org.junit.Assert 类提供了各种断言方法来写 JUnit 测试。这些方法被用来检查方法的真实结果值和期望值。下列一些有用的断言方法列表，并且以下方法存在大量重载方法：

例子

import org.junit.Test;
import java.util.ArrayList;
import java.util.List;
import static org.junit.Assert.*;

public class ArithmeticTest {

    @Test
    public void testAssertNull() {
        String str = null;
        assertNull(str);
    }

    @Test
    public void testAssertNotNull() {
        String str = "hello Java!!";
        assertNotNull(str);
    }

    @Test
    public void testAssertEqualsLong() {
        long long1 = 2;
        long long2 = 2;
        assertEquals(long1, long2);
    }

    @Test
    public void testAssertEqualsDouble() {
        // test case is successfull as double1 and double 2
        // differ by 0.001 which is less than our specified delta
        double double1 = 1.236;
        double double2 = 1.237;
        double delta = 0.002;
        assertEquals(double1, double2, delta);
    }

    @Test
    public void testAssertTrue() {
        List<String> list = new ArrayList<String>();
        assertTrue(list.isEmpty());
    }

    @Test
    public void testAssertFalse() {
        List<String> list = new ArrayList<String>();
        list.add("hello");
        assertFalse(list.isEmpty());
    }

    @Test
    public void testAssertSame() {
        String str1 = "hello world!!";
        String str2 = "hello world!!";
        assertSame(str2, str1);
    }

    @Test
    public void testAssertNotSame() {
        String str1 = "hello world!!";
        String str3 = "hello Java!!";
        assertNotSame(str1, str3);
    }
}

参考

Junit 4 Tutorials(Junit 4 教程)

JUnit4 wiki翻译