(第四周)四则运算单元测试

项目成员:黄兴、谢孝淼

程序代码

因为此前的程序只有一个主函数main(),为了做单元测试,把代码进行了一些修改,把源代码分到了几个方法里。

1、生成题目并计算的addQuestion()方法,其中把随机数和随机运算符都设成了固定值,这样是为了更容易的进行单元测试,除了这个方式,还没有想好怎样对随机数的方法进行测试。

   Scanner sc = new Scanner(System.in);   //创建Scanner类的对象
    double result=0;
    int right=0;                           //统计正确题目的数量
    public double addQuestion(){
//      Random r = new Random();       //生成一个100以内随机数的方法
//      int a = r.nextInt(100);
//      int b = r.nextInt(100);
//      int c = r.nextInt(100);
//      int d = r.nextInt(100);
        int a = 1;
        int b = 2;
        int c = 3;
        int d = 4;
//      Random r2 = new Random();
//      int i = r2.nextInt(3) + 1;             //另一个生成随机数1~4的方法
//      int j = r2.nextInt(3) + 1;               //另一个生成随机数1~4的方法
//      int k = r2.nextInt(3) + 1;               //另一个生成随机数1~4的方法
        int i = 1;
        int j = 2;
        int k = 3;
        char chrs[] = { ‘.‘,‘+‘, ‘-‘, ‘*‘, ‘/‘ };  //将运算符号存到数组里
        String.valueOf(chrs[i]);
        String.valueOf(chrs[j]);
        String.valueOf(chrs[k]);
        //用switch,case对三个运算符进行判断,方法比较笨,列出了全部64种情况
        switch(i){
            case 1:{
                    switch(j){
                        case 1:{
                                switch(k){
                                    case 1:System.out.println(a+"+"+b+"+"+c+"+"+d+"=?");
                                            result=a+b+c+d;
                                            break;
                                    case 2:System.out.println(a+"+"+b+"+"+c+"-"+d+"=?");
                                            result=a+b+c-d;
                                            break;
                                    case 3:System.out.println(a+"+"+b+"+"+c+"*"+d+"=?");
                                            result=a+b+c*d;
                                            break;
                                    case 4:System.out.println(a+"+"+b+"+"+c+"/"+d+"=?");
                                            float f = c;
                                            float g = d;
                                            if(g!=0){
                                                result =a+b+f/g;
                                            }
                                            break;
                                }
                        }
                        break;
                        case 2:{
                                switch(k){
                                    case 1:System.out.println(a+"+"+b+"-"+c+"+"+d+"=?");
                                            result=a+b-c+d;
                                            break;
                                    case 2:System.out.println(a+"+"+b+"-"+c+"-"+d+"=?");
                                            result=a+b-c-d;
                                            break;
                                    case 3:System.out.println(a+"+"+b+"-"+c+"*"+d+"=?");
                                            result=a+b-c*d;
                                            break;
                                    case 4:System.out.println(a+"+"+b+"-"+c+"/"+d+"=?");
                                            float f = c;
                                            float g = d;
                                            if(g!=0){
                                                result =a+b-f/g;
                                            }
                                            break;
                                }
                        }
                        break;
                        case 3:{
                                switch(k){
                                    case 1:System.out.println(a+"+"+b+"*"+c+"+"+d+"=?");
                                            result=a+b*c+d;
                                            break;
                                    case 2:System.out.println(a+"+"+b+"*"+c+"-"+d+"=?");
                                            result=a+b*c-d;
                                            break;
                                    case 3:System.out.println(a+"+"+b+"*"+c+"*"+d+"=?");
                                            result=a+b*c*d;
                                            break;
                                    case 4:System.out.println(a+"+"+b+"*"+c+"/"+d+"=?");
                                            float f = c;
                                            float g = d;
                                            if(g!=0){
                                                result =a+b*f/g;
                                            }
                                            break;
                                }
                        }
                        break;
                        case 4:{
                                switch(k){
                                    case 1:System.out.println(a+"+"+b+"/"+c+"+"+d+"=?");
                                            float f1 = b;
                                            float g1 = c;
                                            if(g1!=0){
                                                result =a+f1/g1+d;
                                            }
                                            break;
                                    case 2:System.out.println(a+"+"+b+"/"+c+"-"+d+"=?");
                                            float f2 = b;
                                            float g2 = c;
                                            if(g2!=0){
                                                result =a+f2/g2-d;
                                            }
                                            break;
                                    case 3:System.out.println(a+"+"+b+"/"+c+"*"+d+"=?");
                                            float f3 = b;
                                            float g3 = c;
                                            if(g3!=0){
                                                result =a+f3/g3*d;
                                            }
                                            break;
                                    case 4:System.out.println(a+"+"+b+"/"+c+"/"+d+"=?");
                                            float f4 = b;
                                            float g4 = c;
                                            float p4 = d;
                                            if(g4!=0 && p4!=0){
                                                result =a+f4/g4/p4;
                                            }
                                            break;
                                }
                        }
                        break;
                    }
            }
            break;
            case 2:{
                    switch(j){
                        case 1:{
                                switch(k){
                                    case 1:System.out.println(a+"-"+b+"+"+c+"+"+d+"=?");
                                            result=a-b+c+d;
                                            break;
                                    case 2:System.out.println(a+"-"+b+"+"+c+"-"+d+"=?");
                                            result=a-b+c-d;
                                            break;
                                    case 3:System.out.println(a+"-"+b+"+"+c+"*"+d+"=?");
                                            result=a-b+c*d;
                                            break;
                                    case 4:System.out.println(a+"-"+b+"+"+c+"/"+d+"=?");
                                            float f = c;
                                            float g = d;
                                            if(g!=0){
                                                result =a-b+f/g;
                                            }
                                            break;
                                }
                        }
                        break;
                        case 2:{
                                switch(k){
                                    case 1:System.out.println(a+"-"+b+"-"+c+"+"+d+"=?");
                                            result=a-b-c+d;
                                            break;
                                    case 2:System.out.println(a+"-"+b+"-"+c+"-"+d+"=?");
                                            result=a-b-c-d;
                                            break;
                                    case 3:System.out.println(a+"-"+b+"-"+c+"*"+d+"=?");
                                            result=a-b-c*d;
                                            break;
                                    case 4:System.out.println(a+"-"+b+"-"+c+"/"+d+"=?");
                                            float f = c;
                                            float g = d;
                                            if(g!=0){
                                                result =a-b-f/g;
                                            }
                                            break;
                                }
                        }
                        break;
                        case 3:{
                            switch(k){
                                    case 1:System.out.println(a+"-"+b+"*"+c+"+"+d+"=?");
                                            result=a-b*c+d;
                                            break;
                                    case 2:System.out.println(a+"-"+b+"*"+c+"-"+d+"=?");
                                            result=a-b*c-d;
                                            break;
                                    case 3:System.out.println(a+"-"+b+"*"+c+"*"+d+"=?");
                                            result=a-b*c*d;
                                            break;
                                    case 4:System.out.println(a+"-"+b+"*"+c+"/"+d+"=?");
                                            float f = c;
                                            float g = d;
                                            if(g!=0){
                                                result =a-b*f/g;
                                            }
                                            break;
                            }
                        }
                        break;
                        case 4:{
                            switch(k){
                                    case 1:System.out.println(a+"-"+b+"/"+c+"+"+d+"=?");
                                            float f1 = b;
                                            float g1 = c;
                                            if(g1!=0){
                                                result =a-f1/g1+d;
                                            }
                                            break;
                                    case 2:System.out.println(a+"-"+b+"/"+c+"-"+d+"=?");
                                            float f2 = b;
                                            float g2 = c;
                                            if(g2!=0){
                                                result =a-f2/g2-d;
                                            }
                                            break;
                                    case 3:System.out.println(a+"-"+b+"/"+c+"*"+d+"=?");
                                            float f3 = b;
                                            float g3 = c;
                                            if(g3!=0){
                                                result =a-f3/g3*d;
                                            }
                                            break;
                                    case 4:System.out.println(a+"-"+b+"/"+c+"/"+d+"=?");
                                            float f4 = b;
                                            float g4 = c;
                                            float p4 = d;
                                            if(g4!=0 && p4!=0){
                                                result =a-f4/g4/p4;
                                            }
                                            break;
                            }
                        }
                        break;
                    }
            }
            break;
            case 3:{
                    switch(j){
                        case 1:{
                                switch(k){
                                    case 1:System.out.println(a+"*"+b+"+"+c+"+"+d+"=?");
                                            result=a*b+c+d;
                                            break;
                                    case 2:System.out.println(a+"*"+b+"+"+c+"-"+d+"=?");
                                            result=a*b+c-d;
                                            break;
                                    case 3:System.out.println(a+"*"+b+"+"+c+"*"+d+"=?");
                                            result=a*b+c*d;
                                        break;
                                    case 4:System.out.println(a+"*"+b+"+"+c+"/"+d+"=?");
                                            float f = c;
                                            float g = d;
                                            if(g!=0){
                                                result =a*b+f/g;
                                            }
                                            break;
                                }
                        }
                        break;
                        case 2:{
                                switch(k){
                                    case 1:System.out.println(a+"*"+b+"-"+c+"+"+d+"=?");
                                            result=a*b-c+d;
                                            break;
                                    case 2:System.out.println(a+"*"+b+"-"+c+"-"+d+"=?");
                                            result=a*b-c-d;
                                            break;
                                    case 3:System.out.println(a+"*"+b+"-"+c+"*"+d+"=?");
                                            result=a*b-c*d;
                                            break;
                                    case 4:System.out.println(a+"*"+b+"-"+c+"/"+d+"=?");
                                            float f = c;
                                            float g = d;
                                            if(g!=0){
                                                result =a*b-f/g;
                                            }
                                            break;
                                }
                        }
                        break;
                        case 3:{
                                switch(k){
                                    case 1:System.out.println(a+"*"+b+"*"+c+"+"+d+"=?");
                                            result=a*b*c+d;
                                            break;
                                    case 2:System.out.println(a+"*"+b+"*"+c+"-"+d+"=?");
                                            result=a*b*c-d;
                                            break;
                                    case 3:System.out.println(a+"*"+b+"*"+c+"*"+d+"=?");
                                            result=a*b*c*d;
                                            break;
                                    case 4:System.out.println(a+"*"+b+"*"+c+"/"+d+"=?");
                                            float f = c;
                                            float g = d;
                                            if(g!=0){
                                                result =a*b*f/g;
                                            }
                                            break;
                                }
                        }
                        break;
                        case 4:{
                                switch(k){
                                    case 1:System.out.println(a+"*"+b+"/"+c+"+"+d+"=?");
                                            float f1 = b;
                                            float g1 = c;
                                            if(g1!=0){
                                                result =a*f1/g1+d;
                                            }
                                            break;
                                    case 2:System.out.println(a+"*"+b+"/"+c+"-"+d+"=?");
                                            float f2 = b;
                                            float g2 = c;
                                            if(g2!=0){
                                                result =a*f2/g2-d;
                                            }
                                            break;
                                    case 3:System.out.println(a+"*"+b+"/"+c+"*"+d+"=?");
                                        float f3 = b;
                                        float g3 = c;
                                        if(g3!=0){
                                            result =a*f3/g3*d;
                                        }
                                        break;
                                    case 4:System.out.println(a+"*"+b+"/"+c+"/"+d+"=?");
                                            float f4 = b;
                                            float g4 = c;
                                            float p4 = d;
                                            if(g4!=0 && p4!=0){
                                                result =a*f4/g4/p4;
                                            }
                                            break;
                                }
                        }
                        break;
                    }
            }
            break;
            case 4:{
                    switch(j){
                        case 1:{
                                switch(k){
                                    case 1:System.out.println(a+"/"+b+"+"+c+"+"+d+"=?");
                                            float f1 = a;
                                            float g1 = b;
                                            if(g1!=0){
                                                result =f1/g1+c+d;
                                            }
                                            break;
                                    case 2:System.out.println(a+"/"+b+"+"+c+"-"+d+"=?");
                                            float f2 = a;
                                            float g2 = b;
                                            if(g2!=0){
                                                result =f2/g2+c-d;
                                            }
                                            break;
                                    case 3:System.out.println(a+"/"+b+"+"+c+"*"+d+"=?");
                                            float f3 = a;
                                            float g3 = b;
                                            if(g3!=0){
                                                result =f3/g3+c*d;
                                            }
                                            break;
                                    case 4:System.out.println(a+"/"+b+"+"+c+"/"+d+"=?");
                                            float f4 = a;
                                            float g4 = b;
                                            float p4 = c;
                                            float q4 = d;
                                            if(g4!=0 && q4!=0){
                                                result =f4/g4+p4/q4;
                                            }
                                            break;
                                }
                        }
                        break;
                        case 2:{
                                switch(k){
                                    case 1:System.out.println(a+"/"+b+"-"+c+"+"+d+"=?");
                                            float f1 = a;
                                            float g1 = b;
                                            if(g1!=0){
                                                result =f1/g1-c+d;
                                            }
                                            break;
                                    case 2:System.out.println(a+"/"+b+"-"+c+"-"+d+"=?");
                                            float f2 = a;
                                            float g2 = b;
                                            if(g2!=0){
                                                result =f2/g2-c-d;
                                            }
                                            break;
                                    case 3:System.out.println(a+"/"+b+"-"+c+"*"+d+"=?");
                                            float f3 = a;
                                            float g3 = b;
                                            if(g3!=0){
                                                result =f3/g3-c*d;
                                            }
                                            break;
                                    case 4:System.out.println(a+"/"+b+"-"+c+"/"+d+"=?");
                                            float f4 = a;
                                            float g4 = b;
                                            float p4 = c;
                                            float q4 = d;
                                            if(g4!=0 && q4!=0){
                                                result =f4/g4-p4/q4;
                                            }
                                            break;
                                }
                        }
                        break;
                        case 3:{
                                switch(k){
                                    case 1:System.out.println(a+"/"+b+"*"+c+"+"+d+"=?");
                                            float f1 = a;
                                            float g1 = b;
                                            if(g1!=0){
                                                result =f1/g1*c+d;
                                            }
                                            break;
                                    case 2:System.out.println(a+"/"+b+"*"+c+"-"+d+"=?");
                                            float f2 = a;
                                            float g2 = b;
                                            if(g2!=0){
                                                result =f2/g2*c-d;
                                            }
                                            break;
                                    case 3:System.out.println(a+"/"+b+"*"+c+"*"+d+"=?");
                                            float f3 = a;
                                            float g3 = b;
                                            if(g3!=0){
                                                result =f3/g3*c*d;
                                            }
                                            break;
                                    case 4:System.out.println(a+"/"+b+"*"+c+"/"+d+"=?");
                                            float f4 = a;
                                            float g4 = b;
                                            float p4 = c;
                                            float q4 = d;
                                            if(g4!=0 && q4!=0){
                                                result =f4/g4*p4/q4;
                                            }
                                            break;
                                }
                        }
                        break;
                        case 4:{
                                switch(k){
                                    case 1:System.out.println(a+"/"+b+"/"+c+"+"+d+"=?");
                                            float f1 = a;
                                            float g1 = b;
                                            float p1 = c;
                                            if(g1!=0 && p1!=0){
                                                result =f1/g1/p1+d;
                                            }
                                            break;
                                    case 2:System.out.println(a+"/"+b+"/"+c+"-"+d+"=?");
                                            float f2 = a;
                                            float g2 = b;
                                            float p2 = c;
                                            if(g2!=0 && p2!=0){
                                                result =f2/g2/p2-d;
                                            }
                                            break;
                                    case 3:System.out.println(a+"/"+b+"/"+c+"*"+d+"=?");
                                            float f3 = a;
                                            float g3 = b;
                                            float p3 = c;
                                            if(g3!=0 && p3!=0){
                                                result =f3/g3/p3*d;
                                            }
                                            break;
                                    case 4:System.out.println(a+"/"+b+"+"+c+"/"+d+"=?");
                                            float f4 = a;
                                            float g4 = b;
                                            float p4 = c;
                                            float q4 = d;
                                            if(g4!=0 && p4!=0 && q4!=0){
                                                result =f4/g4/p4/q4;
                                            }
                                            break;
                                }
                        }
                        break;
                    }
            }
            break;
        }
        return result;
    }

