结对编程之附加题：单元测试

Posted 2020-10-12 实习第二天

　　　　　　　201421122079 林仙平　　201421122076 陈俊达

　需求：

　　　　1.测试加减是否正确

　　　　2.测试加减乘除功能

　　　　3.测试计算类对各种参数的支持

　　　　4.通过增量修改的方式，改进程序

　测试准备：

     　　 先建好一个项目，把原来项目的计算类导进来，（要做成GUI时也是直接拷过去的），再在计算方法的每个节点添加输出查看测试过程中每个小模块的数据是否正确，这样输出的过程就知道测试用例经过多少代码，如：

　　　　　　输入表达式为：1*15*15
　　　　　　去括号后：1*15*15
　　　　　　循环去乘号：15*15
　　　　　　循环去乘号：225
　　　　　　最后结果为：225

　　　　就表示经过一次去括号循环模块、两次乘法计算模块、没有经过加减运算

　　     代码截图：

                            

                       

 

 

 

  测试：

     

      简单加法：                                                    简单减法：

                                

　　加减括号混合：                                            简单乘除：

                                

　　加减乘除括号混合：

            

　　这里第二个测试表达式在第二步进行乘法运算时出错了，由于方法复杂，用断点的排错误太麻烦，所以在关键代码段添加输出来查看分析错误原因：

           

 

　　看结果是乘法前面的数取错了，15只取到各位数5，更改后代码结果：

         

 　讨论照片：

　        　

  小结和感受：　　 

　　　  在第一次四则运算作业中给各个功能模块写在单独的一个类里面，所以这次把这个类拷过来就可以用了，所以给功能分详细的模块在以后更改项目上非常方便，添加修改模块需要的改动比较小。

      　　还好当时写计算模块时候花时间加上注释，不然重新理一遍算法的逻辑肯定是一件相当蛋疼的事情，还有就是但是敲完计算模块后，只是做了简单的测试，没有覆盖到所有情况，所以有些小错误没有及时发现，在这次测试中才发现并修改了错误。

     　　 关于代码规范，这次体会不是很深，因为方法跟参数并不多，不管取名规范还是怎样，不看名字就能知道是什么方法或者干嘛的，当然，这次看代码跟上次间隔时间并不长，如果过个一两年再重新看自己的 代码规范取名的作用可能就会感受出来了，因为过个一两年后看自己写的代码相当于看别人写的代码，所以规范名字还是很重要的啊，注释也是必须的。

　         还有就是但是敲完计算模块后，只是做了简单的测试，没有覆盖到所有情况，所以有些小错误没有及时发现，在这次测试中才发现并修改了错误。

  PSP

        

 

  coding地址

　　https://coding.net/u/lxp2017/p/coding/git/tree/master/        下的CountTest是整个测试的项目

  代码展示：

 

