JUnit单元测试学习摘要教程

1.教程摘要

　　在编写代码的时候经过System.out和alert来作测试，很是麻烦，并且不够正规，对于即将步入工做的人来讲，一个正规的写代码习惯和测试习惯是很是重要的，所以应当认真学学如何使用JUnit。　　

　　junit包有junit3和junit4两个版本，通常都使用junit4这个版本，兼容性好且更灵活。

2.教程实例

步骤1：建立待测试类

首先新建一个项目叫JUnit_Test，咱们编写一个Calculator类，这是一个可以简单实现加减乘除、平方、开方的计算器类，而后对这些功能进行单元测试。这个类并非很完美，咱们故意保留了一些Bug用于演示，这些Bug在注释中都有说明。该类代码以下：

package dyz.calculator;
public class Calculator {

    private static int result; // 静态变量，用于存储运行结果
    public void add(int n) {
        result = result + n;
    }
    public void substract(int n) {
        result = result - 1; // Bug: 正确的应该是 result =result-n
    }

    public void multiply(int n) {
    } // 此方法还没有写好

    public void divide(int n) {
        result = result / n;
    }

    public void square(int n) {
        result = n * n;
    }

    public void squareRoot(int n) {
        for (;;)
            ; // Bug : 死循环
    }

    public void clear() { // 将结果清零
        result = 0;
    }

    public int getResult() {
        return result;
    }
}

步骤2：在eclipse中为项目添加JUnit环境

右键JUnit_Test项目，在build path中“add library”，添加JUnit，以下图所示：

步骤3：建立测试类

右键Calculator类，选择“new"，建立JUnit Test Case

步骤4：编写测试用例代码

测试用例代码以下：

package dyz.calculatortest;
import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;

import xw.calculator.Calculator;

public class CalculatorTest {
    private static Calculator calculator = new Calculator();

    // 复原操做，代表对每一个Test方法测试之后都会进行这个方法操做。
    @Before
    public void setUp() throws Exception {
        calculator.clear();// 结果清零
    }

    @Test
    public void testAdd() {
        // fail("Not yet implemented");
        calculator.add(2);
        calculator.add(3);
        assertEquals(5, calculator.getResult());
    }

    @Test
    public void testSubstract() {
        // fail("Not yet implemented");
        calculator.add(10);
        calculator.substract(2);
        assertEquals(8, calculator.getResult());
    }

    // 忽略标注，代表这个方法功能尚未实现
    @Ignore("Multiply() Not yet implemented")
    @Test
    public void testMultiply() {
        fail("Not yet implemented");
    }

    @Test
    public void testDivide() {
        // fail("Not yet implemented");
        calculator.add(8);
        calculator.divide(2);
        assertEquals(4, calculator.getResult());
    }

    // Timeout参数代表了你要设定的时间，单位为毫秒，所以1000就表明1秒。
    @Test(timeout = 1000)
    public void squareRoot() {
        calculator.squareRoot(4);
        assertEquals(2, calculator.getResult());

    }

    /**
     * square1/square2/square3分别用来测试正数，0，复数的平方
     */
    @Test
    public void square1() {
        calculator.square(2);
        assertEquals(4, calculator.getResult());
    }

    @Test
    public void square2() {
        calculator.square(0);
        assertEquals(0, calculator.getResult());
    }

    @Test
    public void square3() {
        calculator.square(-3);
        assertEquals(9, calculator.getResult());
    }
}

经常使用注解说明　　

　　一、@BeforeClass所修饰的方法在全部方法加载前执行，并且他是静态的在类加载后就会执行该方法，

在内存中只有一份实例，适合用来加载配置文件。

　　二、@AfterClass所修饰的方法在全部方法执行完毕以后执行，一般用来进行资源清理，例如关闭数据库链接。

　　三、@Before和@After在每一个测试方法执行前都会执行一次。

       四、@Test(excepted=XX.class) 在运行时忽略某个异常。

　　五、@Test(timeout=毫秒) 容许程序运行的时间。

　　六、@Ignore 所修饰的方法被测试器忽略。

　　七、@RunWith 能够修改测试运行器 org.junit.runner.Runner

 

3.参数化测试与运行器(Runner)

考虑一种场景，若是要单独测试正数的平方，0的平方以及负数的平方，那么就要建立三个测试方法来进行测试，这样会显得特别繁琐，如步骤4中最后的三个测试方法square1()、square2()和square3()。JUnit考虑到了这种状况，提出了参数化测试方法。这个时候运行器也不是默认的运行器，而是经过@RunWith(Parameterized.class)来标注。

参数化测试代码以下所示;

package dyz.calculatortest;
import static org.junit.Assert.*;
import java.util.Arrays;
import java.util.Collection;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;
import dyz.calculator.Calculator;
@RunWith(Parameterized.class)
public class SquareTest {
    private static Calculator calculator = new Calculator();
    private int param;
    private int result;

    @Parameters
    public static Collection<Object[]> data() {//定义测试数据的集合
        return Arrays.asList(new Object[][] { { 2, 4 }, { 0, 0 }, { -3, 9 }});
    }

    // 构造函数，对变量进行初始化，参数的顺序与数据集成的顺序相关
    public SquareTest(int param, int result) {
        this.param = param;
        this.result = result;
    }

    // 复原操做，代表对每一个Test方法测试之后都会进行这个方法操做。
    @Before
    public void setUp() throws Exception {
        calculator.clear();// 结果清零
    }

    @Test
    public void testSquare() {
        calculator.square(param);
        assertEquals(result, calculator.getResult());
    }
}

具体步骤：

　　一、更改默认的测试运行器为@RunWith(Parameterized.class)。

　　二、声明变量来存放预期值和测试值。

　　三、声明一个返回值为Collection的公共静态方法，并用@Parameters修饰。

　　四、为测试类声明一个带有参数的公共构造函数，并在其中为他声明变量赋值。

 

4.打包测试

考虑另一种场景，若是一个项目中有许多个测试类，一个一个去运行会很是繁琐，这个时候就能够考虑使用打包测试。将全部须要运行的测试类集中起来，一次性的运行完毕，大大的方便了咱们的测试工做。

右键Calculator类，新建一个JUnit Test Suite，以下图所示。

而后选择须要打包测试的测试类，以下图所示：

打包测试类叫作AllTests，须要打包测试的三个测试类是CalculatorTest，SquareTest和test。点击Finish完成打包测试，生成的打包测试类代码以下：

package dyz.calculatortest;

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

@RunWith(Suite.class)
@SuiteClasses({SquareTest.class,CalculatorTest.class,Test.class})
public class AllTests {

}

运行结果以下：

注意事项：

　　一、做为测试套件的入口类，类中不能包含任何方法。

　　二、更改测试运行器Suite.class。

　　三、将须要运行的测试类放入Suite.SuiteClasses({})的数组中。