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

我的学号：201421122044

队友学号：201421122040

coding地址：https://coding.net/u/gebeelaowang/p/FourArithmeticOperation/git

 

1.把计算模块提取出来，单独创建一个类。

　　提取计算模块,封装成单独的一个计算类NPR.java

　　 类中主要方法为

　　 　　1.中缀表达式转后缀表达式

　　  　   2.后缀表达式计算生成结果

public class NPR {
    public String getFindTheSame() {
        return findTheSame;
    }
    public void setFindTheSame(String findTheSame) {
        this.findTheSame = findTheSame;
    }
    //判断ch是否为运算符
    public boolean inOp(char c){
        if (c == '(' || c == ')' || c == '+' || c == '-' || c == '*' || c == '÷'){
            return true;
        }
        else{
            return false;
        }
    }
    //判断ch是否为运算符
    public int precede(int op1,int op2){
        if (op1 == op2){
            return 0;
        }
        else if (op1 < op2){
            return -1;
        }
        else{
            return 1;
        }
    }
    
    //逆波兰式
    public String exchangeNPR(String formula) {
        //用哈希键值对映射左运算符的优先级
        HashMap<String, Integer> lpri = new HashMap<String,Integer>();
        lpri.put("=",0);
        lpri.put("(",1);
        lpri.put("*",5);
        lpri.put("÷",5);
        lpri.put("+",3);
        lpri.put("-",3);
        lpri.put(")",6);
        //用哈希键值对映射右运算符的优先级
        HashMap<String, Integer> rpri = new HashMap<String,Integer>();
        rpri.put("=",0);
        rpri.put("(",6);
        rpri.put("*",4);
        rpri.put("÷",4);
        rpri.put("+",2);
        rpri.put("-",2);
        rpri.put(")",1);
        //创建栈
        Stack op = new Stack();
        op.data = new char[200];
        op.top=-1;
        op.top++;
        op.data[op.top]='=';
        //把传入的表达式转化成字符数组
        char[] exp = formula.toCharArray();
        //用来存储后缀表达式
        String postexp = ""; 
        int j=0;
        while(j<exp.length) {
            if(!inOp(exp[j])) {
                while(j<exp.length&&((exp[j]>='0'&& exp[j]<='9')||(exp[j]=='\'')||(exp[j]=='/'))) {
//                    System.out.println(exp.length);
                    postexp+=(exp[j]);
                    j++;
                }
                postexp+=('#');
            }else {
                switch(precede(lpri.get(op.data[op.top]+""),rpri.get(exp[j]+""))){
                case -1:
                    op.top++;
                    op.data[op.top]=exp[j];
                    j++;
                    break;
                case 0:
                    op.top--;
                    j++;
                    break;
                case 1:
                    postexp+=(op.data[op.top]);
                    op.top--;
                    break;
                }
            }    
        }
        while(op.data[op.top]!='=') {
            postexp+=(op.data[op.top]);
            op.top--;
        }
        return postexp;
    }
    //把运算数转换成数组[分子，分母]
    public int[] numberChangeArr(String number){
        int num[] = new int[2];
        if(number.indexOf('/')!=-1) {
            if(number.indexOf('\'')!=-1) {
                int theTimes = Integer.parseInt(number.split("\'")[0]);
                int numerator = Integer.parseInt((number.split("\'")[1]).split("/")[0]);
                int denominator = Integer.parseInt((number.split("\'")[1]).split("/")[1]);
                num[0] = theTimes*denominator+numerator;
                num[1] = denominator;
            }else {
                num[0] = Integer.parseInt(number.split("/")[0]);
                num[1] = Integer.parseInt(number.split("/")[1]);
            }
        }else {
            num[0] = Integer.parseInt(number);
            num[1] = 1;
        }
        return num;
    }
    //后缀表达式的计算
    public String compvalue(String nprFormula) {
        this.findTheSame = ""; //查重用字符串
        Stack st = new Stack();
        st.top=-1;
        st.data2 = new String[200];
        int i=0;
        char[] postexp = nprFormula.toCharArray();
        while(i<postexp.length) {
            switch(postexp[i]) {
            case '+':
                String a = st.data2[st.top];
                st.top--;
                String b = st.data2[st.top];
                st.top--;
                String c = "";
                int numeratorA = numberChangeArr(a)[0];
                int denominatorA = numberChangeArr(a)[1];
                int numeratorB = numberChangeArr(b)[0];
                int denominatorB = numberChangeArr(b)[1];
                int theMinTimes = MathUtils.minTimes(denominatorA,denominatorB);
                numeratorA=(theMinTimes/denominatorA)*numeratorA;
                numeratorB=(theMinTimes/denominatorB)*numeratorB;
                int theAdd = numeratorA+numeratorB;
                c+=MathUtils.simpleNum(theAdd,theMinTimes);
                st.top++;
                st.data2[st.top]=c;
                //查重用
                if(numeratorA>numeratorB) {
                    this.findTheSame+=b;
                    this.findTheSame+=a;
                }else {
                    this.findTheSame+=a;
                    this.findTheSame+=b;
                }
                this.findTheSame+=c+" ";
                break;
            case '-':
                String a2 = st.data2[st.top];
                st.top--;
                String b2 = st.data2[st.top];
                st.top--;
                String c2 = "";
                int numeratorA2 = numberChangeArr(a2)[0];
                int denominatorA2 = numberChangeArr(a2)[1];
                int numeratorB2 = numberChangeArr(b2)[0];
                int denominatorB2 = numberChangeArr(b2)[1];
                int theMinTimes2 = MathUtils.minTimes(denominatorA2,denominatorB2);
                int theReduct = 0;
                theReduct = numeratorB2-numeratorA2;
                numeratorA2=(theMinTimes2/denominatorA2)*numeratorA2;
                numeratorB2=(theMinTimes2/denominatorB2)*numeratorB2;
                theReduct = numeratorB2-numeratorA2;
                if(theReduct==0) {
                    c2+="0";
                }else if(theReduct>0) {
                    c2+=MathUtils.simpleNum(theReduct,theMinTimes2);
                }else {
                    theReduct=Math.abs(theReduct);
                    c2+="-"+MathUtils.simpleNum(theReduct,theMinTimes2);
                }
                st.top++;
                st.data2[st.top]=c2;
            case '÷':
                String a3 = st.data2[st.top];
                st.top--;
                String b3 = st.data2[st.top];
                st.top--;
                String c3 = "";
                int numeratorA3 = numberChangeArr(a3)[0];
                int denominatorA3 = numberChangeArr(a3)[1];
                int numeratorB3 = numberChangeArr(b3)[0];
                int denominatorB3 = numberChangeArr(b3)[1];
                if(numeratorA3!=0) {
                    int theNumerator = numeratorB3*denominatorA3;
                    int theDenominator = denominatorB3*numeratorA3;
                    c3 += MathUtils.simpleNum(theNumerator,theDenominator);
                    st.top++;
                    st.data2[st.top]=c3;
                }else {
                    c3="Error! divide zero exception!";
                    return c3;
                }
                break;
            case '*':
                String a4 = st.data2[st.top];
                st.top--;
                String b4 = st.data2[st.top];
                st.top--;
                String c4 = "";
                int numeratorA4 = numberChangeArr(a4)[0];
                int denominatorA4 = numberChangeArr(a4)[1];
                int numeratorB4 = numberChangeArr(b4)[0];
                int denominatorB4 = numberChangeArr(b4)[1];
                int numerator = numeratorA4*numeratorB4;
                int denominator = denominatorA4*denominatorB4;
                c4+=MathUtils.simpleNum(numerator,denominator);
                st.top++;
                st.data2[st.top]=c4;
                break;
            default:
                String d = "";
                while((postexp[i]>='0'&&postexp[i]<='9')||(postexp[i]=='\'')||(postexp[i]=='/')) {
                    d+=postexp[i];
                    i++;
                }
                st.top++;
                st.data2[st.top]=d;
                break;
            }
            i++;
        }
        return st.data2[st.top];
    }
    
    

}

