随机四则运算的单元测试5.1

进行单元测试步骤:

第一步：将所有的运算分类情况封装在Calculator类中：

import java.math.BigDecimal;
import java.text.DecimalFormat;
public class Calculator{
        long sum;
        char a[]={‘+‘,‘-‘,‘ב,‘÷‘};
        char b[]={‘+‘,‘-‘,‘ב,‘÷‘};
        public void IntegerandInteger(int b,int c,int d){
            if(a[b]==a[0])
            {
                sum=c+d;
            }
            else if(a[b]==a[1])
            {
                sum=c-d;
            }
            else if(a[b]==a[2])
            {
                sum=c*d;
            }
            else if(a[b]==a[3])
            {
                sum=(long) ((float)c/d);
            }
        }
        public void Integerandfraction(int b,int c,int d,int f){
            if(a[b]==a[0])
            {
                sum=(long) (c+(float)f/d);
            }
            else if(a[b]==a[1])
            {
                sum=(long) (c-(float)f/d);
            }
            else if(a[b]==a[2])
            {
                sum=(long) (c*((float)f/d));
            }
            else if(a[b]==a[3])
            {
                sum=(long) ((float)c/((float)f/d));
            }
        }
        public void fractionandfraction(int b,int c,int d,int g,int f){
            if(a[b]==a[0])
            {
                sum=(long) ((float)d/c+(float)g/f);
            }
            else if(a[b]==a[1])
            {
                sum=(long) ((float)d/c-(float)g/f);
            }
            else if(a[b]==a[2])
            {
                sum=(long) (((float)d/c)*((float)g/f));
            }
            else if(a[b]==a[3])
            {
                sum=(long) (((float)d/c)/((float)g/f));
            }
        }
        public void twoIntegerandfraction(int c,int d,int f,int g,int h,int l){
            if(a[c]==a[0])
            {
                if(b[d]==b[0])
                {
                    sum=(long) (f+g+(float)l/h);
                }
                else if(b[d]==b[1])
                {
                    sum=(long) (f+g-(float)l/h);
                }
                else if(b[d]==b[2])
                {
                    sum=(long) (f+g*((float)l/h));
                }
                else if(b[d]==b[3])
                {
                    sum=(long) (f+(float)g/((float)l/h));
                }
            }
            else if(a[c]==a[1])
            {
                if(b[d]==b[0])
                {
                    sum=(long) (f-g+(float)l/h);
                }
                else if(b[d]==b[1])
                {
                    sum=(long) (f-g-(float)l/h);
                }
                else if(b[d]==b[2])
                {
                    sum=(long) (f-g*((float)l/h));
                }

                else if(b[d]==b[3])
                {
                    sum=(long) (f-(float)g/((float)l/h));
                }
            }
            else if(a[c]==a[2])
            {
                if(b[d]==b[0])
                {
                    sum=(long) (f*g+(float)l/h);
                }
                else if(b[d]==b[1])
                {
                    sum=(long) (f*g-(float)l/h);
                }
                else if(b[d]==b[2])
                {
                    sum=(long) (f*g*((float)l/h));
                }
                else if(b[d]==b[3])
                {
                    sum=(long) ((float)f*g/((float)l/h));
                }
            }
            else if(a[c]==a[3])
            {
                if(b[d]==b[0])
                {
                    sum=(long) ((float)f/g+(float)l/h);
                }
                else if(b[d]==b[1])
                {
                    sum=(long) ((float)f/g-(float)l/h);
                }
                else if(b[d]==b[2])
                {
                    sum=(long) ((float)f/g*((float)l/h));
                }
                else if(b[d]==b[3])
                {
                    sum=(long) ((float)f/g/((float)l/h));
                }
            }
        }
        public void allfraction(int c,int d,int f,int g,int h,int l,int s,int p){
            if(a[c]==a[0])
            {
                if(b[d]==b[0])
                {
                    sum=(long) ((float)g/f+(float)l/h+(float)p/s);
                }
                else if(b[d]==b[1])
                {
                    sum=(long) ((float)g/f+(float)l/h-(float)p/s);
                }
                else if(b[d]==b[2])
                {
                    sum=(long) ((float)g/f+((float)l/h)*((float)p/s));
                }
                else if(b[d]==b[3])
                {
                    sum=(long) ((float)g/f+((float)l/h)/((float)p/s));
                }
            }
            else if(a[c]==a[1])
            {
                if(b[d]==b[0])
                {
                    sum=(long) ((float)g/f-(float)l/h+(float)p/s);
                }
                else if(b[d]==b[1])
                {
                    sum=(long) ((float)g/f-(float)l/h-(float)p/s);
                }
                else if(b[d]==b[2])
                {
                    sum=(long) ((float)g/f-((float)l/h)*((float)p/s));
                }
                else if(b[d]==b[3])
                {
                    sum=(long) ((float)g/f-((float)l/h)/((float)p/s));
                }
            }
            else if(a[c]==a[2])
            {
                if(b[d]==b[0])
                {
                    sum=(long) (((float)g/f)*((float)l/h)+(float)p/s);
                }
                else if(b[d]==b[1])
                {
                    sum=(long) (((float)g/f)*((float)l/h)-(float)p/s);
                }
                else if(b[d]==b[2])
                {
                    sum=(long) (((float)g/f)*((float)l/h)*((float)p/s));
                }
                else if(b[d]==b[3])
                {
                    sum=(long) (((float)g/f)*((float)l/h)/((float)p/s));
                }
            }
            else if(a[c]==a[3])
            {
                if(b[d]==b[0])
                {
                    sum=(long) (((float)g/f)/((float)l/h)+(float)p/s);
                }
                else if(b[d]==b[1])
                {
                    sum=(long) (((float)g/f)/((float)l/h)-(float)p/s);
                }
                else if(b[d]==b[2])
                {
                    sum=(long) (((float)g/f)/((float)l/h)*((float)p/s));
                }
                else if(b[d]==b[3])
                {
                    sum=(long) (((float)g/f)/((float)l/h)/((float)p/s));
                }
            }
        }
        public void allInteger(int c,int d,int f,int g,int h){
            if(a[c]==a[0])
            {
                if(b[d]==b[0])
                {
                    sum=f+g+h;
                }
                else if(b[d]==b[1])
                {
                    sum=f+g-h;
                }
                else if(b[d]==b[2])
                {
                    sum=f+g*h;
                }
                else if(b[d]==b[3])
                {
                    sum=(long) (f+(float)g/h);
                }
            }
            else if(a[c]==a[1])
            {
                if(b[d]==b[0])
                {
                    sum=f-g+h;
                }
                else if(b[d]==b[1])
                {
                    sum=f-g-h;
                }
                else if(b[d]==b[2])
                {
                    sum=f-g*h;
                }

                else if(b[d]==b[3])
                {
                    sum=(long) (f-(float)g/h);
                }
            }
            else if(a[c]==a[2])
            {
                if(b[d]==b[0])
                {
                    sum=f*g+h;
                }
                else if(b[d]==b[1])
                {
                    sum=f*g-h;
                }
                else if(b[d]==b[2])
                {
                    sum=f*g*h;
                }
                else if(b[d]==b[3])
                {
                    sum=(long) ((float)f*g/h);
                }
            }
            else if(a[c]==a[3])
            {
                if(b[d]==b[0])
                {
                    sum=(long) ((float)f/g+h);
                }
                else if(b[d]==b[1])
                {
                    sum=(long) ((float)f/g-h);
                }
                else if(b[d]==b[2])
                {
                    sum=(long) ((float)f/g*h);
                }
                else if(b[d]==b[3])
                {
                    sum=(long) ((float)f/g/h);
                }
            }
        }
        public void Integerandtwofraction(int c,int d,int f,int g,int h,int l,int s){
            if(a[c]==a[0])
            {
                if(b[d]==b[0])
                {
                    sum=(long) (f+(float)h/g+(float)s/l);
                }
                else if(b[d]==b[1])
                {
                    sum=(long) (f+(float)h/g-(float)s/l);
                }
                else if(b[d]==b[2])
                {
                    sum=(long) (f+((float)h/g)*((float)s/l));
                }
                else if(b[d]==b[3])
                {
                    sum=(long) (f+((float)h/g)/((float)s/l));
                }
            }
            else if(a[c]==a[1])
            {
                if(b[d]==b[0])
                {
                    sum=(long) (f-(float)h/g+(float)s/l);
                }
                else if(b[d]==b[1])
                {
                    sum=(long) (f-(float)h/g-(float)s/l);
                }
                else if(b[d]==b[2])
                {
                    sum=(long) (f-((float)h/g)*((float)s/l));
                }
                else if(b[d]==b[3])
                {
                    sum=(long) (f-((float)h/g)/((float)s/l));
                }
            }
            else if(a[c]==a[2])
            {
                if(b[d]==b[0])
                {
                    sum=(long) (f*((float)h/g)+(float)s/l);
                }
                else if(b[d]==b[1])
                {
                    sum=(long) (f*((float)h/g)-(float)s/l);
                }
                else if(b[d]==b[2])
                {
                    sum=(long) (f*((float)h/g)*((float)s/l));
                }
                else if(b[d]==b[3])
                {
                    sum=(long) (f*((float)h/g)/((float)s/l));
                }
            }
            else if(a[c]==a[3])
            {
                if(b[d]==b[0])
                {
                    sum=(long) (f/((float)h/g)+(float)s/l);
                }
                else if(b[d]==b[1])
                {
                    sum=(long) (f/((float)h/g)-(float)s/l);
                }
                else if(b[d]==b[2])
                {
                    sum=(long) (f/((float)h/g)*((float)s/l));
                }
                else if(b[d]==b[3])
                {
                    sum=(long) (f/((float)h/g)/((float)s/l));
                }
            }
        }
        public long getSum(){
            return sum;
        }
}

