四则运算-单元测试

最新推荐文章于 2022-04-05 22:31:29 发布
最新推荐文章于 2022-04-05 22:31:29 发布
阅读量421 收藏 1
点赞数
文章标签： python 测试 git
原文链接：http://www.cnblogs.com/lizhiqiang0/p/6638962.html
版权

四则运算-单元测试

李志强 201421123028 连永刚 201421123014 林方言 201421123023

coding 地址：https://git.coding.net/lizhiqiang0x01/sizeyunsuan-TestExample.git

一、题目要求

1、通过单元测试代码，测试加法是否能正确工作；

2、通过单元测试代码，测试加减乘除功能。

3、通过单元测试代码，测试计算类对于各种参数的支持：

     a. 输入是有错误的，例如 “1 ++ 2”，

     b. 在数值范围是 -1000 .. 1000 的时候，传进去 “10000 + 32768”,

     c. 或者是 “ 248 / 0” 怎么办?

     d. 怎么告诉函数的调用者 “你错了”? 把返回的字符串定义为 “-1” 来表示？

     e. 那么如果真的计算结果是 “-1” 又怎么处理呢?

4、通过增量修改的方式，改进程序， 完成对各种错误情况的处理。

 二、实验步骤

   a、需求分析

    通过单元测试代码，测试程序加减乘除功能是否正确工作，对于格式错误、数值溢出、除零异常是否能检测的到。

  b、设计测试框架，模拟测试数据

  • 测试加减乘除功能
        TEST_METHOD(TestAdd)    //测试加法
        {
            Test.CheckInput("1/2+4");
            Assert::AreEqual(test11,Test.add());
        }
        TEST_METHOD(TestAdd1)
        {
            Test.CheckInput("3+1/3");
            Assert::AreEqual(test12, Test.add());
        }
        TEST_METHOD(TestAdd2)
        {
            Test.CheckInput("2+4");
            Assert::AreEqual(test13, Test.add());
        }
        TEST_METHOD(TestAdd3)
        {
            Test.CheckInput("1/2+1/4");
            Assert::AreEqual(test14, Test.add());
        }

        TEST_METHOD(TestSub)           //测试减法
        {
            Test.CheckInput("1/2-1/3");
            Assert::AreEqual(test21, Test.sub());
        }

        TEST_METHOD(TestSub1)
        {
            Test.CheckInput("1/3-2");
            Assert::AreEqual(test22, Test.sub());
        }
        TEST_METHOD(TestSub2)
        {
            Test.CheckInput("2-1/3");
            Assert::AreEqual(test23, Test.sub());
        }
        TEST_METHOD(TestSub3)
        {
            Test.CheckInput("5-3");
            Assert::AreEqual(test24, Test.sub());
        }

        TEST_METHOD(TestMul)       //测试乘法
        {
            Test.CheckInput("1×2");        
            Assert::AreEqual(test31, Test.mul());
        }
        TEST_METHOD(TestMul1)
        {
            Test.CheckInput("1/2×2");
            Assert::AreEqual(test32, Test.mul());
        }
        TEST_METHOD(TestMul2)
        {
            Test.CheckInput("2×1/3");
            Assert::AreEqual(test33, Test.mul());
        }
        TEST_METHOD(TestMul3)
        {
            Test.CheckInput("1/3×1/2");
            Assert::AreEqual(test34, Test.mul());
        }
        TEST_METHOD(TestDiv)       //测试除法
        {
            Test.CheckInput("1/2÷2");
            Assert::AreEqual(test41, Test.div());
        }
        TEST_METHOD(TestDiv1)
        {
            Test.CheckInput("4÷1/2");
            Assert::AreEqual(test42, Test.div());
        }
        TEST_METHOD(TestDiv2)
        {
            Test.CheckInput("1/2÷2/3");
            Assert::AreEqual(test43, Test.div());
        }
        TEST_METHOD(TestDiv3)
        {
            Test.CheckInput("1÷2");
            Assert::AreEqual(test44, Test.div());
        }
  • 测试格式错误、数值溢出、除零异常功能
        TEST_METHOD(TestCheckFormat1)     //测试格式错误
        {
            Test.CheckInput("2--2");
            Assert::AreEqual(test5, Test.g_szErrIn);
        }
        TEST_METHOD(TestCheckFormat2)
        {
            Test.CheckInput("2+÷2");
            Assert::AreEqual(test5, Test.g_szErrIn);
        }
        TEST_METHOD(TestCheckFormat3)
        {
            Test.CheckInput("2+×2");
            Assert::AreEqual(test5, Test.g_szErrIn);
        }
        TEST_METHOD(TestCheckFormat4)
        {
            Test.CheckInput("2+×");
            Assert::AreEqual(test5, Test.g_szErrIn);
        }
        TEST_METHOD(TestCheckFormat5)
        {
            Test.CheckInput("2+/2");
            Assert::AreEqual(test5, Test.g_szErrIn);
        }
        TEST_METHOD(TestCheckNum61)     //测试非法数值
        {
            Test.CheckInput("1÷0");
            Test.div();
            Assert::AreEqual(test6, Test.g_szErrNum);
        }
        TEST_METHOD(TestCheckNum62)
        {
            Test.CheckInput("1/0");
            Test.div();
            Assert::AreEqual(test6, Test.g_szErrNum);
        }
        TEST_METHOD(TestCheckNum63)
        {
            Test.CheckInput("1/2+2/0");
            Test.add();
            Assert::AreEqual(test6, Test.g_szErrNum);
        }
        TEST_METHOD(TestCheckBey71)      //测试时数值溢出
        {
            Test.CheckInput("-2000+2");
            Test.add();
            Assert::AreEqual(test7, Test.g_szErrBey);
        }
        TEST_METHOD(TestCheckBey72)
        {
            Test.CheckInput("-2000");
            Test.add();
            Assert::AreEqual(test7, Test.g_szErrBey);
        }
        TEST_METHOD(TestCheckBey73)
        {
            Test.CheckInput("-200+2/3000");
            Test.add();
            Assert::AreEqual(test7, Test.g_szErrBey);
        }
