JUnit4单元测试学习笔记

注意事项：

1. 测试方法上必须使用@Test修饰
2. 测试方法必须使用public void进行修饰，不能带任何参数
3. 新建一个源代码目录存放测试代码
4. 测试类的包应该和被测试类的包保持一致
5. 测试单元中的每个方法必须可以独立测试，互相之间不能有依赖关系
6. 测试类使用（类型+Test）作为测试类名（不是必须，但最好养成这个习惯）
7. 测试方法使用test作为方法名的前缀（不是必须，但最好养成这个习惯）

IDE version：IntelliJ IDEA 15.0.6
JUnit version：4.10

一、JUnit快速入门

1. 项目结构：

   
   Paste_Image.png
2. Calculate.java

package com.amber.junittest;
/**
 * Created by amber on 2017/6/13.
 */
public class Calculate {
    public int add(int a, int b) {
        return a + b;
    }
    public int subtract(int a, int b) {
        return a - b;
    }
  public int multiply(int a, int b) {
        return a * b;
    }
  public int divide(int a, int b) {
        return a / b;
    }
}

3. 在Calculate类页面，使用右键或者快捷键Shift+Alt+T，弹出下图：

   
   Paste_Image.png
   Paste_Image.png
   Paste_Image.png
   

   就会生成CalculateTest.java测试类：

package com.amber.junittest;
import org.junit.Assert;
import org.junit.Test;
import static org.junit.Assert.*;
/**
 * Created by amber on 2017/6/13.
 */
public class CalculateTest {
    @Test
    public void testAdd() throws Exception {
        Assert.assertEquals(5, new Calculate().add(2, 3));
    }
    @Test
    public void testSubtract() throws Exception {
        Assert.assertEquals(5, new Calculate().subtract(2, 3));
    }
  @Test
    public void testMultiply() throws Exception {
        Assert.assertEquals(5, new Calculate().multiply(2, 3));
    }
    @Test
    public void testDivide() throws Exception {
        Assert.assertEquals(5, new Calculate().divide(2, 3));
    }
}

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

如下图所示：橙色感叹号代表是Failure、红色代表是error、绿色代表success。

Paste_Image.png

全部正确，都是绿色的，看着真舒服~

Paste_Image.png

二、JUnit运行流程

1. 再生成一个测试类，这回多选两个选项，会在测试类中生成一个带注解@Before的方法和@After的方法。

   
   Paste_Image.png
2. 在测试类中添加注解@BeforeClass和 @AfterClass的方法：

package com.amber.junittest;
import org.junit.*;
import static org.junit.Assert.*;
/**
 * Created by amber on 2017/6/13.
 */
public class CalculateTest2 {
    @BeforeClass
    public static void setUpBeforeClass() {
        System.out.println("this is BeforeClass...");
    }
    @Before
    public void setUp() throws Exception {
        System.out.println("\nthis is Before...");
    }
    @After
    public void tearDown() throws Exception {
        System.out.println("this is After...");
    }
    @AfterClass
    public static void setTearDownAfterClass() {
        System.out.println("this is AfterClass...");
    }
    @Test
    public void test1(){
        System.out.println("this is Test1...");
    }
 @Test
    public void test2(){
        System.out.println("this is Test2...");
    }
}

3. 执行测试后，结果为：

this is BeforeClass...
this is Before...
this is Test1...
this is After...
this is Before...
this is Test2...
this is After...
this is AfterClass...

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

三、JUnit常用注解

我们大致的五个注解已经有了解了，下面再深入了解@Test测试注解还有什么小技能。

1. @Test(expected = xxx.class)这是可以捕获预期会遇到的异常的一个待参数注解，只要正确的预期到会出现的异常，那么测试运行就不会报错了。

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

因为0不能做除数，所以肯定会出现一个ArithmeticException，我们通过@Test(expected = ArithmeticException.class)正确的捕获了异常，运行结果当然是success！

Paste_Image.png

2. @Test(timeout = 毫秒)，这个参数见名知其意，如果方法执行时间小于超时限定时间，则success。反之，则会强行停止方法运行，并报出failure。
   看第一个例子，设置个死循环，设置超时100毫秒。

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

结果如图，因为是死循环，所以肯定会超时，100毫秒后，方法被强行停止。

Paste_Image.png

看第二个例子，让当前线程沉睡100毫秒，超时时间是1秒。

  @Test(timeout = 1000)
    public void testTimeout() {
        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

结果：

Paste_Image.png

3. @Ignore注解所修饰的方法会被测试运行器忽略。(太简单了，不做测试了)
4. @RunWith注解可以更改测试运行器。只要类继承org.junit.runner.Runner。（这个后面会详解）
5. junit断言参考帮助文档：http://junit.org/junit4/javadoc/latest/

四、JUnit测试套件的使用

测试套件就是可以一次性批量执行测试的一个类。下面开始编写：

1. 在test包下新建SuiteTest类，并使用@RunWith(Suite.class)注解更改测试运行器为Suite.class，使用@Suite.SuiteClasses(数组)将测试类添加到数组：

package com.amber.junittest;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
/**
 * Created by amber on 2017/6/13.
 */
@RunWith(Suite.class)
@Suite.SuiteClasses(value = {TaskTest1.class,TaskTest2.class,TaskTest3.class,TaskTest4.class})
public class SuiteTest {
}

运行：

Paste_Image.png
Paste_Image.png
总结：

1. 测试套件就是组织测试类一起运行的。
2. 新建一个测试套件的入口类，这个类中不能包含其他的方法。
3. 使用@RunWith(Suite.class)更改测试运行器为Suite.class。
4. 将要测试的类作为数组传到@Suite.SuiteClasses({})。

五、JUnit的参数化设置

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

package com.amber.junittest;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import java.util.Arrays;
import java.util.Collection;
/**
 * Created by amber on 2017/6/13.
 */
@RunWith(Parameterized.class)
public class ParameterTest {
    int expected = 0;
    int input1 = 0;
    int input2 = 0;
    @Parameterized.Parameters
    public static Collection<Object[]> t() {
        return Arrays.asList(new Object[][]{
                        {3, 1, 2},
                        {4, 1, 3}
                }
        );
    }
   public ParameterTest(int expected,int input1,int input2){
        this.expected=expected;
        this.input1=input1;
        this.input2=input2;
    }
   @Test
    public void testAdd(){
        Assert.assertEquals(expected,new Calculate().add(input1,input2));
    }
}