Java单元测试



JUNIT

JUnit是Java单元测架，已经在Eclipse中默认安装。目前主流的有JUnit3和JUnit4。JUnit3中，测试用例需要继承TestCase类。JUnit4中，测试用例无需继承TestCase类，只需要使用@Test等注解

Junit3

// 测试java.lang.Math  
// 必须继承TestCase  
public class Junit3TestCase extends TestCase {  
    public Junit3TestCase() {  
        super();  
    }  
    
        // 传入测试用例名称  
    public Junit3TestCase(String name) {  
        super(name);  
    }  
   
        // 在每个Test运行之前运行  
    @Override  
    protected void setUp() throws Exception {  
        System.out.println("Set up");  
    }  
        // 测试方法。  
        // 方法名称必须以test开头，没有参数，无返回值，是公开的，可以抛出异常  
        // 也即类似public void testXXX() throws Exception {}  
    public void testMathPow() {  
        System.out.println("Test Math.pow");  
        Assert.assertEquals(4.0, Math.pow(2.0, 2.0));  
    }  
   
    public void testMathMin() {  
        System.out.println("Test Math.min");  
        Assert.assertEquals(2.0, Math.min(2.0, 4.0));  
    }  
   
        // 在每个Test运行之后运行  
    @Override  
    protected void tearDown() throws Exception {  
        System.out.println("Tear down");  
    }  
}  

从中，可以猜测到，对于每个测试方法，调用的形式是：

testCase.setUp();  
testCase.testXXX();  
testCase.tearDown(); 

运行测试方法

在Eclipse中，可以直接在类名或测试方法上右击，在弹出的右击菜单中选择Run As -> JUnit Test。
在Mvn中，可以直接通过mvn test命令运行测试用例。
也可以通过Java方式调用，创建一个TestCase实例，然后重载runTest()方法，在其方法内调用测试方法（可以多个）。

TestCase test = new Junit3TestCase("mathPow") {  
        // 重载  
    protected void runTest() throws Throwable {  
        testMathPow();  
    };  
};  
test.run();  

更加便捷地，可以在创建TestCase实例时直接传入测试方法名称，JUnit会自动调用此测试方法，如

TestCase test = new Junit3TestCase("testMathPow");  
test.run(); 

JUnit4

与JUnit3不同，JUnit4通过注解的方式来识别测试方法。目前支持的主要注解有：

• @BeforeClass 全局只会执行一次，而且是第一个运行
• @Before 在测试方法运行之前运行
• @Test 测试方法
• @After 在测试方法运行之后允许
• @AfterClass 全局只会执行一次，而且是最后一个运行
• @Ignore 忽略此方法

下面举一个样例：

import org.junit.After;  
import org.junit.AfterClass;  
import org.junit.Assert;  
import org.junit.Before;  
import org.junit.BeforeClass;  
import org.junit.Ignore;  
import org.junit.Test;  
   
public class Junit4TestCase {  
   
    @BeforeClass  
    public static void setUpBeforeClass() {  
        System.out.println("Set up before class");  
    }  
   
    @Before  
    public void setUp() throws Exception {  
        System.out.println("Set up");  
    }  
   
    @Test  
    public void testMathPow() {  
        System.out.println("Test Math.pow");  
        Assert.assertEquals(4.0, Math.pow(2.0, 2.0), 0.0);  
    }  
   
    @Test  
    public void testMathMin() {  
        System.out.println("Test Math.min");  
        Assert.assertEquals(2.0, Math.min(2.0, 4.0), 0.0);  
    }  
   
        // 期望此方法抛出NullPointerException异常  
    @Test(expected = NullPointerException.class)  
    public void testException() {  
        System.out.println("Test exception");  
        Object obj = null;  
        obj.toString();  
    }  
   
        // 忽略此测试方法  
    @Ignore  
    @Test  
    public void testMathMax() {  
          Assert.fail("没有实现");  
    }  
        // 使用“假设”来忽略测试方法  
    @Test  
    public void testAssume(){  
        System.out.println("Test assume");  
                // 当假设失败时，则会停止运行，但这并不会意味测试方法失败。  
        Assume.assumeTrue(false);  
        Assert.fail("没有实现");  
    }  
   
    @After  
    public void tearDown() throws Exception {  
        System.out.println("Tear down");  
    }  
   
    @AfterClass  
    public static void tearDownAfterClass() {  
        System.out.println("Tear down After class");  
    }  
   
}