public class CountExp {
    //计算表达式答案
    public static String countAnswer(String exp) {
        int result = 0;
        int a1 = 0, a2 = 0;
        int b = 0;// 为0说明符号后面的数为负数，1 为正数
        int bb = 0;// 符号后面的数字长度-1
        int w = 0;// w用来表示符号前面打数字打位数-1
        int ww = 0;// ww为0说明算术符号前面的数是正数，为1说明是负数
        String exp1 = "";// 接收去括号后的表达式
        String exp2 = "";// 接收去乘除号后打表达式
        String exp3 = "";// 用来接收分数
        //第一个模块
        // 去括号
        System.out.println("输入表达式为："+exp);
        for (int i = 0; i < exp.length(); i++) {
            if (exp.charAt(i) == \'(\') {
                int i1 = 0;
                int i2 = 0;
                // 判断算术符号前面的数是否多位
                if (exp.charAt(i + 2) != \'-\' && exp.charAt(i + 2) != \'+\') {
                    i1 = i1 + 1;
                    if (exp.charAt(i + 3) != \'-\' && exp.charAt(i + 3) != \'+\')
                        i1 = i1 + 1;
                }
                // 判断算术符号后面的数是否多位
                if (exp.charAt(i + i1 + 4) != \')\') {
                    i2 = i2 + 1;
                    if (exp.length() > (i + i1 + 5)
                            && exp.charAt(i + i1 + 5) != \')\')
                        i2 = i2 + 1;
                }
                a1 = Integer.parseInt(exp.substring(i + 1, i + 2 + i1));
                a2 = Integer.parseInt(exp
                        .substring(i + 3 + i1, i + 4 + i1 + i2));
                if (exp.charAt(i + 2+i1) == \'+\')
                    exp1 = exp1 + (a1 + a2);
                else
                    exp1 = exp1 + (a1 - a2);
                i = i + 4 + i1 + i2;

            } else
                exp1 = exp1 + exp.charAt(i);
        }
        System.out.println("去括号后："+exp1);
        //第二个小模块
        // 循环先算公式里的乘跟除
        for (int j = 0; j < exp1.length(); j++) {
            if (exp1.charAt(j) == \'*\') {
                w = 0;// w用来表示符号前面打数字的位数-1
                ww = 0;// ww为0说明算术符号前面的数是正数，为1说明是负数
                if ((j - 2) >= 0 && exp1.charAt(j - 2) != \'-\'
                        && exp1.charAt(j - 2) != \'+\'
                        && exp1.charAt(j - 2) != \'*\'
                        && exp1.charAt(j - 2) != \'÷\') {
                    w = w + 1;
                    if ((j - 2 - w) >= 0 && exp1.charAt(j - 2 - w) != \'-\'
                            && exp1.charAt(j - 2 - w) != \'+\'
                            && exp1.charAt(j - 2) != \'*\'
                            && exp1.charAt(j - 2) != \'÷\')
                        w = w + 1;
                }

                if ((j - 2 - w) > 0
                        && exp1.charAt(j - 2 - w) == \'-\'
                        && ((j - 3 - w) > 0 && exp1.charAt(j - 3 - w) == \'-\' || (exp1
                                .charAt(j - 3 - w) == \'+\')))
                    ww = ww + 1;

                a1 = Integer.parseInt(exp1.substring(j - w - 1, j));
                if (ww == 1)
                    a1 = 0 - a1;
                b = 0;// 为0说明符号后面的数为负数，1 为正数
                bb = 0;// 符号后面的数字长度-1
                // 判断算术符号后面的数是否是负数
                if (exp1.charAt(j + 1) == \'-\')
                    b = b + 1;
                // 判断算术符号后面的数是否多余一位
                if (exp1.length() > (j + 2 + b)
                        && (exp1.charAt(j + 2 + b) != \'-\'
                                && exp1.charAt(j + 2 + b) != \'+\'
                                && exp1.charAt(j + 2 + b) != \'*\' && exp1
                                .charAt(j + 2 + b) != \'÷\')) {
                    bb = bb + 1;
                    if (exp1.length() > (j + 3 + b)
                            && (exp1.charAt(j + 3 + b) != \'-\'
                                    && exp1.charAt(j + 3 + b) != \'+\'
                                    && exp1.charAt(j + 3 + b) != \'*\' && exp1
                                    .charAt(j + 3 + b) != \'÷\'))
                        bb = bb + 1;
                }
                a2 = Integer
                        .parseInt(exp1.substring(j + 1 + b, j + 2 + b + bb));
                if (b == 1)
                    a2 = 0 - a2;
                exp2 = exp2.substring(0, j - 1 - w - ww);
                exp2 = exp2 + (a1 * a2);
                exp2 = exp2 + exp1.substring(j + 2 + b + bb, exp1.length());
                exp1 = exp2;
                exp2 = "";
                j = -1;
                System.out.println("循环去乘号："+exp1);
                continue;
                
            } else if (exp1.charAt(j) == \'÷\') {// 遇到除号 ，则进行除法运算，结果为分数
                w = 0;// w用来表示符号前面打数字打位数-1
                ww = 0;// ww为0说明算术符号前面的数是正数，为1说明是负数
                if ((j - 2) > 0 && exp1.charAt(j - 2) != \'-\'
                        && exp1.charAt(j - 2) != \'+\') {
                    w = w + 1;
                    if (exp1.charAt(j - 2 - w) != \'-\'
                            && exp1.charAt(j - 2 - w) != \'+\')
                        w = w + 1;
                }
                if ((j - 2 - w) > 0
                        && exp1.charAt(j - 2 - w) == \'-\'
                        && (exp1.charAt(j - 3 - w) == \'-\' || (exp1.charAt(j - 3
                                - w) == \'+\')))
                    ww = ww + 1;
                a1 = Integer.parseInt(exp1.substring(j - w - 1, j));

                b = 0;// 为0说明符号后面的数为负数，1 为正数
                bb = 0;// 符号后面的数字长度-1
                // 判断算术符号后面的数是否是负数
                if (exp1.charAt(j + 1) == \'-\')
                    b = b + 1;
                // 判断算术符号后面的数是否多余一位
                if (exp1.length() > (j + 2 + b)
                        && (exp1.charAt(j + 2 + b) != \'-\'
                                && exp1.charAt(j + 2 + b) != \'+\'
                                && exp1.charAt(j + 2 + b) != \'*\' && exp1
                                .charAt(j + 2 + b) != \'÷\')) {
                    bb = bb + 1;
                    if (exp1.length() > (j + 3 + b)
                            && (exp1.charAt(j + 3 + b) != \'-\'
                                    && exp1.charAt(j + 3 + b) != \'+\'
                                    && exp1.charAt(j + 3 + b) != \'*\' && exp1
                                    .charAt(j + 3 + b) != \'÷\'))
                        bb = bb + 1;
                }
                a2 = Integer
                        .parseInt(exp1.substring(j + 1 + b, j + 2 + b + bb));

                if (a1 % a2 == 0) {
                    exp2 = "" + (a1 / a2);
                    return exp2;
                } else if (a1 < a2) {
                    exp2 = "" + a1 + "/" + a2;
                    return exp2;
                } else {
                    int e1 = a1 / a2;
                    int e2 = a1 - a2 * e1;
                    exp2 = "" + e1 + "’" + e2 + "/" + a2;
                    System.out.println("进行除法运算后："+exp2);
                    return exp2;
                }

            } else
                exp2 = exp2 + exp1.charAt(j);
        }
        int fs = 10;// 用来记录表达式括号的位置
        //第三个小模块
        // 进行加减运算
        for (int xx = 0; xx < exp2.length(); xx++) {
            if (exp2.charAt(xx) == \'/\')
                fs = xx;
        }
        int aa = 0;// 用来暂a1,a2的值
        if (fs == 10) {
            for (int fss = 1; fss < exp2.length(); fss++) {
                if (exp2.charAt(fss) == \'+\') {
                    b = 0;// 符号后面的数字长度-1
                    bb = 0;// 为0说明符号后面的数为负数，1 为正数
                    w = 0;// w用来表示符号前面打数字打位数-1
                    ww = 0;// ww为0说明算术符号前面的数是正数，为1说明是负数
                    if (exp2.charAt(0) == \'-\')
                        bb = bb + 1;
                    b = fss - bb;
                    a1 = Integer.parseInt(exp2.substring(0, fss));
                    if ((fss + 2) < exp2.length()
                            && exp2.charAt(fss + 2) != \'+\'
                            && exp2.charAt(fss + 2) != \'-\') {
                        w = w + 1;
                        if ((fss + 3) < exp2.length()
                                && exp2.charAt(fss + 3) != \'+\'
                                && exp2.charAt(fss + 3) != \'-\') {
                            w = w + 1;
                            if ((fss + 4) < exp2.length()
                                    && exp2.charAt(fss + 4) != \'+\'
                                    && exp2.charAt(fss + 4) != \'-\') {
                                w = w + 1;
                            }
                        }
                    }
                    a2 = Integer.parseInt(exp2.substring(fss + 1, fss + 2 + ww
                            + w));

                    exp2 = (a2 + a1)
                            + exp2.substring(fss + 2 + w + ww, exp2.length());
                    fss = 0;
                    System.out.println("循环一次去加减："+exp2);
                    if (exp.length() < 2)
                        break;
                } else if (exp2.charAt(fss) == \'-\') {
                    if ((fss < exp.length()) && exp2.charAt(fss) == \'-\') {
                        b = 0;// 符号后面的数字长度-1
                        bb = 0;// 为0说明符号后面的数为负数，1 为正数
                        w = 0;// w用来表示符号前面打数字打位数-1
                        ww = 0;// ww为0说明算术符号前面的数是正数，为1说明是负数
                        if (exp2.charAt(0) == \'-\')
                            bb = bb + 1;
                        b = fss - bb;
                        a1 = Integer.parseInt(exp2.substring(0, fss));
                        if (exp2.charAt(fss + 1) == \'-\')
                            ww = ww + 1;
                        if ((fss + 2 + ww) < exp2.length()
                                && exp2.charAt(fss + 2 + ww) != \'+\'
                                && exp2.charAt(fss + 2 + ww) != \'-\') {
                            w = w + 1;
                            if ((fss + 3 + ww) < exp2.length()
                                    && exp2.charAt(fss + 3 + ww) != \'+\'
                                    && exp2.charAt(fss + 3 + ww) != \'-\')
                                w = w + 1;
                        }
                        a2 = Integer.parseInt(exp2.substring(fss + 1 + ww, fss
                                + 2 + ww + w));
                        exp2 = (a1 - a2)
                                + exp2.substring(fss + 2 + w + ww,
                                        exp2.length());
                        fss = 0;
                        System.out.println("循环一次去加减："+exp2);
                        if (exp.length() < 2)
                            break;
                        
                    }
                }
                
            }
        }
        return exp2;
        
    }
}