View Code
  • 单元测试加减乘除功能
string Calc::add()     //测试加法
{
    size_t iPos = g_szInput.find('+');
    g_szX = g_szInput.substr(0, iPos);
    g_szY = g_szInput.substr(iPos+1, g_szInput.length()-1-iPos);
    size_t iPosInX = g_szX.find('/');
    g_iFirNer = stoi(g_szX.substr(0, iPosInX));
    if (iPosInX == -1)
    {
        g_iFirDer = 1;
    }
    else
    {
        g_iFirDer = stoi(g_szX.substr(iPosInX+1, g_szInput.length() - 1 - iPosInX));
    }
    size_t iPosInY = g_szY.find('/');
    g_iSecNer = stoi(g_szY.substr(0, iPosInY));
    if (iPosInY == -1)
    {
        g_iSecDer = 1;
    }
    else
    {
        g_iSecDer = stoi(g_szY.substr(iPosInY+1, g_szInput.length() - 1 - iPosInY));
    }
    simplify(g_iFirNer, g_iFirDer, g_iSecNer, g_iSecDer);
    g_iRusNer = g_iFirNer*g_iSecDer + g_iFirDer*g_iSecNer;
    g_iRusDer = g_iFirDer*g_iSecDer;
    init(g_iRusNer, g_iRusDer);
    g_szRusDer = "";
    g_szRusNer = "";
    if (g_iRusDer == 1)
    {
        g_szRusNer += to_string(g_iRusNer);
        return  g_szRusNer;
    }
    else{
        g_szRusDer += to_string(g_iRusDer);
        g_szRusNer += to_string(g_iRusNer);
        return  g_szRusNer + "/" + g_szRusDer;
    }
}

