Junit 学习笔记

[TOC]

Junit 学习笔记

1. 编写测试用例时需要注意

1. 测试方法上必须使用 @Test 进行修饰
2. 测试方法必须使用 public void 进行修饰，不能带任何参数
3. 新建一个车源代码目录来存放我们的测试代码
4. 测试类的包应该和被测试类保持一致
5. 测试单元中的每个方法必须可以独立测试，测试方向间不能有任何依赖
6. 测试类使用 Test 作为类名的后缀（不是必须）
7. 测试方法使用 Test 作为方法名的前缀（不是必须）

2. 出现结果分析

1. Failure 一般由单元测试使用的断言方法判断失败所引起，这表示测试点发现了问题，就是说程序输出的结果和我们预期的不一样。
2. error 是由代码异常引起的，它可以产生于测试代码本身的错误，也可以是被测试代码中的一个隐藏 bug
3. 测试用例不是用来证明你是对的，而是用来证明你没有错（即测试用例用来达到想要的预期结果，但对于逻辑错误无能为力）。

3. Junit 运行流程

举个例子：

public class JunitFlowTest {

    @BeforeClass
    public static void setUpBeforeClass() throws Exception {
        System.out.println("this is beforeClass...");
    }

    @AfterClass
    public static void tearDownAfterClass() throws Exception {
        System.out.println("this is afterClass...");
    }

    @Before
    public void setUp() throws Exception {
        System.out.println("this is before...");
    }

    @After
    public void tearDown() throws Exception {
        System.out.println("this is after");
    }

    @Test
    public void test1() {
        System.out.println("this is test1...");
    }

}

输出结果如下：

---- IntelliJ IDEA coverage runner ---- 
sampling ...
include patterns:
com\.test\.util\..*
exclude patterns:this is beforeClass...
this is before...
this is test1...
this is after
this is afterClass...

Process finished with exit code 0

解释如下：

1. @BeforeClass 修饰的方法会在所有方法被调用前被执行，而且该方法是静态的，所以当测试类被加载后接着就会运行它，而且在内存中它只回存在一份实例，它比较适合加载配置文件
2. @AfterClass 所修饰的方法通常用来对资源的清理，如关闭数据库的连接
3. @Before 和 @After 会在每个测试方法的前后各执行一次

4. Junit 常用注解

1. @Test：将一个普通的方法修饰成为一个测试方法
   • @Test(expected=XX.class)：用来捕获异常
   • @Test(timeout=毫秒)：到时间后停止测试（用来测试一些循环很久的语句）
2. @BeforeClass：它会在所有的方法运行前被执行，static 修饰
3. @AfterClass：它会在所有的方法运行结束后被执行，static 修饰
4. @Before：会在每一个测试方法被运行前执行一次
5. @After：会在每一个测试方法运行后被执行一次
6. @Ignore：所修饰的测试方法会被测试运行器忽略
7. @RunWith：可以更改测试运行器 org.junit.runner.Runner

举个例子：

public class AnnotationTest {

    @Test(expected = ArithmeticException.class)
    public void testDivide() {
        assertEquals(3, new Calculate().divide(6, 0));
    }

    @Test(timeout = 2000)
    @Ignore
    public void testWhile() {
        while (true) {
            System.out.println("run forever...");
        }
    }

    @Test(timeout = 3000)
    public void testReadFile() {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

5. Junit 测试套件的使用

测试套件就是组织测试类一起运行的。

步骤：

1. 写一个作为测试套件的入口类，这个类里不包含其他的方法
2. 更改测试运行器 Suite.class
3. 将要测试的类作为数组传入到 Suite.SuiteClasses({})

例子：

@RunWith(Suite.class)
@Suite.SuiteClasses({TaskTest1.class, TaskTest2.class, TaskTest3.class})
public class SuiteClasses {
}

6. Junit 参数化设置

步骤

1. 更多默认的测试运行器为 RunWith(Parameterized.class)
2. 声明变量来存放预期值和结果值
3. 声明一个返回值为 Collection 的公共静态方法，并使用 @Parameters 进行修饰
4. 为测试类声明一个带有参数的公共构造函数，并在其中为之声明变量赋值

例子

ParameterTest.java：

@RunWith(Parameterized.class)
public class ParameterTest {

    int expected = 0;
    int input1 = 0;
    int input2 = 0;

    @Parameterized.Parameters
    public static Collection t() {
        return Arrays.asList(new Object[][] {
                {3, 1, 2},
                {4, 2, 2}
        });
    }

    public ParameterTest(int expected, int input1, int input2) {
        this.expected = expected;
        this.input1 = input1;
        this.input2 = input2;
    }

    @Test
    public void add() {
        assertEquals(expected, new Calculate().add(input1, input2));
    }
}