2.需求分析：测试上有哪些详细的需求？

1. 通过单元测试代码，测试加法是否能正确工作；
2. 通过单元测试代码，测试加减乘除功能。
3. 通过单元测试代码，测试计算类对于各种参数的支持。
4. 通过增量修改的方式，改进程序， 完成对各种错误情况的处理。

3.设计测试框架, 模拟测试数据

　　1.加法测试

　　　　测试数据：3+4+5

　　　　预期结果：12

　　2.减法测试

　　　　测试数据：3-4-5-1/2

　　　　预期结果：-6'1/2

　　3.乘法测试

　　　　测试数据：2*5*1/2

　　　　预期结果：5

　　4.除法测试

　　　　测试数据：2÷5÷1/2

　　　　预期结果：4/5

　　5.混合参数类型，混合运算符类型测试

　　　　测试数据：1/3+1'1/3*2÷1/5-(8-4)

　　　　预期结果：9'2/3

　　6.除零异常测试

　　　　测试数据：7÷(4-4)

　　　　预期结果：Error! divide zero exception!

 

　　Junit类测试代码

package com.jmu.test;
import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;
import com.jmu.model.NPR;
public class NPRTest {

    @Before
    public void setUp() throws Exception {
    }
    
    //加法测试
    @Test
    public void testAdd() {
        NPR testNpr = new NPR();
        String testOutcome = testNpr.compvalue(testNpr.exchangeNPR("3+4+5"));
        assertEquals(testOutcome,"12");
    }
    
