4-2 四则运算_单元测试

Posted 2020-10-10

单元测试git地址：https://coding.net/u/huangzy_95/p/f4/git/tree/master

要求1 对每个功能，先给出测试用例，然后再编码功能。请注意把测试用例视为功能需求完成的检验指标。

要求2 在博客报告测试用例全部fail 到 全部pass 的过程，报告事实 (fail到修改代码或者测试用例，到pass) 以及收获。 除了最初的框架，测试用例中存在一次性pass没有经过fail的，也报告一次性通过，给出如此优秀地实现了这部分功能的代码。

初识单元测试，因水平有限，部分功能代码测试框架没有编写成功导致部分功能虽然可实现但是无法顺利进行单元测试。

功能1. 四则运算支持出题4个数的四则运算题目。

测试用例如下图：

单元测试：

 实现功能1的主要代码：

// 运算符优先级表 
// ‘+‘ ‘-‘ ‘*‘ ‘/‘ ‘(‘ ‘)‘ ‘#‘ 
unsigned char Prior[7][7] =
{
    /*‘+‘*/‘>‘, ‘>‘, ‘<‘, ‘<‘, ‘<‘, ‘>‘, ‘>‘,
    /*‘-‘*/‘>‘, ‘>‘, ‘<‘, ‘<‘, ‘<‘, ‘>‘, ‘>‘,
    /*‘*‘*/‘>‘, ‘>‘, ‘>‘, ‘>‘, ‘<‘, ‘>‘, ‘>‘,
    /*‘/‘*/‘>‘, ‘>‘, ‘>‘, ‘>‘, ‘<‘, ‘>‘, ‘>‘,
    /*‘(‘*/‘<‘, ‘<‘, ‘<‘, ‘<‘, ‘<‘, ‘=‘, ‘ ‘,
    /*‘)‘*/‘>‘, ‘>‘, ‘>‘, ‘>‘, ‘ ‘, ‘>‘, ‘>‘,
    /*‘#‘*/‘<‘, ‘<‘, ‘<‘, ‘<‘, ‘<‘, ‘ ‘, ‘=‘,
};

typedef struct StackChar
{
    char c;
    struct StackChar *next;
}SC;       //StackChar类型的结点SC  

typedef struct StackFloat
{
    float f;
    struct StackFloat *next;
}SF;       //StackFloat类型的结点SF 

SC *Push(SC *s, char c)          //SC类型的指针Push，返回p  
{
    SC *p = (SC*)malloc(sizeof(SC));
    p->c = c;
    p->next = s;
    return p;
}

SF *Push(SF *s, float f)        //SF类型的指针Push，返回p  
{
    SF *p = (SF*)malloc(sizeof(SF));
    p->f = f;
    p->next = s;
    return p;
}

SC *Pop(SC *s)    //SC类型的指针Pop  
{
    SC *q = s;
    s = s->next;
    free(q);
    return s;
}

SF *Pop(SF *s)      //SF类型的指针Pop  
{
    SF *q = s;
    s = s->next;
    free(q);
    return s;
}

float Operate(float a, unsigned char theta, float b)      //计算函数Operate  
{
    switch (theta)
    {
    case ‘+‘: return a + b;
    case ‘-‘: return a - b;
    case ‘*‘: return a*b;
    case ‘/‘: return a / b;
    default: return 0;
    }
}

代码实现效果如下图：

 

功能2. 支持括号

测试用例：

单元测试：

 实现功能2的主要代码：

