JUnit自动化单元测试

本文章转载自 博主 _唛唛：https://blog.csdn.net/u012882327/article/details/72642351

JUnit自动化单元测试（一）：生成测试类

第一步：导入Junit4包到项目中。
可以自己到网上下载junit4 jar包，也可以用JDE自带junit测试工具包。以Eclipse为例

第二步，创建测试类。
现有Calcuate类，要测试其加减乘除四个方法，在该类的包点击右键 new other… ，新建JUnit Test Case， 填好各参数下一步，选择要测试的函数完成。




第三步，生成测试类，可以开始测试了。
经过以上步骤，生成测试类如下：

此时我们可以选择JUnit Test工具运行一下：

发现全部方法都是错误，别急，这只是第一步，下面接着讲。

---

JUnit自动化单元测试（二）：简单测试实例讲解

我们现在有了测试类TestCalcuate，默认是这样的

package junit.demo;
import static org.junit.Assert.*;
import org.junit.Test;
public class TestCalcuate {
    @Test
    public void testAdd() {
        fail("Not yet implemented");
    }

    @Test
    public void testSub() {
        fail("Not yet implemented");
    .....

首先注解@Test表示这个方法是需要JUnit测试的方法，fail()函数的意思是测试失败，这就是为什么初始的测试类进行测试每个都会失败，因为方法里面的内容需要由我们自己写。

现在我们简单写一个testAdd

package junit.demo;
import static org.junit.Assert.*;
import org.junit.Test;
public class TestCalcuate {
    @Test
    public void testAdd() {
        Calcuate calcuate = new Calcuate(); //新建对象实例
        int result = calcuate.add(2, 3);    //进行add操作
        assertEquals(5, result);            //通过断言assertEquals看上面得到的结果是不是期望的结果
    }

    @Test
    public void testSub() {
        fail("Not yet implemented");
    .....

很好理解，要测试add方法，先创建对象，然后进行add操作，最后通过assertEquals断言看看得到的结果是不是我们期望的结果，此时再运行JUnit Test会发现testAdd成功，表示这个方法测试成功，和我们期望的一样。

接下来我们写testSub，聪明的人会发现，每个测试方法都要创建对象，一点都不人性，于是，就有了@Before和@After注解，@Before表示每次测试都会先执行一次，一般用于初始化。@After表示每次测试后都会执行一次，一般用于断开IO连接等。

package junit.demo;
import static org.junit.Assert.*;
import org.junit.Test;
import org.junit.Before;
public class TestCalcuate {
    Calcuate calcuate;   //全局变量
    @Before    //每次测试都会执行一次，一般用于初始化，一般取名为setUp
    public void setUp() {
        calcuate=new Calcuate();
    }

    @Test
    public void testAdd() {
        int result = calcuate.add(2, 3);    //进行add操作
        assertEquals(5, result);            //通过断言assertEquals看上面得到的结果是不是期望的结果
    }

    @Test
    public void testSub() {
        assertEquals(3, calcuate.sub(5, 2));  
    }  
    .....

现在testAdd、testSub都已完成了测试，聪明的人又会发现，引用包的时候import static org.junit.Assert.*;是什么？意思是静态导入Assert，我们用到的fail和assertEquals都是Assert的静态方法，静态导入Assert之后，就不需要我们每次开头都写”Assert.”。

---

JUnit自动化单元测试（三）：各常用注解和测试函数详细讲解

@Test：将一个方法修饰成一个可测试的方法；只有@Test修饰之后，这个方法才会被JUnit执行。

@Test（expected=XXException.class）：表示这个方法一定会抛出某个异常；如果没有抛出该异常则测试失败。

    //测试代码
    @Test(expected = ArithmeticException.class)
    public void testDiv() {
        int result = calcuate.div(6, 0); // 除法中，除数为0，抛出ArithmeticException
    }

@Test（(timeout=XX）：表示这个方法执行的超时时间，单位毫秒；如果这个方法在规定时内还没结果，则测试失败。

  //测试代码
    @Test(timeout = 3000)
    public void testTimeout () {
        while (true) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

@Before：会在每一个测试方法被运行前执行一次；一般用于初始化测试数据。注意：有多少个@Test修饰的方法就会执行多少次。

@After：会在每一个测试方法运行后被执行一次；一般用于注销测试数据。注意：有多少个@Test修饰的方法就会执行多少次。

@BeforeClass：它会在所有的方法运行前执行，static修饰；一般用于测试需要读取文件数据时。注意：不管有多少个@Test修饰的方法只执行一次。

@AfterClass：它会在所有的方法运行结束后执行，static修饰；一般用于断开文件连接。注意：不管有多少个@Test修饰的方法只执行一次。

@Ignore：所修饰的测试方法会被测试运行器忽略；当方法还没写完时可用，写好之后删掉@Ignore即可开始测试。

 //测试代码
    @Ignore
    @Test
    public void testIgnore () {
        System.out.println("我会被忽略，不会执行");
    }

@RunWith：可以更改测试运行器 org.junit.runner.Runner；当需要多个或自定义的运行器时用，下一篇具体讲解。

注解大致是就这么多，此外还有一些常用的断言函数：

AssertEquals：断言两个结果相等；
AssertArrayEquals：断言两个数组相等；
AssertNotEquals：断言两个结果不相等；
AssertSame：判断两个对象是否为同一个，不同于equals这里是使用“==”判断；
AssertTrue：断言结果为真；
AssertFalse：断言结果为假；
AssertNull：断言结果为空；
AssertNotNull：断言结果不为空；
AssertThat：使用Matcher做自定义的校验；
如果想了解更多的测试函数，请自行查阅Assert API，这里就不详细说明了。

---

JUnit自动化单元测试（四）：@RunWith测试套件运行器的使用

一些常用的测试方法前面已经说了，但有人又说了，JUnit为项目里每个类都创建一个对应的测试类，虽然一次能把类里面所有的方法都测试一遍，但是，我一个项目有可能有上千百个类，总不能每个类都点一下进行测试吧。
没错，@RunWith注解就是为了这种情况，我们先声明用套件运行器进行测试，然后把需要进行测试的所有类放进套件（集合）里面，一次就可以把所有类所有方法测试完，也叫打包测试。当我们没有声明的时候默认的则是JUnit自带的运行器，一次只能测试一个类。
见代码：

//这里有三个可以放到一起测试的类TaskTest1 、TaskTest2 、TaskTespackage junit.demo;
import org.junit.Test;
public class TaskTest1 {
        @Test
        public void test() {
            System.out.println("this is TaskTest1");
        }
    }

package junit.demo;
import org.junit.Test;
public static class TaskTest2 {
        @Test
        public void test() {
            System.out.println("this is TaskTest2");
        }
    }

package junit.demo;
import org.junit.Test;
public static class TaskTest3 {
        @Test
         {
            System.out.ppuntln("this is TaskTest3");
        }
    }们新建一个套件类，用套件运行器Suite
package junit.demo;
import org.junit.runner.RunWith;
import org.junit.runners.Suite.SuiteClasses;
import org.junit.runners.Suite;

@RunWith(Suite.class) //声明套件运行器
@SuiteClasses({TaskTest1.class,TaskTest2.class,TaskTest3.class}) //将需要一起测试的类放进来
public class SuiteTest {
    /* 
     * 测试套件就是组织测试类一起运行的 
     * 写一个作为测试套件的入口类，这个类里不需要包含其他的方法 
     * 1.更改测试运行器Suite.class 
     * 2.将要测试的类作为数组传入到Suite.SuiteClasses（{}） 
     */
}

接着，我们只测试SuiteTest 这一个类就可以看到全部测试类的测试结果了。
@RunWith最主要是声明测试的运行器，都在org.junit.runners.下面有声明，其他的一般用不到了，有兴趣的朋友可以共同探讨分享。

---

JUnit自动化单元测试（五）：参数化测试

要成为JUnit测试高手必不可少的一项技能就是参数化测试了，现在有一个方法根据不同的参数会有不同的结果，为了测试全面如果把所有可能的情况都逐个写出来测试一遍那未免太low了，此时就可以用参数化测试，举个例子：

package junit.demo;
import static org.junit.Assert.assertEquals;
import java.util.Arrays;
import java.util.List;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

@RunWith(Parameterized.class) //声明参数运行器
public class ParametersTest {
    private int first;
    private int second;
    /* 构造函数需要的参数会自动从参数列表中依次取出 */
    public ParametersTest(int first, int second) {
        this.first = first;
        this.second = second;
    }

    /* 这里就是参数化测试的关键了
     * 通过@Parameters修饰表示该方法是为这次测试提供参数的，默认是构造函数的参数，以集合的形式传入。
     * name属性则是一个名字，稍后解释。
     * 当然最简单的方法就像这样写就行了 */
    @Parameters(name = "{index}: parm({0},{1})")
    public static List<Object[]> data() {
        return Arrays.asList(new Object[][] { { 2, 6 }, { 0, 100 }, { -3, 9 } });
    }

    @Test
    public void test() {
        assertEquals(second, doSome(first));
    }

    /* 假如这个就是我们要测试的方法：
     * 如果参数大于零，则返回参数*3；
     * 如果参数等于零，则返回100；
     * 如果参数小于零，则返回参数*-3   */
    private Object doSome(int first) {
        if (first > 0) {return first * 3;}
        if (first == 0) {return 100;}
        if (first < 0) {return first * -3;}
        return null;
    }
}

OK，这样测试一下会发现三个测试成功结果

没错，Parameterized.class参数运行器相当于把参数列表里面的数据一次取一组进行测试，通过构造函数实例化将参数放进测试中，我的demo里有三组数据，因此会有三个测试结果。
同时细心的朋友会发现，每个测试结果的显示名字… 没错，就是代码里面提到的参数配置name属性：”{index}”表示集合下标，“{0}”表示第一个参数值，“{1}”表示第二个参数值。很好理解吧。

至此，整个JUnit已经讲解了十分之八，最重要还是在实际运用过程中根据据需要进行单元测试，可能在实际开发中很少有公司会正规的进行单元测试，不过身为一个开发者，没有任何的借口阻挡我们不断学习进取的脚步。