第二步：将JUnit4单元测试包引入这个项目中

第三步，生成JUnit测试框架，之后系统会自动生成一个新类CalculatorTest，再根据情况完善CalculatorTest类里面的代码，完整的CalculatorTest代码如下：

import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;
public class CalculatorTest {
    private Calculator calculator=new Calculator();
    @Before
    public void setUp() throws Exception {
    }

    @Test
    public void testIntegerandInteger() {
        calculator.IntegerandInteger(0,1,2);
        assertEquals(3, calculator.getSum());
    }

    @Test
    public void testIntegerandfraction() {
        calculator.Integerandfraction(0, 1, 2, 4);
        assertEquals(3,calculator.getSum());
    }

    @Test
    public void testFractionandfraction() {
        calculator.fractionandfraction(0,3,1,2,3);
        assertEquals(1,calculator.getSum());
    }

    @Test
    public void testTwoIntegerandfraction() {
        calculator.twoIntegerandfraction(0, 0, 2, 3, 1, 2);
        assertEquals(7,calculator.getSum());
    }

    @Test
    public void testAllfraction() {
        calculator.allfraction(0, 0, 5, 3, 5, 4, 5, 3);
        assertEquals(2,calculator.getSum());
    }

    @Test
    public void testAllInteger() {
        calculator.allInteger(0, 0, 3, 4, 5);
        assertEquals(12,calculator.getSum());
    }

