在进行单元测试的时候，往往要设计多个用例逐个放入程序中执行并返回结果，如果我们想自动完成循环放入用例的操作就需要自己写循环语句。而Junit4的新特性就可以直接帮你完成循环的操作，你只需要将用例以特定的格式写入即可，这就是参数化测试，但是这存在一个限制，一个测试类只能测试一个方法。
非参数化测试的概念我一直没搜到过，但是根据老师给的实例，大概率就是不使用Junit4的新特性…使用Junit3的标准来实现测试，所以涉及到循环也是自己写的，好处是可以在当前类内为每一个覆盖都单独创建一个测试方法。

JUnit4参数化测试

Junit4可以把你的所有测试用例自动运行一遍，并且自带判断函数（这里叫断言）

idea中自带Junit4，但有个提高效率的插件：JunitGenerater V2.0，这个插件是使用Junit这个工具的工具…可以帮你自动生成测试代码框架，类似于打游戏自动寻路。

操作思路

1、安装插件。
2、写好需要测试的目标函数。
3、通过插件自动生成测试类。
4、将设计好的测试用例填进去，运行。

安装插件

settings -> Plugins 搜索安装，安装完会提示重启idea。

安装完成后需要注意一个配置，默认的template改为Junit4。

测试目标

这里简单看一下我的作业。

使用插件

使用插件的方法就是万能右键 -> Generate… -> Test…
有快捷键 Alt+insert 但是我懒得记。
需要注意的是光标要在函数体范围内右键。

勾选上想要测试的函数名，会自动生成测试函数。
@Before和@After可选，这两个类似于生命周期函数，一个是在test函数执行前必会执行，一个在结束后必会执行。虽然我勾了但不一定用到，看习惯。

三个勾选会生成三个函数，当然你不勾自己手打也是一样的。

完善程序

准备测试数据

测试函数使用的数据来自它所在的测试类，所以要在测试类中定义需要的数据。从我要测试的方法中可以看出来输入为x、y、z三个变量，但是还需要一个期望结果expected让程序判断测试是否通过。

	private int x;
    private int y;
    private int z;
    private int expected;

这些变量的值每过一个测试用例就会变一次，需要一个构造函数来赋值。

	public OriginTest(int x, int y, int z, int expected){
        this.x = x;
        this.y = y;
        this.z = z;
        this.expected = expected;
    }

在一个函数中初始化所有测试用例，这个函数需要org.junit.runners.Parameterized.Parameters的注解、static的修饰、Collection的返回值，其中的数据依次对应构造函数的入参。这里我放入的是语句覆盖的测试用例，比较简短。之后可以手动换成别的覆盖数据，或者考虑通过文件操作从txt获取数据。

	@Parameterized.Parameters
    public static Collection testData(){
        Object[][] object={{0,0,50,0},{12,11,100,24},{4,9,-1,18}};
        return Arrays.asList(object);  // 数组转化为集合
    }

测试函数

调用要测试的函数，然后比较结果是否一致。
assertEquals()用来断言两个值是否相同，当然还存在其他断言函数。

	@org.junit.Test
    public void origin() {
        int result = origin.ori(x, y, z);
        assertEquals(expected, result);
    }

完整代码

import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

import java.util.Arrays;
import java.util.Collection;

import static org.junit.Assert.*;

@RunWith(Parameterized.class)
public class OriginTest {
    private Origin origin;

    private int x;
    private int y;
    private int z;
    private int expected;

    public OriginTest(int x, int y, int z, int expected){
        this.x = x;
        this.y = y;
        this.z = z;
        this.expected = expected;
    }

    @org.junit.Before
    public void setUp() throws Exception {
        origin = new Origin();
    }

    @org.junit.After
    public void tearDown() throws Exception {
    }

    @Parameterized.Parameters
    public static Collection testData(){
        Object[][] object={{0,0,50,0},{12,11,100,24},{4,9,-1,18}};
        return Arrays.asList(object);
    }

    @org.junit.Test
    public void origin() {
        int result = origin.ori(x, y, z);
        assertEquals(expected, result);
    }
}

输出结果

如果没什么问题会每个打个勾，有错的用例会打岔并且输出期望和实际结果。

JUnit3非参数化测试（自动化测试）

我们前面看到的Junit4创建的测试类，你的所有测试用例数据会依次赋值给这个类里声明的私有变量，测试方法也直接使用类内声明变量，没有办法做到在一个类里设计多个函数来执行不同的逻辑覆盖测试。Junit3就比较简陋，除了可以识别测试方法来运行这个单个方法，没什么别的功能了，但就意味着自由度也高。

操作思路

1、创建Junit3测试类
2、在这个测试类为每种覆盖都创建一个测试方法
3、然后想测试哪个覆盖就测试哪个覆盖

创建测试类

同样是右键 -> Generate… -> test…
唯一的不同是将Junit选择为Junit3

创建完成后只是有一个测试类和测试方法，Junit3不使用注解，它通过方法名来判断该方法是否为一个测试函数，所以之后自己创建测试方法名字必须以test开头。

完善程序

基本的参数循环放入逻辑都需要自己写，由于每个覆盖的测试方法只有测试用例不同，我可以将相同的那部分逻辑放到一个方法内实现。实际结果与预期结果的判断可以自己判断也可以使用assert断言函数，但是junit3中的assert如果出现结果不相符返回fasle会出现报错并中止程序，如果希望程序继续运行就需要捕获异常，捕获的异常类型为AssertionError。

完整代码

import junit.framework.TestCase;


public class OriginTest3 extends TestCase {
    private Origin origin;

    public void runTest(int[][] object){
        origin = new Origin();
        for(int i = 0; i < object.length; i++){
            int result = origin.ori(object[i][0], object[i][1], object[i][2]);
            int number = i+1;
            System.out.print("case"+number+": expect:"+object[i][3]+" actual:"+result+" ");
            if (result == object[i][3]) System.out.println("success");else System.out.print("failure ");
            try{
                assertEquals(result, object[i][3]);
            }catch (AssertionError e){
                System.out.println(e.getMessage());
            }
        }
    }

    //语句覆盖
    public void testStatements() {
        int[][] object={{0,0,50,0},{12,11,100,24},{4,9,-1,18}};
        runTest(object);
    }

    //判定覆盖
    public void testDetermine() {
        int[][] object={{0,0,50,0},{12,11,100,24},{24,12,100,24},{4,9,100,18},{3,9,100,9}};
        runTest(object);
    }

    //条件覆盖
    public void testConditions() {
        int[][] object={{0,0,50,0},{1,12,-1,12},{24,12,100,24},{4,9,100,18},{3,9,100,9}};
        runTest(object);
    }

    //判定条件覆盖
    public void testDc() {
        int[][] object={{0,0,50,0},{13,12,-1,26},{24,12,100,24},{4,9,100,18},{3,9,100,9}};
        runTest(object);
    }

    //条件组合覆盖
    public void testCc() {
        int[][] object={{0,0,50,0},{13,12,-1,26},{13,12,100,26},{24,12,100,24},{5,12,100,24},{10,9,100,18},{4,9,100,18}};
        runTest(object);
    }

    //路径覆盖
    public void testPath() {
        int[][] object={{0,0,50,0},{12,11,100,24},{22,11,100,22},{4,9,100,18},{3,9,100,9}};
        runTest(object);
    }

}

参考文献

安装和使用插件：
https://www.csdn.net/tags/NtjaUg5sNzk2MjctYmxvZwO0O0OO0O0O.html
参数化测试：
https://www.cnblogs.com/softidea/p/4155312.html
https://www.cnblogs.com/byron0918/p/4801152.html