string Calc::sub()    //测试加法
{
    size_t iPos = g_szInput.find('-');
    g_szX = g_szInput.substr(0, iPos);
    g_szY = g_szInput.substr(iPos + 1, g_szInput.length() - 1 - iPos);
    size_t iPosInX = g_szX.find('/');
    g_iFirNer = stoi(g_szX.substr(0, iPosInX));
    if (iPosInX == -1)
    {
        g_iFirDer = 1;
    }
    else
    {
        g_iFirDer = stoi(g_szX.substr(iPosInX + 1, g_szInput.length() - 1 - iPosInX));
    }
    size_t iPosInY = g_szY.find('/');
    g_iSecNer = stoi(g_szY.substr(0, iPosInY));
    if (iPosInY == -1)
    {
        g_iSecDer = 1;
    }
    else
    {
        g_iSecDer = stoi(g_szY.substr(iPosInY + 1, g_szInput.length() - 1 - iPosInY));
    }
    simplify(g_iFirNer, g_iFirDer, g_iSecNer, g_iSecDer);
    g_iRusNer = g_iFirNer*g_iSecDer - g_iFirDer*g_iSecNer;
    g_iRusDer = g_iFirDer*g_iSecDer;
    init(g_iRusNer, g_iRusDer);
    g_szRusDer = "";
    g_szRusNer = "";
    if (g_iRusDer == 1)
    {
        g_szRusNer += to_string(g_iRusNer);
        return  g_szRusNer;
    }
    else{
        g_szRusDer += to_string(g_iRusDer);
        g_szRusNer += to_string(g_iRusNer);
        return  g_szRusNer + "/" + g_szRusDer;
    }
}

string Calc::mul()     //测试乘法
{
    size_t iPos = g_szInput.find('×');
    g_szX = g_szInput.substr(0, iPos);
    g_szY = g_szInput.substr(iPos + 1, g_szInput.length() - 1 - iPos);
    size_t iPosInX = g_szX.find('/');
    g_iFirNer = stoi(g_szX.substr(0, iPosInX));
    if (iPosInX == -1)
    {
        g_iFirDer = 1;
    }
    else
    {
        g_iFirDer = stoi(g_szX.substr(iPosInX + 1, g_szInput.length() - 1 - iPosInX));
    }
    size_t iPosInY = g_szY.find('/');
    g_iSecNer = stoi(g_szY.substr(0, iPosInY));
    if (iPosInY == -1)
    {
        g_iSecDer = 1;
    }
    else
    {
        g_iSecDer = stoi(g_szY.substr(iPosInY + 1, g_szInput.length() - 1 - iPosInY));
    }
    simplify(g_iFirNer, g_iFirDer, g_iSecNer, g_iSecDer);
    g_iRusNer = g_iFirNer*g_iSecNer;
    g_iRusDer = g_iFirDer*g_iSecDer;
    init(g_iRusNer, g_iRusDer);
    g_szRusDer = "";
    g_szRusNer = "";
    if (g_iRusDer == 1)
    {
        g_szRusNer += to_string(g_iRusNer);
        return  g_szRusNer;
    }
    else{
        g_szRusDer += to_string(g_iRusDer);
        g_szRusNer += to_string(g_iRusNer);
        return  g_szRusNer + "/" + g_szRusDer;
    }
}

string Calc::div()    //测试除法
{
    size_t iPos = g_szInput.find('÷');
    g_szX = g_szInput.substr(0, iPos);
    g_szY = g_szInput.substr(iPos + 1, g_szInput.length() - 1 - iPos);
    size_t iPosInX = g_szX.find('/');
    g_iFirNer = stoi(g_szX.substr(0, iPosInX));
    if (iPosInX == -1)
    {
        g_iFirDer = 1;
    }
    else
    {
        g_iFirDer = stoi(g_szX.substr(iPosInX + 1, g_szInput.length() - 1 - iPosInX));
    }
    size_t iPosInY = g_szY.find('/');
    g_iSecNer = stoi(g_szY.substr(0, iPosInY));
    if (iPosInY == -1)
    {
        g_iSecDer = 1;
    }
    else
    {
        g_iSecDer = stoi(g_szY.substr(iPosInY + 1, g_szInput.length() - 1 - iPosInY));
    }
    simplify(g_iFirNer, g_iFirDer, g_iSecNer, g_iSecDer);
    g_iRusNer = g_iFirNer*g_iSecDer;
    g_iRusDer = g_iFirDer*g_iSecNer;
    init(g_iRusNer, g_iRusDer);
    g_szRusDer = "";
    g_szRusNer = "";
    if (g_iRusDer == 1)
    {
        g_szRusNer += to_string(g_iRusNer);
        return  g_szRusNer;
    }
    else{
        g_szRusDer += to_string(g_iRusDer);
        g_szRusNer += to_string(g_iRusNer);
        return  g_szRusNer + "/" + g_szRusDer;
    }
}

 c、测试结果