    //减法测试
    @Test
    public void testMinus() {
        NPR testNpr = new NPR();
        String testOutcome = testNpr.compvalue(testNpr.exchangeNPR("3-4-5-1/2"));
        assertEquals(testOutcome,"-6'1/2");
    }
    
    //乘法测试
    @Test
    public void testMultiply() {
        NPR testNpr = new NPR();
        String testOutcome = testNpr.compvalue(testNpr.exchangeNPR("2*5*1/2"));
        assertEquals(testOutcome,"5");
    }
    
    //除法测试
    @Test
    public void testDivede() {
        NPR testNpr = new NPR();
        String testOutcome = testNpr.compvalue(testNpr.exchangeNPR("2÷5÷1/2"));
        assertEquals(testOutcome,"4/5");
    }
    
    //计算类对于各种参数的支持，各类型运算元混合测试
    @Test
    public void testMess() {
        NPR testNpr = new NPR();
        String testOutcome = testNpr.compvalue(testNpr.exchangeNPR("1/3+1'1/3*2÷1/5-(8-4)"));
        assertEquals(testOutcome,"9'2/3");
    }
    
    //除零异常测试
    @Test
    public void zeroException() {
        NPR testNpr = new NPR();
        String testOutcome = testNpr.compvalue(testNpr.exchangeNPR("7÷(4-4)"));
        assertEquals(testOutcome,"Error! divide zero exception!");
    }
}

 

　　2.测试结果

　　

　　如图，通过Junit单元测试，可以直观地看出所有函数运行结果与预期出现的结果一致

　   coding提交记录

　　　　

 

4.小结与感受：通过测试，是否有效发现了程序计算模块的问题，并给予改进？

　　实验一的时候不是使用Junit测试，而是自己单独创建一个类Test.java

　　然后用类里面的main函数实例化出这个计算类，对每个函数进行测试

　　计算过程中的bug已经在实验一测试的时候排除

　　然而，使用Junit可以更加直观地看出测试结果

　　在后面的编码过程中，我打算更多地使用Junit来进行单元测试，测试过程更加方便，测试结果更加直观

5.PSP

　　

PSP2.1	Personal Software Process Stages	Time Senior Student	Time
Planning	计划	3	1
· Estimate	估计这个任务需要多少时间	24	24
Development	开发	7	12
· Analysis	需求分析 (包括学习新技术)	10	3
· Design Spec	生成设计文档	NaN	0
· Design Review	设计复审	NaN	0
· Coding Standard	代码规范	NaN	0
· Design	具体设计	NaN	20
· Coding	具体编码	NaN	20
· Code Review	代码复审	NaN	10
· Test	测试（自我测试，修改代码，提交修改）	NaN	2
Reporting	报告	NaN	10
·	测试报告	NaN	0
·	计算工作量	NaN	0
·	并提出过程改进计划	NaN	0