JUnit介绍及其快速使用-技术开发专区

JUnit介绍及其快速使用

作者：ych2054的专栏编辑：李倩 2009-01-06 16:19 来源：ITPUB.n

【IT168 技术文章】

　　JUnit 是 Java 社区中知名度最高的单元测试工具。它诞生于 1997 年，由 Erich Gamma 和 Kent Beck 共同开发完成。其中 Erich Gamma 是经典著作《设计模式：可复用面向对象软件的基础》一书的作者之一，并在 Eclipse 中有很大的贡献；Kent Beck 则是一位极限编程（XP）方面的专家和先驱。

　　麻雀虽小，五脏俱全。JUnit 设计的非常小巧，但是功能却非常强大。Martin Fowler 如此评价 JUnit：在软件开发领域，从来就没有如此少的代码起到了如此重要的作用。它大大简化了开发人员执行单元测试的难度，特别是 JUnit 4 使用 Java 5 中的注解（annotation）使测试变得更加简单。

　　从推出到现在,JUnit3.8.1和JUnit4的工作原理和使用区别还是比较大的，下面首先用一段代码来演示JUnit3.8.1的快速使用，以便熟悉JUnit的原理

1.首先，我们在Eclipse的项目中创建一个待测试的类Hello.java,代码如下：

public class Hello {

    public int abs(int num)
    {
        return num>0?num:-num;
    }
    public double division(int a,int b)
    {
        return a/b;
    }
}

　　2.右击该类，选择新建->JUnit测试用例,选择JUnit3.8.1,setUp和tearDown方法,点击下一步，选择需要测试的方法,JUnit会自动生成测试的代码框架，手动添加自己的测试代码后如下：

import junit.framework.TestCase;

public class HelloTest extends TestCase {

    private Hello hello;
    public HelloTest()
    {
        super();
        System.out.println("a new test instance...");
    }
    //测试前JUnit会调用setUp()建立和初始化测试环境
    protected void setUp() throws Exception {
        super.setUp();                                    //注意：在Junit3.8.1中这里要调用父类的setUp()
        hello=new Hello();
        System.out.println("call before test...");
    }
    //测试完成后JUnit会调用tearDown()清理资源，如释放打开的文件,关闭数据库连接等等
    protected void tearDown() throws Exception {
        super.tearDown();                                //注意：在Junit3.8.1中这里要调用父类的tearDown()
        System.out.println("call after test... ");
    }

    //测试Hello类中的abs函数
    public void testAbs() {
        System.out.println("test the method abs()");
        assertEquals(16, hello.abs(16));
        assertEquals(11, hello.abs(-10));//在这里，会出现故障，应该把左边的参数改为10
        assertEquals(0, hello.abs(0));

    }

    //测试Hello类中的division函数
    public void testDivision() {
        System.out.println("test the method division()");
        assertEquals(3D, hello.division(6, 2));
        assertEquals(6D, hello.division(6, 1));
        assertEquals(0D, hello.division(6, 0));//在这里，会出现错误，java.lang.ArithmeticException: /by zero

    }

}

　　3.运行该测试类，输出如下：

a new test instance...
a new test instance...
call before test...
test the method abs()
call after test...

call before test...
test the method division()
call after test...
　　从上面的输出结果中，可以看出JUnit大概会生成如下的测试代码:

try {
    HelloTest test = new HelloTest();     // 建立测试类实例
    test.setUp();             // 初始化测试环境
    test.testAbs();             // 测试abs方法
    test.tearDown();             // 清理资源
}
catch(Exception e){}

try {
    HelloTest test = new HelloTest();     // 建立测试类实例
    test.setUp();             // 初始化测试环境
    test.testDivision();         // 测试division方法
    test.tearDown();             // 清理资源
}
catch(Exception e){}

　　所以，每测试一个方法，JUnit就会创建一个xxxTest实例，如上面就分别生成了两个HelloTest实例来分别测试abs和division方法。

现在已经了解了JUnit3.8.1的使用和其基本的工作原理，JUnit 4是JUnit框架有史以来的最大改进，其主要目标便是利用Java 5的Annotation特性简化测试用例的编写。下面同样通过代码来学习一下:

　　1.右击该类，选择新建->JUnit测试用例,选择JUnit4,setUp和tearDown方法,点击下一步，选择需要测试的方法,JUnit会自动生成测试的代码框架(可以看到这个代码框架和上面的有较大的不同)，手动添加自己的测试代码后如下：

import static org.junit.Assert.*;

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

public class HelloTest4 { //这里不需要继承自TestCase

    private Hello hello;
    public HelloTest4()
    {
        super();
        System.out.println("a new test instance...");
    }
    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
        System.out.println("call before all tests...");
    }

    @AfterClass
    public static void tearDownAfterClass() throws Exception {
        System.out.println("call after all tests... ");
    }
    @Before
    public void setUp() throws Exception {
        //这里不需要调用super.setUp()
        System.out.println("call before test...");
        hello=new Hello();
    }

    @After
    public void tearDown() throws Exception {
        //这里不需要调用super.tearDown()
        System.out.println("call after test... ");
    }

    @Test
    public void testAbs() {
        System.out.println("test the method abs()");
        assertEquals(16, hello.abs(16));
        assertEquals(11, hello.abs(-10));//在这里，会出现故障，应该把左边的参数改为10
        assertEquals(0, hello.abs(0));
    }

    @Test
    public void testDivision() {
        System.out.println("test the method division()");
        assertEquals(3D, hello.division(6, 2));
        assertEquals(6D, hello.division(6, 1));
        assertEquals(0D, hello.division(6, 0));//在这里，会出现故障(与3.8.1有些不同?)
    }

    //下面,并不是对JunitDemo类中成员函数的测试，只是演示JUnit的一些功能

    //测试是否会发生期望的异常
    @Test(expected=ArithmeticException.class)
    public void testDiv0() {
        System.out.println("test the method Div0()");
        double result=100/0;
    }

    //测试是否超时
    @Test(timeout=1)
    public void testLongTimeTask()
    {
        System.out.println("test the method LongTimeTask()");
        double d = 0;
        for(int i=1; i<10000000; i++)
            d+=i;
    }

}

　　2.运行该测试类，输出如下：

call before all tests...
a new test instance...
call before test...
test the method abs()
call after test...

a new test instance...
call before test...
test the method division()
call after test...

a new test instance...
call before test...
test the method Div0()
call after test...

a new test instance...
call before test...
test the method LongTimeTask()
call after test...

call after all tests...
　　3.从上面的输出结果可以看出，JUnit的工作原理和以前的几乎还是没有变的，只是让用户使用更简单了当然有一个变化是3.8.1的所有测试实例是测试前全都创建好的，而JUnit4的测试实例是在每个测试前创建的。

　　4.当JUnit4还有一个与以前很大的不同就是引入了@BeforeClass和@AfterClass(可以在选择setUp和tearDown的时候选择setUpBeforeClass()和tearDownAfterClass()),setUpBeforeClass()在所有测试前调用,tearDownAfterClass()在所有测试后调用，它们不同与setUp和tearDown，在整个测试过程中只会被调用一次,这是为了能在@BeforeClass中初始化一些昂贵的资源，例如数据库连接，然后执行所有的测试方法，最后在@AfterClass中释放资源。

　　总结，这里只是对JUnit对class的单元测试作了简单的讨论，除此以外，JUnit还可以对JSP,Servlt,EJB等做单元测试。

关注我们