    @Test
    public void testIntegerandtwofraction() {
        calculator.Integerandtwofraction(0, 0, 3, 5, 2, 5, 3);
        assertEquals(4,calculator.getSum());
    }

    @Test
    public void testFactorial() {
        calculator.Factorial(3);
        assertEquals(6,calculator.getSum());
    }

}

第四步，运行测试代码，结果如下：

白盒测试与黑盒测试：

白盒测试：

IntegerandInteger白盒测试：


当c=4,d=4时

判断
条件
结果

a[b]==a[0]
8

a[b]==a[1]
0

a[b]==a[2]
16

a[b]==a[3]
1

上面的白盒演示是整数与整数的两项测试，其余形式两项的白盒测试情况同上。

twoIntegerandfraction白盒测试：


当f=1,g=3,l=4,h=2

判断
一级条件
二级条件
结果

a[c]==a[0]
b[d]==b[0]
6

b[d]==b[1]
2

b[d]==b[2]
8

b[d]==b[3]
2

a[c]==a[1]
b[d]==b[0]
0

b[d]==b[1]
-4

b[d]==b[2]
-4

b[d]==b[3]
-1

a[c]==a[2]
b[d]==b[0]
5

b[d]==b[1]
1

b[d]==b[2]
6

b[d]==b[3]
1.5

a[c]==a[3]
b[d]==b[0]
2.33

b[d]==b[1]
-1.67

b[d]==b[2]
0.67

b[d]==b[3]
0.17

上面的白盒演示是两个整数与一个分数的三项测试，其余形式三项的白盒测试情况同上。

Factorial白盒测试：


当a=3时

判断
条件
结果

a==0
1

a!=0
6

上面的白盒演示是阶乘的测试。

黑盒测试:


测试内容
期望结果
实际结果

窗口中框中数据非正常输入
有相应的提示窗口弹出，提示输入错误
没有窗口弹出提示输入的不规范

通过黑盒的测试，将原代码进行改进，改进后运行截图如下：

实验总结：

本次的实验由于某种原因未能结对完成，这是一个比较遗憾的事情，但是通过本次的实验我却收获了不少。我知道了如何写单元测试以及如何做黑白盒的测试，以后写代码也可以通过本次实验的方法，这样可以使我们的代码更加完善，有关核心算法的出错几率会相应地减少。在单元测试的过程中出现了一些问题，至今还是不明白，例如：为什么返回计算的结果时，如果返回的是double或者float型测试的时候总是提示错误，如果把它改成int或者long型的话就不会出现这个问题。在黑白盒测试的时候，感觉黑盒测试比白盒测试更加好，因为黑盒测试有点像我们的用户，用户根本不知道我们的代码是如何的，他肯定是不按情理出牌的，这样更加有利于我们该软件的完善，对各种情况都可以考虑到，是开发出来的软件更加人性化。

