四则运算2单元测试

规范后的四则运算2源程序：

//四则运算程序2,从四则运算程序1的基础之上进行功能扩展
//支持真分数运算，题目不重复,最多可支持十个运算数的带括号的运算式
//多项四则运算式以及分数除法未予考虑余数，整数除法可以实现整除功能
//2016,03,09

#include<iostream>
#include<fstream>
#include<stdlib.h>
#include<time.h>
using namespace std;

void main()
{
	srand((int)time(NULL));
	//定义变量，记录用户的功能选择选项
	int minfigure;
	int maxfigure;
	int count;
	int chengchu;
	int remainder_chengchu;
	int negative_jiajian;
	int printstyle;
	//功能设置界面
	cout << "*******************************************************************" << endl;
	cout << "*                         四则运算生成器                          *" << endl;
	cout << "*******************************************************************" << endl;
	cout << "请按照系统提示设置生成器的功能：" << endl;
	cout << "请输入参与四则运算的数值范围(格式如：1  100)：" ;
	cin >> minfigure >> maxfigure;
	cout << "请输入生成四则运算式的数量：";
	cin >> count;
	cout << "请选择打印方式（1 屏幕输出  0 输出到文档）：";
	cin >> printstyle;
	cout << "请设置系统的下列参数：" << endl;
	cout << "    1 四则运算可否生成乘除法（1 是  0 否）：";
	cin >> chengchu;
	if (1 == chengchu)
	{
		cout << "    2 除法是否可有余数（1 是  0 否）：";
		cin >> remainder_chengchu;
	}
	else
	{
		cout << "    2 加减法是否可以有负数（1 是  0 否）：";
		cin >> negative_jiajian;
	}
	cout << "功能设置完成！" << endl;
	cout << "*******************************************************************" << endl;

	int i, j;
	int array_A[100];
	int array_B[100];
	int Operator[10];
	char operatorFu[9];
	int Operatorfu[9];
	//生成用户指定数量的运算式的因子，为保证算式不重复，让生成的随机数都不重复
	for (i = 0; i < count; i++)
	{
		array_A[i] = minfigure + rand() % maxfigure;
		array_B[i] = minfigure + rand() % maxfigure;
		for (j = 0; j < i; j++)
		{
			if (array_A[i] == array_A[j])
			{
				array_A[i] = minfigure + rand() % maxfigure;
				j = 0;
			}
			if (array_B[i] == array_B[j])
			{
				array_B[i] = minfigure + rand() % maxfigure;
				j = 0;
			}
		}
	}
	//根据用户的选择产生功能分支
	if (1 == printstyle)   //运算式输出到屏幕上
	{
		if (1 == chengchu)  //是否可以生成除法
		{
			if (remainder_chengchu)  //除法可否有余数，分数除法谈论是否有余数无意义
			{
				cout << "*******************************************************************" << endl;
				cout << "生成的四则运算式如下所示：" << endl;
				cout << "*******************************************************************" << endl;
				for (i = 0; i < count; i++)
				{
					if (array_A[i] > array_B[i])   //如果A[i]>B[i],则后续程序生成带括号的多项因子的四则运算
					{
						int m;
						int operator_count = 3 + rand() % 8;   //随机生成多项因子的个数
						int operatorfu_count = operator_count - 1;  //算符的个数比因子的个数少一
						for (m = 0; m < operator_count; m++)
						{
							Operator[m] = minfigure + rand() % maxfigure;   //生成多项因子
						}
						for (m = 0; m < operatorfu_count; m++)
						{
							Operatorfu[m] = rand() % 4;                  //生成多项式的算符
						}
						for (m = 1; m < operator_count; m++)
						{
							if ((Operatorfu[m] / 2)>(Operatorfu[m - 1] / 2))  //乘除用3和4表示，加减用1和2表示，让其除以二得商0和1，可以区分出乘除为同一优先级，加减比乘除优先级低
							{                                                 //若后一个运算符的优先级比前一个运算符的优先级高，则将前一个运算符对应的式子用括号括起来，确保了运算优先级低的加减运算在括号里面
								switch (Operatorfu[m - 1])
								{
								case 0:
									cout << "(" << Operator[m - 1] << " + " << Operator[m] << ")"; break;
								case 1:
									cout << "(" << Operator[m - 1] << " - " << Operator[m] << ")"; break;
								case 2:
									cout << "(" << Operator[m - 1] << " x " << Operator[m] << ")"; break;
								case 3:
									if (0 == Operator[m])
									{
										cout << "(" << Operator[m - 1] << " ÷ " << Operator[m] + 2 << ")";
									}
									break;   //若分子为零时，则让分子加2，即除以2
								}
								switch (Operatorfu[m])
								{
								case 0:
									cout << " + "; m = m + 1; break;
								case 1:
									cout << " - "; m = m + 1; break;
								case 2:
									cout << " x "; m = m + 1; break;
								case 3:
									cout << " ÷ "; m = m + 1; break;
								}
							}
							else
							{
								switch (Operatorfu[m - 1])
								{
								case 0:
									cout << Operator[m - 1] << " + "; break;
								case 1:
									cout << Operator[m - 1] << " - "; break;
								case 2:
									cout << Operator[m - 1] << " x "; break;
								case 3:
									cout << Operator[m - 1] << " ÷ "; break;
								}
							}
						}
						cout << Operator[m - 1] << " = " << endl;         //输出最后一个多项式因子
					}
					else            //如果A[i]<B[i],则产生真分数运算式
					{
						int copyA = array_A[i];
						int copyB = array_B[i];
						int beichushuA = maxfigure;
						int beichushuB = maxfigure;
						int firstA = beichushuA% copyA;
						int firstB = beichushuB% copyB;
						while (firstA != 0)        //求A[i]和最大值的公约数，以便后面化简
						{
							int temp = copyA;
							copyA = beichushuA%copyA;
							beichushuA = temp;
							firstA = beichushuA%copyA;
						}
						while (firstB != 0)
						{
							int temp = copyB;
							copyB = beichushuB%copyB;
							beichushuB = temp;
							firstB = beichushuB%copyB;
						}
						int suanfu = rand() % 4;
						switch (suanfu)
						{
						case 0:
							cout << array_A[i] / copyA << "/" << maxfigure / copyA << " + " << array_B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
						case 1:
							cout << array_A[i] / copyA << "/" << maxfigure / copyA << " - " << array_B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
						case 2:
							cout << array_A[i] / copyA << "/" << maxfigure / copyA << " x " << array_B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
						case 3:
							cout << array_A[i] / copyA << "/" << maxfigure / copyA << " ÷ " << array_B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
							//让A[i]和最大值都除以公约数便可以得到无法再约分的最大公约数
						}
					}
				}
			}
			else
			{
				cout << "*******************************************************************" << endl;
				cout << "生成的四则运算式如下所示：" << endl;
				cout << "*******************************************************************" << endl;
				for (i = 0; i < count; i++)
				{
					if (array_A[i] > array_B[i])
					{
						int m;
						int operator_count = 3 + rand() % 8;
						int operatorfu_count = operator_count - 1;
						for (m = 0; m < operator_count; m++)
						{
							Operator[m] = minfigure + rand() % maxfigure;
						}
						for (m = 0; m < operatorfu_count; m++)
						{
							Operatorfu[m] = rand() % 4;
						}
						for (m = 1; m < operator_count; m++)
						{
							if ((Operatorfu[m] / 2)>(Operatorfu[m - 1] / 2))
							{
								switch (Operatorfu[m - 1])
								{
								case 0:
									cout << "(" << Operator[m - 1] << " + " << Operator[m] << ")"; break;
								case 1:
									cout << "(" << Operator[m - 1] << " - " << Operator[m] << ")"; break;
								case 2:
									cout << "(" << Operator[m - 1] << " x " << Operator[m] << ")"; break;
								case 3:
									if (0 == Operator[m])
									{
										cout << "(" << Operator[m - 1] << " ÷ " << Operator[m] + 2 << ")";
									}
									break;
								}
								switch (Operatorfu[m])
								{
								case 0:
									cout << " + "; m = m + 1; break;
								case 1:
									cout << " - "; m = m + 1; break;
								case 2:
									cout << " x "; m = m + 1; break;
								case 3:
									cout << " ÷ "; m = m + 1; break;
								}
							}
							else
							{
								switch (Operatorfu[m - 1])
								{
								case 0:
									cout << Operator[m - 1] << " + "; break;
								case 1:
									cout << Operator[m - 1] << " - "; break;
								case 2:
									cout << Operator[m - 1] << " x "; break;
								case 3:
									cout << Operator[m - 1] << " ÷ "; break;
								}
							}
						}
						cout << Operator[m - 1] << " = " << endl;
					}
					else
					{
						int copyB = array_B[i];
						int first = array_B[i] % array_A[i];
						while (first != 0)
						{
							int temp = array_A[i];
							array_A[i] = array_B[i] % array_A[i];
							array_B[i] = temp;
							first = array_B[i] % array_A[i];
						}
						int suanfu = rand() % 4;
						switch (suanfu)
						{
						case 0:
							cout << array_A[i] << " + " << array_B[i] << "=" << endl; break;
						case 1:
							cout << array_A[i] << " - " << array_B[i] << "=" << endl; break;
						case 2:
							cout << array_A[i] << " x " << array_B[i] << "=" << endl; break;
						case 3:
							cout << copyB << " ÷ " << array_A[i] << " = " << endl; break;
						}
					}
				}
			}
		}
		else   //不允许生成乘除法，则只有加减法
		{
			if ((minfigure < 0) && (0 == negative_jiajian))  //若加减法不允许出现负数，则应该重新设定数值的范围，让最小值大于零，保证生成的随机数都是大于零的
			{
				cout << "请重新设置数值范围，最小值应大于零以保证加法无负数！" << endl;
				cout << "请输入参与四则运算的数值范围(格式如：1  100)：";
				cin >> minfigure >> maxfigure;
				for (i = 0; i < count; i++)     //重新生成的随机数仍是不重复的
				{
					array_A[i] = minfigure + rand() % maxfigure;
					array_B[i] = minfigure + rand() % maxfigure;
					for (j = 0; j < i; j++)
					{
						if (array_A[i] == array_A[j])
						{
							array_A[i] = minfigure + rand() % maxfigure;
							j = 0;
						}
						if (array_B[i] == array_B[j])
						{
							array_B[i] = minfigure + rand() % maxfigure;
							j = 0;
						}
					}
				}
			}
			for (i = 0; i < count; i++)
			{
				if (array_A[i]>array_B[i])
				{
					int suanfu = rand() % 2;
					switch (suanfu)
					{
					case 0:
						cout << array_A[i] << " + " << array_B[i] << "=" << endl; break;
					case 1:
						cout << array_A[i] << " - " << array_B[i] << "=" << endl; break;
					}
				}
				else
				{
					int copyA = array_A[i];
					int copyB = array_B[i];
					int beichushuA = maxfigure;
					int beichushuB = maxfigure;
					int firstA = beichushuA% copyA;
					int firstB = beichushuB% copyB;
					while (firstA != 0)
					{
						int temp = copyA;
						copyA = beichushuA%copyA;
						beichushuA = temp;
						firstA = beichushuA%copyA;
					}
					while (firstB != 0)
					{
						int temp = copyB;
						copyB = beichushuB%copyB;
						beichushuB = temp;
						firstB = beichushuB%copyB;
					}
					int suanfu = rand() % 2;
					switch (suanfu)
					{
					case 0:
						cout << array_A[i] / copyA << "/" << maxfigure / copyA << " + " << array_B[i] / copyB << "/" << maxfigure / copyB << "=" << endl; break;
					case 1:
						cout << array_B[i] / copyB << "/" << maxfigure / copyB << " - " << array_A[i] / copyA << "/" << maxfigure / copyA << "=" << endl; break;
					}
				}
			}
		}
	}
	else  //将最后生成的四则运算式存到文件中，内部实现的功能与输出到屏幕一致，只是输出不一样
	{
		if (1 == chengchu)
		{
			if (remainder_chengchu)
			{
				ofstream fileout;  //定义输出文件流的对象
				fileout.open("biaodashi.txt", ios::out);  //打开文件，该文件为指定路径，则存放在工程的当前目录下
				fileout << "*******************************************************************" << endl;
				fileout << "生成的四则运算式如下所示：" << endl;
				fileout << "*******************************************************************" << endl;
				for (i = 0; i < count; i++)
				{
					if (array_A[i] > array_B[i])
					{
						int m;
						int operator_count = 3 + rand() % 8;
						int operatorfu_count = operator_count - 1;
						for (m = 0; m < operator_count; m++)
						{
							Operator[m] = minfigure + rand() % maxfigure;
						}
						for (m = 0; m < operatorfu_count; m++)
						{
							Operatorfu[m] = rand() % 4;
						}
						for (m = 1; m < operator_count; m++)
						{
							if ((Operatorfu[m] / 2)>(Operatorfu[m - 1] / 2))
							{
								switch (Operatorfu[m - 1])
								{
								case 0:
									fileout << "(" << Operator[m - 1] << " + " << Operator[m] << ")"; break;
								case 1:
									fileout << "(" << Operator[m - 1] << " - " << Operator[m] << ")"; break;
								case 2:
									fileout << "(" << Operator[m - 1] << " x " << Operator[m] << ")"; break;
								case 3:
									if (0 == Operator[m])
									{
										fileout << "(" << Operator[m - 1] << " ÷ " << Operator[m] + 2 << ")";
									}
									break;
								}
								switch (Operatorfu[m])
								{
								case 0:
									fileout << " + "; m = m + 1; break;
								case 1:
									fileout << " - "; m = m + 1; break;
								case 2:
									fileout << " x "; m = m + 1; break;
								case 3:
									fileout << " ÷ "; m = m + 1; break;
								}
							}
							else
							{
								switch (Operatorfu[m - 1])
								{
								case 0:
									fileout << Operator[m - 1] << " + "; break;
								case 1:
									fileout << Operator[m - 1] << " - "; break;
								case 2:
									fileout << Operator[m - 1] << " x "; break;
								case 3:
									fileout << Operator[m - 1] << " ÷ "; break;
								}
							}
						}
						fileout << Operator[m - 1] << " = " << endl;
					}
					else
					{
						int copyA = array_A[i];
						int copyB = array_B[i];
						int beichushuA = maxfigure;
						int beichushuB = maxfigure;
						int firstA = beichushuA% copyA;
						int firstB = beichushuB% copyB;
						while (firstA != 0)
						{
							int temp = copyA;
							copyA = beichushuA%copyA;
							beichushuA = temp;
							firstA = beichushuA%copyA;
						}
						while (firstB != 0)
						{
							int temp = copyB;
							copyB = beichushuB%copyB;
							beichushuB = temp;
							firstB = beichushuB%copyB;
						}
						int suanfu = rand() % 4;
						switch (suanfu)
						{
						case 0:
							fileout << array_A[i] / copyA << "/" << maxfigure / copyA << " + " << array_B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
						case 1:
							fileout << array_A[i] / copyA << "/" << maxfigure / copyA << " - " << array_B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
						case 2:
							fileout << array_A[i] / copyA << "/" << maxfigure / copyA << " x " << array_B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
						case 3:
							fileout << array_A[i] / copyA << "/" << maxfigure / copyA << " ÷ " << array_B[i] / copyB << "/" << maxfigure / copyB << " = " << endl; break;
						}
					}
				}
				fileout.close();   //关闭文件，断开与文件连接
			}
			else
			{
				ofstream fileout;
				fileout.open("biaodashi.txt", ios::out);
				fileout << "*******************************************************************" << endl;
				fileout << "生成的四则运算式如下所示：" << endl;
				fileout << "*******************************************************************" << endl;
				for (i = 0; i < count; i++)
				{
					if (array_A[i] > array_B[i])
					{
						int m;
						int operator_count = 3 + rand() % 8;
						int operatorfu_count = operator_count - 1;
						for (m = 0; m < operator_count; m++)
						{
							Operator[m] = minfigure + rand() % maxfigure;
						}
						for (m = 0; m < operatorfu_count; m++)
						{
							Operatorfu[m] = rand() % 4;
						}
						for (m = 1; m < operator_count; m++)
						{
							if ((Operatorfu[m] / 2)>(Operatorfu[m - 1] / 2))
							{
								switch (Operatorfu[m - 1])
								{
								case 0:
									fileout << "(" << Operator[m - 1] << " + " << Operator[m] << ")"; break;
								case 1:
									fileout << "(" << Operator[m - 1] << " - " << Operator[m] << ")"; break;
								case 2:
									fileout << "(" << Operator[m - 1] << " x " << Operator[m] << ")"; break;
								case 3:
									if (0 == Operator[m])
									{
										fileout << "(" << Operator[m - 1] << " ÷ " << Operator[m] + 2 << ")";
									}
									break;
								}
								switch (Operatorfu[m])
								{
								case 0:
									fileout << " + "; m = m + 1; break;
								case 1:
									fileout << " - "; m = m + 1; break;
								case 2:
									fileout << " x "; m = m + 1; break;
								case 3:
									fileout << " ÷ "; m = m + 1; break;
								}
							}
							else
							{
								switch (Operatorfu[m - 1])
								{
								case 0:
									fileout << Operator[m - 1] << " + "; break;
								case 1:
									fileout << Operator[m - 1] << " - "; break;
								case 2:
									fileout << Operator[m - 1] << " x "; break;
								case 3:
									fileout << Operator[m - 1] << " ÷ "; break;
								}
							}
						}
						fileout << Operator[m - 1] << " = " << endl;
					}
					else
					{
						int copyB = array_B[i];
						int first = array_B[i] % array_A[i];
						while (first != 0)
						{
							int temp = array_A[i];
							array_A[i] = array_B[i] % array_A[i];
							array_B[i] = temp;
							first = array_B[i] % array_A[i];
						}
						int suanfu = rand() % 4;
						switch (suanfu)
						{
						case 0:
							fileout << array_A[i] << " + " << array_B[i] << "=" << endl; break;
						case 1:
							fileout << array_A[i] << " - " << array_B[i] << "=" << endl; break;
						case 2:
							fileout << array_A[i] << " x " << array_B[i] << "=" << endl; break;
						case 3:
							fileout << copyB << " ÷ " << array_A[i] << " = " << endl; break;
						}
					}
				}
				fileout.close();
			}
		}
		else
		{
			if ((minfigure < 0) && (0 == negative_jiajian))
			{
				cout << "请重新设置数值范围，最小值应大于零以保证加法无负数！" << endl;
				cout << "请输入参与四则运算的数值范围(格式如：1  100)：";
				cin >> minfigure >> maxfigure;
				for (i = 0; i < count; i++)
				{
					array_A[i] = minfigure + rand() % maxfigure;
					array_B[i] = minfigure + rand() % maxfigure;
					for (j = 0; j < i; j++)
					{
						if (array_A[i] == array_A[j])
						{
							array_A[i] = minfigure + rand() % maxfigure;
							j = 0;
						}
						if (array_B[i] == array_B[j])
						{
							array_B[i] = minfigure + rand() % maxfigure;
							j = 0;
						}
					}
				}
			}
			ofstream fileout;
			fileout.open("biaodashi.txt", ios::out);
			for (i = 0; i < count; i++)
			{
				if (array_A[i]>array_B[i])
				{
					int suanfu = rand() % 2;
					switch (suanfu)
					{
					case 0:
						fileout << array_A[i] << " + " << array_B[i] << "=" << endl; break;
					case 1:
						fileout << array_A[i] << " - " << array_B[i] << "=" << endl; break;
					}
				}
				else
				{
					int copyA = array_A[i];
					int copyB = array_B[i];
					int beichushuA = maxfigure;
					int beichushuB = maxfigure;
					int firstA = beichushuA% copyA;
					int firstB = beichushuB% copyB;
					while (firstA != 0)
					{
						int temp = copyA;
						copyA = beichushuA%copyA;
						beichushuA = temp;
						firstA = beichushuA%copyA;
					}
					while (firstB != 0)
					{
						int temp = copyB;
						copyB = beichushuB%copyB;
						beichushuB = temp;
						firstB = beichushuB%copyB;
					}
					int suanfu = rand() % 2;
					switch (suanfu)
					{
					case 0:
						fileout << array_A[i] / copyA << "/" << maxfigure / copyA << " + " << array_B[i] / copyB << "/" << maxfigure / copyB << "=" << endl; break;
					case 1:
						fileout << array_B[i] / copyB << "/" << maxfigure / copyB << " - " << array_A[i] / copyA << "/" << maxfigure / copyA << "=" << endl; break;
					}
				}
			}
			fileout.close();
		}
	}
}

    Right-BICEP测试要求：

    1.Right－结果是否正确？

    2.B－是否所有的边界条件都是正确的？

    3.I－能查一下反向关联吗？

    4.C－能用其他手段交叉检查一下结果吗？

    5.E－你是否可以强制错误条件发生？

    6.P－是否满足性能要求？

    对四则运算2程序的测试用例如下：

    第一组测试用例：数值范围去1-465，输出数量为15，可生成除数，除数可以有余数

    最大值465为随便输入的，1到465都为整数，是常规的数据，主要用来测试程序能否得到正确的结果，测试截图如下：

   

    第二组测试用例：数值范围-200到164，输出数量12，可以生成乘除法，整数除法无余数

    测试程序是否可以生成负数，对于负数参与运算，看程序能否获得正确的结果，测试结果如下所示：

   

    第三组测试用例：数值范围0-1，输出数量10，可生成乘除法，有余数

    测试除数为零时是否与可以继续执行，测试结果如下所示：

   

    程序出现错误，无法执行，查找程序源代码得知，为保证题目数量不重复，随机产生的每一个数都是不同的，因此，数值的范围必须大于输出的数量程序才可以后续执行。

    修改后的运行结果为：

   

    第四组测试用例：数值范围0-3，输出数量1，可以生成乘除法，无余数

    主要为测试数据除数为零是是否能继续执行，测试结果如下所示：

   

    程序出现未知的错误，程序中若除数为零时，加入了相应的处理语句，但是不知为何还存在错误，该错误暂时还没有得到解决。

   第五组测试数据：数值范围-123-4897，输出数量50，屏幕输出，不可生成乘除法，加减无负数

    主要为测试程序生成负数时，如何保证加减法无负数，测试结果如下所示：

   

    第六组测试数据：数值范围-465 到-12，输出数量5 ，保存到文件，不可生成乘除法，加减有负数

    主要测试程序最后的结果能否保存到文件，测试结果如下所示：