2、建立calculate()方法,确定生成题目的数量,并对结果进行判断,统计答对的题目数

   public void calculate(){
        int h = sc.nextInt();                  //题目数量
        for(int m=0;m<h;m++){               //for循环用来生成指定数量的题目
            double result = addQuestion();
            float jg = sc.nextFloat();                  //将自算结果赋给jg
            if(jg==result){                             //用if,else对结果进行判断,正确则继续,若错误则显示正确答案,然后继续
                System.out.println("答对了,你真是个天才!");
                right++;
            }else{
                System.out.println("结果错误!");
                System.out.println("再想想吧,答案似乎是:"+result+"喔!");
                }
        }
        System.out.println("你一共答对"+right+"道题,"+"共"+h+"道题。");
    }

3、建立choose()方法,选择是否继续答题或结束答题

   public void choose(){
        System.out.println("1.开始下一轮\t2.结束答题");
        Scanner select = new Scanner(System.in);
        int se = select.nextInt();
        switch(se){                                 //两层switch,case判断,
        case 1:main(null);                          //如果两次选择均输入错误,则结束程序
                break;
        case 2:System.out.println("答题结束!");
                break;
        default:System.out.println("输入有误,请重新输入!");
                System.out.println("1.开始下一轮\t2.结束答题");
                Scanner rp = new Scanner(System.in);
                int rt = rp.nextInt();
                switch(rt){
                case 1:main(null);
                        break;
                case 2:System.out.println("答题结束!");
                        break;
                default:System.out.println("连续两次输入错误,答题结束!");
                }
        }
    }