虽然刚开始做实验的时候觉得无从下手，都有了不想写的念头了，但是通过查阅相关的资料发现，原来单元测试是这么有用的，再一步一步的写下去，才感受到了它的益处，其知道它是和我们做好一个软件息息相关。本次实验真是收获颇丰。

时间： 2024-07-28 20:25:27

随机四则运算的单元测试5.1的相关文章

随机四则运算 C语言

设计思想:出三十道一百以内数的随机四则运算题目,先随机两个一百以内的数字,再通过随机数确定四则运算算符,最后通过for循环输出三十道 源代码程序: #include <stdlib.h>#include <iostream.h>#include <conio.h>#include <time.h>int main(){ int a = 0; int b = 0; int mode = 0;//0:加 1:减 2:乘 3:除 int i = 0; srand(

随机四则运算的改进

#include<stdio.h> int Menu() { int choic; printf("\n\n\n******************************************\n"); printf("1.四则运算整数习题(试卷型)\n"); printf("2.四则运算真分数习题(试卷型)\n"); printf("3.四则运算整数习题(同步练习型)\n"); printf("4.

300道随机四则运算小程序（java编写）

这是由Java编写的300道随机四则运算小程序, 运算数范围为0~100(不包括100),运算结果保留两位小数. 程序代码: import java.util.*; class Yunsuan{ public static void main(String[] args){ Random rand = new Random(); for(int i = 0; i < 300; i++){ int num1 = (int)(rand.nextDouble() * 100); int num2 =

BICEP单元测试——随机四则运算升级版

一.测试方法 6个值得测试的具体部位: Right-结果是否正确? B-是否所有的边界条件都是正确的? I-能查一下反向关联吗? C-能用其他手段交叉检查一下结果吗? E-你是否可以强制错误条件发生? P-是否满足性能要求? 二.测试部分 case 3: if(c[5] == 1) //判断选择是否有余数,如果能有余数 { printf("%d/%d = ",a, b ); } else if(a%b!=0) //如果不能有余数 { i = i-1; } else { printf(&

C#窗体-&gt;&gt;随机四则运算

用户需求: 程序能接收用户输入的整数答案,并判断对错程序结束时,统计出答对.答错的题目数量.补充说明:0——10的整数是随机生成的用户可以选择四则运算中的一种用户可以结束程序的运行,并显示统计结果.在此基础上,做增量开发.增量内容:1)处理用户的错误输入,比如输入字母或符号等,处理除法运算中分母为0的情况,处理结果为负数的情况,保证是小学水平不出现负数,比如不能出现5-8=-3这种情况:               2)用户可以设定倒计时:               3)用户可以设定随机整数的

随机四则运算1.1版

之前写的四则运算1.0版,现在继续扩充 : <四则运算>题目的功能,要求: 题目避免重复:可以定制数量和打印方式: 可以控制下列参数 (1) 是否有乘除法 (2) 是否有括号 (3) 数值范围 (4) 加减有无负数 (5) 除法有无余数 (6) 是否支持分数(真分数.假分数…) (7) 是否支持小数(精确到多少位?) (8) 打印中每行的间隔 先上图看主要界面,及功能区,如下: 1: 一如既往的用JS来写,自认为在界面上可以做到更美观,功能也可以完全做到, 那么找几个功能来演示,那么就从默认条

随机四则运算的生成

这是一道简单的编程,随机的生成四则运算,不过还是不是很完美,还有一些欠缺! 源代码: #include<iostream.h>#include<time.h>#include<stdlib.h>void main(){ int a,b,i,op,r;//r记录回答结果 int flag=1; while(flag) { for(i=0;i<30;i++) { srand(time(0)); a = rand() % 100+1; b = rand() % 100+

软件工程随堂练习——随机四则运算

题目要求随机生成30道四则运算题目,则主体部分采用循环结构,运算符的随机产生则用随机数的模运算控制 源代码: #include<iostream>using namespace std;void main(){ for(int i=0;i<30;i++) {  int a=rand()%100;  int b=rand()%100;  int c=rand()%4;  switch(c)  {  case(0):   cout<<a<<"+"&

随机四则运算

题目:二柱子要为上二年级的儿子编写一个程序.本程序要求随机产生30道四则运算的题目. 编程思路:在这道题中一共有三个需要随机产生的变量,即第一操作数.符号(+.-.*./)和第二操作数.第一操作数和第二操作数的随机产生比较简单,并将其设置在100以内.但遇到随机符号的时候,我也将其转化成了对数字的随机,即运用if函数,通过对四个数的随机来对应指定的符号.最后用for函数将整体循环输出30次即可. 程序代码: #include<iostream.h> #include<stdlib.h&g