三、PSP

 

PSP2.1Personal Software Process StagesEstimated time（h）actual time（h）
Planning计划11.5
· Estimate估计这个任务需要多少时间1015
Development开发810
· Analysis需求分析 (包括学习新技术)0.51
· Design Spec生成设计文档22
· Design Review设计复审0.30.5
· Coding Standard代码规范0.50.4
· Design具体设计1.51.3
· Coding具体编码87
· Code Review代码复审0.51
· Test测试（自我测试，修改代码，提交修改）0.20.5
Reporting报告22
·测试报告0.50.5
·计算工作量0.51
·并提出过程改进计划24

 四、总结

      先来一片面包：队友之前作业都是用c++写的，使用c++单元测试。

      再把肉放上：我们首先将各个功能模块做了分割，并对相应的模块进行多组测试，达到要进行单元测试的目的，在做分割的过程中，我们解决了之前变量太乱的诟病，在此次单元测试上，我们在代码规范做了很大的改进，我们使用匈牙利命名方法对变量进行命名，比如  g_iFirNer  g_iFirDer  g_szRusDer 等，在属性+类型+描述这种结构下，很容易理解这个变量所表达的含义，在交替写代码过程中明显加快了团队的速度，在随后的编程之路，我们会更加注重代码的规范。

      然后再来一片面包：经过这次的单元测试，我们对软件工程有了更加深刻的认识，原来发布一个软件需要许多过程来逐步完善的，需要默契的团队合作。

 

 

转载于:https://www.cnblogs.com/lizhiqiang0/p/6638962.html