4、main(),调用其它方法

   public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("*******随机四则运算*******");
        System.out.println("请输入题目数量:");
        one js = new one();
        js.calculate();
        js.choose();

    }

测试用例

对addQuestion()方法进行测试。上面也说了,为了方便测试,将随机数和随机符号进行了固定。这样结果我们是知道的,如果我们的希望就是这个结果,那么就会成功通过测试,如果换个数,就不会通过测试。

成功情况:其它都是已知的,所以期望为-9。

  @Test
    public void testAddQuestion() {
        szys3 ys = new szys3();
        double expected = -9;
        assertEquals(expected,ys.addQuestion(),1);
    }

测试通过:

失败情况:期望改为-7,不是正确答案

  @Test
    public void testAddQuestion() {
        szys3 ys = new szys3();
        double expected = -7;
        assertEquals(expected,ys.addQuestion(),1);
    }

测试结果:

HTTP:https://git.coding.net/yanzouzhe/szys.git

SSH:[email protected]:yanzouzhe/szys.git

照片:保密

体会:要求就理解到这种程度,对于我们这种水平很低的人来说,做测试还是非常费劲的。

时间: 2024-08-07 21:20:42

(第四周)四则运算单元测试的相关文章

四则运算单元测试

对于四则运算中的单元测试以两个不同功能的函数为示例展示.仍然采用JUnit4的单元测试框架 下面展示的是没有括号和分数情况下的计算函数 doCalculation的代码片段 // 对生成的4则运算进行计算 public static Double doCalculation(String formula) { ArrayList<Double> numList = new ArrayList<Double>();// 存储运算数 ArrayList<String> op

