随笔 - 151 文章 - 0 评论 - 117 阅读 - 108万

JUint4的下载、配置及对一个算法编写单元测试用例（测试多组数据每组多个参数）

一、JUnit4 jar包下载

链接：https://pan.baidu.com/s/1AdeVGGikcY5dfL151ZnWHA
提取码：h1am

下载完成后，解压一下即可。

二、导入JUnit4 jar包

1.打开eclipse，右击你要进行单元测试的类所在的java项目，选择“Properties”选项

2.在弹出的对话框中选择“Java Build Path”----->"Add Library" 选项，进行构建JUnit4路径

3.在弹出的“Add Library”对话框中选择“JUnit”选项，单击“Next”按钮，在下拉列表中选择“JUnit4”，点击“Finish”，完成添加

4.添加完成后，单击“Apply”，应用变更，单击“OK”按钮，JUnit4构建成功，即可以使用JUnit4框架进行单元测试。

三、用JUnit4对一个算法题编写测试用例，进行测试。

1.首先来看这个算法题：

这个算法题有几个条件：

（1）要从起始点走到终点结束

（2）这个线段上的所有的点都要走一遍，但是每个点只能经过一次，

（3）在任何位置都可以用0次或多次技能跳到第一个点和第N个点（最后一个点）以达到以上两个条件

（4）三个值的范围是[1,10000] 且1<=S,T<=N

（5）用任何走法都不能达到目的则输出-1

（6）输入的参数是0或负数的时候，输出-1

（7）输入的终点T大于总点数S的时候，输出-1

（8）当N=S=T>1的时候，想要到达终点，终点所在的这个点始终要经过两遍，所以永远无法满足条件，则输出-1

（9）当N=S=T=1的时候，不用走，直接到终点，需要发动0次技能

（10）当S=1,T=N的时候，从第一个点走到最后一个点即可，也不用发动技能，所以是0次

（11）当S=1,T<N的时候，需要发动一次一次技能

（12）当终点在起始点的右侧相邻点（即T-S=1）的时候,需要发动一次技能

（13）当起始点大于1（S>1）,终点小于N（T<N）的时候，也是只需发动一次技能

　　图同上，但两个判定条件不一样，一个是起始点和终点相邻，一个是起始点和终点在第一个点和最后一个点中间

（14）当起始点大于1（S>1）,终点为N（T=N）的时候，需要发动两次技能才能到达终点

根据以上分析，编写Java代码如下：

import java.util.Scanner;
public class Main66 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String nn = sc.next();
        String ss = sc.next();
        String tt = sc.next();
        new Main66().count(nn,ss,tt);
    }
    private static int count = -1;
    public int count(String nn,String ss,String tt){
        //判断输入的是否是非数字
        boolean nIsNum = nn.matches("^(\\d{1,4}|10000)$");
        boolean sIsNum = ss.matches("^(\\d{1,4}|10000)$");
        boolean tIsNum = tt.matches("^(\\d{1,4}|10000)$");

        if(nIsNum && sIsNum && tIsNum){

            int n = Integer.parseInt(nn);
            int s = Integer.parseInt(ss);
            int t = Integer.parseInt(tt);

            /*
             * 
             * n<1 || s<1 || t<1 :判断负值和0值
             * s==t && n!=s：        判断起始点和终点重合，并且总点数N>1（即永远无法到达终点）
             * s>n || t>n：           判断起始点和终点对总点数n的越界
             * s>t：                       起始点是否大于终点
             * */
            if(n<1 || s<1 || t<1  || (s==t && n!=1) || s>n || t>n || s>t){
                count  = -1;
            }else{
                if(s==t && n==s && n==1){
                    count = 0;
                }else if(s==1 && t==n){
                    count = 0;
                }else if(s==1 && t<n){
                    count = 1;
                }else  if(t-n==1){
                    count = 1;
                }else if(s>1 && t<n ){
                    count = 1;
                }else if(s>1 && t==n){
                    count = 2;
                }
            }
        }
        System.out.println(count);
        return count;
    }
}

2.创建测试类，编写测试用例并执行

（1）右击“Main66”这个类，选择“New”---->"JUnit Text Case"

（2）在打开的“New JUnit Test Case”对话框中，项目路径，包名，要测试的类都是默认填好且正确的，检查无误，测试类的类名可以按照默认的“Main66Test”，也可以自己进行设置，

设置完成后，单击“Finish”按钮

（3）"Main66"的测试类就创建成功了

（4）根据上述编写算法题时列出的条件，一次性进行多组数据，每组数据多个参数的测试，以下是我写的对于这个算法题的测试用例

import static org.junit.Assert.*;
import java.util.Arrays;
import java.util.Collection;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

//1、更改默认的测试运行器为@RunWith(Parameterized.class)
@RunWith(Parameterized.class)
public class Main66Test {
    //2、声明变量定义预期值和初始值
    int expected = 0;//预期值
    String input1 = "";//输入值1
    String input2 = "";//输入值2
    String input3 = "";//输入值3

    //3、声明一个返回值为Collection的公共静态方法，并使用@Parameters进行修改
    @Parameters
    public static Collection<Object[]> t(){
        return Arrays.asList(new Object[][]{
            //汉字测试
            {-1,"输入","2","2"},
            {-1,"2","阿尔戈","2"},
            {-1,"2","2","热"},

            //字母测试
            {-1,"a","2","2"},
            {-1,"2","a","2"},
            {-1,"2","2","w"},

            //字符测试
            {-1,"@","2","2"},
            {-1,"2",".","2"},
            {-1,"2","2","'"},

            //边界值测试
            {-1,"10001","2","2"},
            {-1,"2","10001","2"},
            {-1,"2","2","10001"},
            {-1,"10000","2","2"},
            {-1,"2","10000","2"},
            {-1,"2","2","10000"},
            {-1,"9999","2","2"},
            {-1,"2","9999","2"},
            {-1,"2","2","9999"},

            //大数测试
            {-1,"2222222222222222222222","2","2"},
            {-1,"2","22222222222222222222222222","2"},
            {-1,"2","2","222222222222222222222222222222222"},



            //空格测试
            {-1,"   ","2","2"},
            {-1,"2"," ","2"},
            {-1,"2","2"," "},

            //tab测试
            {-1,"    ","2","2"},
            {-1,"2","    ","2"},
            {-1,"2","2","    "},

            //负值测试
            {-1,"-1","2","2"},
            {-1,"2","-1","2"},
            {-1,"2","2","-1"},

            //0值测试
            {-1,"0","2","2"},
            {-1,"2","0","2"},
            {-1,"2","2","0"},

            //起点和终点重合，但总点数不为1
            {-1,"6","6","6"},
            {-1,"6","1","1"},

            //越界测试
            {-1,"1","2","1"},
            {-1,"1","1","2"},
            {-1,"1","2","2"},

            {-1,"6","6","2"},
            {-1,"6","3","2"},

            //判定覆盖和条件覆盖
            {2,"6","2","6"},
            {0,"6","1","6"},
            {1,"6","1","5"},
            {0,"1","1","1"},            
            {1,"6","2","3"},                
            {1,"6","2","4"},
            {1,"6","1","2"},                
        });
    }

    //4、为测试类声明一个带有参数的公共构造方法，并在其中为变量赋值
    public Main66Test(int expected,String input1,String input2,String input3){
        this.expected = expected;
        this.input1 = input1;
        this.input2 = input2;
        this.input3 = input3;
    }

    //5.执行测试方法
    @Test
    public void testCount() {
        assertEquals(expected,new Main66().count(input1,input2,input3));
    }
}