char OPSET[OPSETSIZE] = { ‘+‘, ‘-‘, ‘*‘, ‘/‘, ‘(‘, ‘)‘, ‘#‘ };
Status In(char Test, char *TestOp)
{
    int Find = false;
    for (int i = 0; i< OPSETSIZE; i++)
    {
        if (Test == TestOp[i])
            Find = true;
    }
    return Find;
}

Status ReturnOpOrd(char op, char *TestOp)
{
    for (int i = 0; i< OPSETSIZE; i++)
    {
        if (op == TestOp[i])
            return i;
    }
}

char precede(char Aop, char Bop)
{
    return Prior[ReturnOpOrd(Aop, OPSET)][ReturnOpOrd(Bop, OPSET)];
}

// 算术表达式求值的算符优先算法  
// 设OPTR和OPND分别为运算符栈和运算数栈，OP为运算符集合 
float EvaluateExpression(char* MyExpression)
{

    SC *OPTR = NULL;       // 运算符栈，字符元素   
    SF *OPND = NULL;       // 运算数栈，实数元素   
    char TempData[20];
    float Data, a, b;
    char theta, *c, Dr[] = { ‘#‘, ‘\\0‘ };
    OPTR = Push(OPTR, ‘#‘);
    c = strcat(MyExpression, Dr);
    strcpy(TempData, "\\0");//字符串拷贝函数   
    while (*c != ‘#‘ || OPTR->c != ‘#‘)
    {
        if (!In(*c, OPSET))
        {
            Dr[0] = *c;
            strcat(TempData, Dr);           //字符串连接函数   
            c++;
            if (In(*c, OPSET))
            {
                Data = atof(TempData);       //字符串转换函数(double)   
                OPND = Push(OPND, Data);
                strcpy(TempData, "\\0");
            }
        }
        else    // 不是运算符则进栈   
        {
            switch (precede(OPTR->c, *c))
            {
            case ‘<‘: // 栈顶元素优先级低   
                OPTR = Push(OPTR, *c);
                c++;
                break;
            case ‘=‘: // 脱括号并接收下一字符   
                OPTR = Pop(OPTR);
                c++;
                break;
            case ‘>‘: // 退栈并将运算结果入栈   
                theta = OPTR->c; OPTR = Pop(OPTR);
                b = OPND->f; OPND = Pop(OPND);
                a = OPND->f; OPND = Pop(OPND);
                OPND = Push(OPND, Operate(a, theta, b));
                break;
            } //switch  
        }
    } //while   
    return OPND->f;
} //EvaluateExpression  
  //符号生成

 代码实现效果如下图：

 

功能3. 限定题目数量，"精美"打印输出，避免重复

测试用例：

 实现功能3的主要代码：

//判断是否重复
        for (j = 0; j < i; j++)
        {
            if (Equation[j] == Equation[i])
            {
                i = i - 1;
                repeat = 1;
                break;
            }
        }

        if (repeat != 1)//若不重复，则输出 
        {
            cout << Equation[i] << "=";
            //判断结果是否正确
            cin >> InputAns;
            Answer = get_ans(Equation[i]);
            Answer *= 100;
            int temp = (int)Answer;
            Answer = ((double)temp) / 100.00;
            if (InputAns == Answer)
            {
                cout << "Correct answer!";
                right++;
            }
            else
            {
                cout << "Wrong answer!The correct answer is";
                cout << setprecision(2) << fixed << Answer;
                wrong++;
            }
            cout << endl;
        }
    }

代码实现效果如下图：

 

功能4. 支持分数出题和运算

测试用例：

 实现功能4的主要代码：

//把数字转换成字符串型
string int_string(int number)
{
    char str[200];
    itoa(number, str, 10);
    string str_ = str;
    return str_;
}

//真分数合成一个字符串
string combination1(string str1, string str2, char k)
{
    string equation;
    equation = ‘(‘ + str1 + k + str2 + ‘)‘;
    return equation;
}

//新生成一个数
string create_num(int proper_fs, int range)
{
    int num, num1, num2, fs;
    string str_num, str_num1, str_num2;
    num = random() % range + 1;
    str_num = int_string(num);
    if (proper_fs == 1)
    {
        fs = random() % 3;
        if (fs == 1)//判断是否生成真分数  
        {
            for (;;)
            {
                num1 = random() % range + 1;
                num2 = random() % range + 1;
                if (num1<num2) break;
            }
            str_num1 = int_string(num1);
            str_num2 = int_string(num2);
            str_num = combination1(str_num1, str_num2, ‘/‘);
        }
    }
    return str_num;
}

//运算式转换成一个字符串
string combination(string str1, string str2, char k)
{
    string equation;
    equation = str1 + k + str2;
    return equation;
}

//得出正确答案 
float get_ans(string str)
{
    int len;
    float ans;
    len = str.length();
    //char num[len];
    char *num = new char[len];
    for (int j = 0; j<len; j++)
    {
        num[j] = str[j];
    }
    //用堆栈解决。。。 
    ans = EvaluateExpression(num);
    return ans;
}

代码实现效果如下图：