【week3】四则运算 单元测试

上一周的四则运算有bug,这次补充正确代码: 1 // 中缀转后缀 2 public String[] SolveOrder(String[] in, HashMap<String, Integer> precedence) { 3 // 符合逆波兰式(后缀)的输出 4 int kk=in.length; 5 String out[] = new String[kk]; 6 int p = 0 ; 7 // 操作符 8 Stack<String> ops = new Stack&l

第四周作业 单元测试

github地址:  PSP表格 接口的实现 由于我是负责主函数类(包含输入模块)这部分的,因此没有负责相关接口的编写,在此简要的说明一下主函数的构成. 首先是导入java相关包,方便后面写代码时函数调用 主函数:含有一个字符串数组参数,创建一个String变量com保存主函数参数(即将其拼接成一个字符串,串与串之间用空格分开),然后创建一个String变量保存正则表达式,接下来调用Pattern包中的matches函数进行正则表达式匹配. 将匹配结果保存在布尔变量isMatch中,最后根据is

四则运算——单元测试(测试方法:Right-BICEP )

一.测试的具体部位 Right-结果是否正确? B-是否所有的边界条件都是正确的? I-能查一下反向关联吗? C-能用其他手段交叉检查一下结果吗? E-你是否可以强制错误条件发生? P-是否满足性能要求? 二.测试结果 1.结果正确 2.边界条件 由上图可知,结果正确,但对于输入0值可以进行改进,让其直接不进行下列判断 3.一致性 数值范围大时,无余数的式子出现概率少 4.区间性 本程序,取值范围设置为int型,所以出题数目和出题数值都可以设很大 5.存在性 数值范围为0,产生未处理异常,此处程