weixin_30929195
关注
Junit对四则运算进行软件测试
06-07
通过使用Junit对四则运算进行软件测试，主要达到以下目的： 掌握软件测试的基本流程； 通过实践，基本学会使用一款主流的软件测试工具，即JUnit； 掌握基于白盒测试和黑盒测试技术设计合理、高效的测试用例；
四则运算单元测试报告1
08-08
四则运算单元测试报告1 本单元测试报告旨在测试四则运算的实现，包括加法、减法、乘法和除法四种基本运算。该测试报告使用Java语言编写， 并使用随机数生成器和Scanner类来生成随机式子和接收用户输入。 测试报告...
四则运算--单元测试
weixin_30819085的博客
04-11 453
（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...
四则运算单元测试
weixin_33737774的博客
03-16 269
一，避免题目重复 当取值范围过小，生成题目数量过大时出现了重复情况。 二，测试参数控制 a)测试有负数有余数 b）测试无余数无负数 c)测试输出题目数量较大的情况 三，用户输入不符合要求时测试情况 a)测试题目数量为0或者负数 b）是否支持负数，余数乘除，写规定之外字符时测试 1）是否支持乘除测试无结果 2）是否支持余数，负数，还是出现了测试结果， ...
软件工程单元测试——四则运算
03-12 457
四则运算2的单元测试 一、测试方法 1、Right－结果是否正确？ 2、B－是否所有的边界条件都是正确的？ 3、I－能查一下反向关联吗？ 4、C－能用其他手段交叉检查一下结果吗？ 5、E－你是否可以强制错误条件发生？ 6、P－是否满足性能要求？ 二、测试计划 分别测试输出结果是否正确，包括题目数量、是否有乘除...
四则运算——单元测试（测试方法：Right-BICEP ）
weixin_30730151的博客
03-13 262
一、测试的具体部位 Right－结果是否正确？ B－是否所有的边界条件都是正确的？ I－能查一下反向关联吗？ C－能用其他手段交叉检查一下结果吗？ E－你是否可以强制错误条件发生？ P－是否满足性能要求？ 二、测试结果 1.结果正确 2.边界条件 由上图可知，结果正确，但对于输入0值可以进行改进，让其直接不进行下列判断 3.一致性 数值范围大时，无余数的式子...
苏教版四年级数学上册《七整数四则混合运算》-单元测试1含答案.pdf
10-02
苏教版四年级数学上册《七整数四则混合运算》-单元测试1含答案.pdf
分数四则混合运算单元测试.pdf
10-08
分数四则混合运算单元测试.pdf
《四则运算》单元测试题及答案.doc
10-10
这份文档是针对小学数学《四则运算》单元的测试题及答案，主要涵盖了基础的加减乘除运算、运算顺序、简单的应用题以及解决实际问题的能力。以下是详细的知识点解析： 1. **基本运算规则**：题目中的一、直接写得数...
四年级下册数学第一单元四则运算测试题-.pdf
10-10
四年级下册数学第一单元四则运算测试题-.pdf
四则运算之Right-BICEP单元测试
weixin_30699465的博客
03-13 247
一、 这篇博客要对上次实现的四则运算进行单元测试，一是检查上次的程序的实现情况，二是巩固单元测试的相关知识。本次进行单元测试用的是Riget-BICEP方法。 Riget-BICEP方法： 1、Right－结果是否正确？ 2、B－是否所有的边界条件都是正确的？ 3、I－能查一下反向关联吗？...
四则运算2单元测试
weixin_30216561的博客
03-16 138
1 #include<iostream.h> 2 #include<stdlib.h> 3 #include<time.h> 4 void display(int number,int l,int mul,int num,int neg,int remainder)//打印方式控制输出列数 5 { 6 i...
5.1 实验五 四则运算单元测试
weixin_33670786的博客
04-30 192
5.1 实验五 四则运算单元测试 一、过程简介： 工作人员：邵家文 学号：201306114322 李泳江 学号：201306114314 博客：http://www.cnblogs.com/mch-29-wamc/ 分工：邵家文：将代码封装成类，用数据做测试 李泳江：记录数据，分析错误的原因。 ...
单元测试——四则运算2
言凡的博客
03-13 295
单元测试——四则运算2 编号 测试用例 使用原因 期望结果 实际结果 1 打印数量输入一百万 这个数很大 输出相应数量的题目 5分钟都没有打印完 2 打...
Jest测试-四则运算单元测试实验
weixin_43363720的博客
04-05 1555
一、Jest介绍 Jest 是 Facebook 出品的一个 JavaScript 开源测试框架。相对其他测试框架，其一大特点就是就是内置了常用的测试工具，比如零配置、自带断言、测试覆盖率工具等功能，实现了开箱即用。 Jest 适用但不局限于使用以下技术的项目：Babel,、TypeScript、 Node、 React、Angular、Vue 等。 二、Jest安装 1.项目安装Jest npm init -y npm install -D jest 2.package.json 添加脚本 "scrip
随机产生30道四则运算的程序单元测试
weixin_33807284的博客
03-14 169
四则运算单元测试 一、测试计划： 分模块进行测试，测试各部分模块功能是否能够实现，是否能够独立运行，是否能够实现重复允许，是否有报错处理等。 （1）在面对是否有乘除法运算时，输入“0”表示没有乘除法运算，输入“1”表示有乘除法运算，当输入其他数字时，则报错，要求重新输入； （2）在所有的“N”份题都含有乘除法运算时，测试有负数有余数、有负数无余数、无负数有余数、无负...
0-99点四则运算扑克游戏源码解析
资源摘要信息:"本项目为一个基于Python编写的四则运算扑克游戏源码，其功能是通过随机抽取去除J、Q、K后的扑克牌，计算出24点。程序经过拓展，可以计算出0到99点之间的任意数值，生成的清单可作为进一步开发游戏的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值