四则运算—单元测试

思路:编写的程序只有一个主函数,并且每个要求的实现方式都是一层层嵌套的,也都是使用同样的方法,先用while对不符合的输入进行提示,再用if...else...分支结构选择.所以则以(是否有乘除法—是否是否有负数—数值范围—打印方式—输出题目)为单元进行测试. 按照BICEP原则: Right-结果是否正确? B-是否所有的边界条件都是正确的? I-能查一下反向关联吗? C-能用其他手段交叉检查一下结果吗? E-你是否可以强制错误条件发生? P-是否满足性能要求? 源代码: #include<i

四则运算--单元测试

(1)初步测试,进行进行判断,输入数据:5 100 1 0 0 0 1 (2)判断乘除变化时,结果是否正确 输入数据:5 100 1 1 0 0 1 (3)当输入的题目数为负数时,判断结果 输入数据:-10 100 1 0 0 1 0 (4)当数值过大时,计算的数值仍然合理 输入数据:10 2000 1 0 0 0 1 (5)当运算数为0时,没有运算式产生,输入数据:5 0 1 0 0 0 1 (6)当用户输入没有按照要求时,无运算式产生 输入数据:5 10 12 1 0 0 1

软件工程——四则运算单元测试(是否有乘除法)

首先找了一组比较大的数测试了一下稳定性: 下面是没有乘除法给出而结果: 有乘除法的结果:

软件工程课堂练习--四则运算单元测试

一.测试计划 对系统所要实现的功能以及程序中的函数进行针对性的测试, 1.输入出题数目,看出题数目是否正确: 2.用户首先要选择有无负数参与运算,分别用[0/1]是或否表示,分别输入[0/1]看是否有无负数出现:其次如若输入其他字符或数字,则显示提示要求用户重新输入: 3.然后用户根据提示输入是否有无乘除法,测试方法同上: 4.测试用户在重复多次操作时是否会有重复运算出现: 5.输入出题数目,选择打印列数,看是否存在问题: 二.测试执行及结果 1.输入30道题目测试有30道输出,然后用分别测试了

随机产生30道四则运算的程序单元测试

四则运算单元测试 一.测试计划: 分模块进行测试,测试各部分模块功能是否能够实现,是否能够独立运行,是否能够实现重复允许,是否有报错处理等. (1)在面对是否有乘除法运算时,输入“0”表示没有乘除法运算,输入“1”表示有乘除法运算,当输入其他数字时,则报错,要求重新输入: (2)在所有的“N”份题都含有乘除法运算时,测试有负数有余数.有负数无余数.无负数有余数.无负数无余数这4种情况下对应的结果是否符合条件(题目的份数N为用户设定),在输入的数值为0或1之外的数值,则默认为1: (3)在所有的“