实验五单元测试

一、实验目的

1）掌握单元测试的方法

2) 学习XUnit测试原理及框架；

3）掌握使用测试框架进行单元测试的方法和过程。

二、实验内容与要求

1、了解单元测试的原理与框架

1.1 单元测试原理

单元测试，是指对软件中的最小可测试单元进行检查和验证。对于单元测试中单元的含义，一般来说，要根据实际情况去判定其具体含义，如C语言中单元指一个函数，Java里单元指一个类，图形化的软件中可以指一个窗口或一个菜单等。总的来说，单元就是人为规定的最小的被测功能模块。单元测试是在软件开发过程中要进行的最低级别的测试活动，软件的独立单元将在与程序的其他部分相隔离的情况下进行测试。单元测试是由程序员自己来完成，最终受益的也是程序员自己。可以这么说，程序员有责任编写功能代码，同时也就有责任为自己的代码编写单元测试。执行单元测试，就是为了证明这段代码的行为和我们期望的一致。

单元测试的内容包括

模块接口测试、局部数据结构测试、路径测试、错误处理测试、边界测试

（1）模块接口测试

模块接口测试是单元测试的基础。只有在数据能正确流入、流出模块的前提下，其他测试才有意义。模块接口测试也是集成测试的重点，这里进行的测试主要是为后面打好基础。测试接口正确与否应该考虑下列因素：

-输入的实际参数与形式参数的个数是否相同

-输入的实际参数与形式参数的属性是否匹配

-输入的实际参数与形式参数的量纲是否一致

-调用其他模块时所给实际参数的个数是否与被调模块的形参个数相同；

-调用其他模块时所给实际参数的属性是否与被调模块的形参属性匹配；

-调用其他模块时所给实际参数的量纲是否与被调模块的形参量纲一致；

-调用预定义函数时所用参数的个数、属性和次序是否正确；

-是否存在与当前入口点无关的参数引用；

-是否修改了只读型参数；

-对全程变量的定义各模块是否一致；

-是否把某些约束作为参数传递。

如果模块功能包括外部输入输出，还应该考虑下列因素：

-文件属性是否正确；

-OPEN/CLOSE语句是否正确；

-格式说明与输入输出语句是否匹配；

-缓冲区大小与记录长度是否匹配；

-文件使用前是否已经打开；

-是否处理了文件尾；

-是否处理了输入/输出错误；

-输出信息中是否有文字性错误。

-局部数据结构测试；

-边界条件测试；

-模块中所有独立执行通路测试；

（2）局部数据结构测试

检查局部数据结构是为了保证临时存储在模块内的数据在程序执行过程中完整、正确，局部功能是整个功能运行的基础。重点是一些函数是否正确执行，内部是否运行正确。局部数据结构往往是错误的根源，应仔细设计测试用例，力求发现下面几类错误：

-不合适或不相容的类型说明；

-变量无初值；

-变量初始化或省缺值有错；

-不正确的变量名（拼错或不正确地截断）；

-出现上溢、下溢和地址异常。

（3）边界条件测试

边界条件测试是单元测试中最重要的一项任务。众所周知，软件经常在边界上失效，采用边界值分析技术，针对边界值及其左、右设计测试用例，很有可能发现新的错误。边界条件测试是一项基础测试，也是后面系统测试中的功能测试的重点，边界测试执行的较好，可以大大提高程序健壮性。

（4）独立路径测试

在模块中应对每一条独立执行路径进行测试，单元测试的基本任务是保证模块中每条语句至少执行一次。测试目的主要是为了发现因错误计算、不正确的比较和不适当的控制流造成的错误。具体做法就是程序员逐条调试语句。常见的错误包括：

-误解或用错了算符优先级；

-混合类型运算；

-变量初值错；

-精度不够；

-表达式符号错。

（5）错误处理测试

检查模块的错误处理功能是否包含有错误或缺陷。例如，是否拒绝不合理的输入;出错的描述是否难以理解、是否对错误定位有误、是否出错原因报告有误、是否对错误条件的处理不正确;在对错误处理之前错误条件是否已经引起系统的干预等。

通常单元测试在编码阶段进行。在源程序代码编制完成，经过评审和验证，确认没有语法错误之后，就开始进行单元测试的测试用例设计。利用设计文档，设计可以验证程序功能、找出程序错误的多个测试用例。对于每一组输入，应有预期的正确结果。

1.2 测试框架

xUnit是各种代码驱动测试框架的统称,这些框架可以测试软件的不同内容(单元),比如函数和类。xUnit框架的主要优点是,它提供了一个自动化测试的解决方案。可以避免多次编写重复的测试代码。

底层是xUnit的framwork，xUnit的类库，提供了对外的功能方法、工具类、api等

TestCase(具体的测试用例)去使用framwork

TestCase执行后会有TestResult

使用TestSuite控制TestCase的组合

TestRunner执行器，负责执行case

TestListener过程监听，监听case成功失败以及数据结果，输出到结果报告中

Unit测试框架包括四个要素：

(1)测试目标（对象）

一组认定被测对象或被测程序单元测试成功的预定条件或预期结果的设定。Fixture就是被测试的目标，可以是一个函数、一组对象或一个对象。测试人员在测试前应了解被测试的对象的功能或行为。

（2）测试集

测试集是一组测试用例，这些测试用例要求有相同的测试Fixture，以保证这些测试不会出现管理上的混乱。

（3）测试执行

单个单元测试的执行可以按下面的方式进行：

第一步编写 setUp() 函数，目的是：建立针对被测试单元的独立测试环境；举个例子，这可能包含创建临时或代理的数据库、目录，再或者启动一个服务器进程。

第二步编写所有测试用例的测试体或者测试程序；

第三步编写tearDown()函数，目的是：无论测试成功还是失败，都将环境进行清理，以免影响后续的测试；

（4）断言

断言实际上就是验证被测程序在测试中的行为或状态的一个函数或者宏。断言的失败会引发异常，终止测试的执行。

1.3 面向特定语言的，基于xUnit框架的自动化测试框架

Junit ：主要测试用Java语言编写的代码

CPPunit：主要测试用C++语言编写的代码

unittest ， PyUnit：主要测试用python语言编写的代码

MiniUnit: 主要用于测试C语言编写的代码

三、实验过程

3.1、源码

  1 package imple;
  2 
  3 import java.util.*;
  4 
  5 public class calculate<optStack> {
  6      private Map<String, Map<String, String>> priorityMap = new HashMap<String, Map<String, String>>();
  7      private Stack<String> optStack = new Stack<String>();
  8      private Stack<Double> numStack = new Stack<Double>();
  9      
 10      public double calcualte1(String exp) {
 11       StringTokenizer vn = new StringTokenizer(exp);
 12       while (vn.hasMoreTokens()) {
 13        String token = vn.nextToken();
 14        transversion(token);
 15       }
 16       return numStack.pop();
 17      }
 18      public double calcualte(String exp) {
 19          char[] strExp = exp.toCharArray();
 20          for(char a: strExp){
 21              transversion(""+a+"");
 22          }
 23           return numStack.pop();
 24          }
 25 
 26      private void  transversion(String token) {
 27       while (false == "=".equals(optStack.peek()) || false == token.equals("=")) {
 28        if (true == judgenum(token)) {
 29             numStack.push(Double.parseDouble(token));
 30             break;
 31             
 32        } else {
 33             String priority = priority(optStack.peek(), token);
 34             if ("<".equals(priority)) {
 35              optStack.push(token);
 36              break;
 37             } else if ("=".equals(priority)) {
 38              optStack.pop();
 39              break;
 40             } else {
 41               double res = calculate(optStack.pop(), numStack.pop(), numStack.pop());
 42               numStack.push(res);
 43             }
 44        }
 45       }
 46      }
 47 
 48      private double calculate(String opt, double a1, double a2) {
 49       if ("+".equals(opt)) {
 50        return a2 + a1;
 51       } else if ("-".equals(opt)) {
 52        return a2 - a1;
 53       } else if ("*".equals(opt)) {
 54        return a2 * a1;
 55       } else if ("/".equals(opt)) {
 56        return a2 / a1;
 57       } else {
 58        throw new RuntimeException("unsupported operator:" + opt);
 59       }
 60      }
 61 
 62      private boolean judgenum(String token) {
 63       int LEN = token.length();
 64       for (int ix = 0 ; ix < LEN ; ++ix) {
 65        char ch = token.charAt(ix);
 66        if (ch == '.') {
 67         continue;
 68        }
 69        if (false == judgenum(ch)) {
 70         return false;
 71        }
 72       }
 73       return true;
 74      }
 75 
 76      private boolean judgenum(char ch) {
 77       if (ch >= '0' && ch <= '9') {
 78        return true;
 79       }
 80       return false;
 81      }
 82 
 83      public String priority(String op1, String op2) {
 84       return priorityMap.get(op1).get(op2);
 85      }
 86 
 87      public calculate() {
 88 
 89       optStack.push("=");
 90       Map<String, String> subMap = new HashMap<String, String>();
 91       subMap.put("+", ">");
 92       subMap.put("-", ">");
 93       subMap.put("*", "<");
 94       subMap.put("/", "<");
 95       subMap.put("(", "<");
 96       subMap.put(")", ">");
 97       subMap.put("=", ">");
 98       priorityMap.put("+", subMap);
 99       // -
100       subMap = new HashMap<String, String>();
101       subMap.put("+", ">");
102       subMap.put("-", ">");
103       subMap.put("*", "<");
104       subMap.put("/", "<");
105       subMap.put("(", "<");
106       subMap.put(")", ">");
107       subMap.put("=", ">");
108       priorityMap.put("-", subMap);
109       // *
110       subMap = new HashMap<String, String>();
111       subMap.put("+", ">");
112       subMap.put("-", ">");
113       subMap.put("*", ">");
114       subMap.put("/", ">");
115       subMap.put("(", "<");
116       subMap.put(")", ">");
117       subMap.put("=", ">");
118       priorityMap.put("*", subMap);
119       // /
120       subMap = new HashMap<String, String>();
121       subMap.put("+", ">");
122       subMap.put("-", ">");
123       subMap.put("*", ">");
124       subMap.put("/", ">");
125       subMap.put("(", "<");
126       subMap.put(")", ">");
127       subMap.put("=", ">");
128       priorityMap.put("/", subMap);
129       // (
130       subMap = new HashMap<String, String>();
131       subMap.put("+", "<");
132       subMap.put("-", "<");
133       subMap.put("*", "<");
134       subMap.put("/", "<");
135       subMap.put("(", "<");
136       subMap.put(")", "=");
137       //subMap.put("#", ">");
138       priorityMap.put("(", subMap);
139       // )
140       subMap = new HashMap<String, String>();
141       subMap.put("+", ">");
142       subMap.put("-", ">");
143       subMap.put("*", ">");
144       subMap.put("/", ">");
145       //subMap.put("(", "<");
146       subMap.put(")", ">");
147       subMap.put("=", ">");
148       priorityMap.put(")", subMap);
149       // #
150       subMap = new HashMap<String, String>();
151       subMap.put("+", "<");
152       subMap.put("-", "<");
153       subMap.put("*", "<");
154       subMap.put("/", "<");
155       subMap.put("(", "<");
156       //subMap.put(")", ">");
157       subMap.put("=", "=");
158       priorityMap.put("=", subMap);
159      }
160     }

calculate.java

  1 package imple;
  2 
  3 import java.io.*;
  4 import java.util.*;
  5 
  6 public class timu {
  7     private int n;
  8     private int range;
  9 
 10     public int getN() {
 11         return n;
 12     }
 13 
 14     public void setN(int n) {
 15         this.n = n;
 16     }
 17 
 18     public int getRange() {
 19         return range;
 20     }
 21 
 22     public void setRange(int range) {
 23         this.range = range;
 24     }
 25 
 26     public void generate(int n, int range) {
 27         char[] symbol = { '+', '-', '*', '/', '(' };
 28         int op; 
 29         try { 
 30              File writename = new File("E:\\Java_szys\\szys.txt"); 
 31                 BufferedWriter out = new BufferedWriter(new FileWriter(writename));  
 32         for (int i = 0; i < n; i++) {
 33 
 34             String eHead = "" + (i + 1) + ". ";
 35             String e ="";
 36             int exlength = (int) (Math.random() * 4 + 2);
 37             int lbracket = 0;
 38             int rbracket = 0;
 39             int[] whe = new int[exlength]; 
 40             for (int j = 0; j < exlength; j++) {
 41                 char s = symbol[(int) (Math.random() * 5)];
 42                 if (j == exlength - 1 && s == '(') { 
 43                     int count1 = lbracket;
 44                     if (lbracket == 0) {
 45                         e += "" + (int) (Math.random() * range) + "";
 46                     } else {
 47                         e += "" + (int) (Math.random() * range) + "";
 48                         for (int q = 0; q < count1; q++) {
 49                             e += ")";
 50                             lbracket--;
 51                         }
 52                     }
 53                     e += "=";
 54                     continue;
 55                 }
 56                 if (lbracket == 0) { 
 57                     if (s == '(') {
 58                         e = e + "" + s + "" + (int) (Math.random() * range)
 59                                 + "" + symbol[(int) (Math.random() * 4)] + "";
 60 
 61                         whe[rbracket] = (int) (Math.random()
 62                                 * (exlength - j - 1) + j + 1);
 63 
 64                         lbracket++;
 65                         rbracket++;
 66                     } else {
 67                         e = e + "" + (int) (Math.random() * range) + "" + s
 68                                 + "";
 69                     }
 70                 } else if (s != '(') {
 71                     int count2 = lbracket;
 72                     int count_match = 0;
 73                     for (int l = 0; l < count2; l++) {
 74                         if (whe[(rbracket-count2) + l ] == j) {
 75                             if (count_match == 0) {
 76                                 e = e + "" + (int) (Math.random() * range)
 77                                         + ")";
 78                                 count_match++;
 79                                 lbracket--;
 80                             } else {
 81                                 e += ')';
 82                                 lbracket--;
 83                             }
 84                         }
 85                     }
 86                     if (count_match == 0) {
 87                         e = e + "" + (int) (Math.random() * range) + "" + s
 88                                 + "";
 89                     } else {
 90                         e += "" + s + "";
 91                     }
 92                 } else {
 93                     int count3 = lbracket;
 94                     int count = 0;
 95                     for (int m = 0; m < count3; m++) {
 96 
 97                         if (whe[rbracket-count3 + m] == j) {
 98                             if (count == 0) {
 99                                 e = e + "" + (int) (Math.random() * range)
100                                         + ")";
101                                 count++;
102                                 lbracket--;
103 
104                             } else {
105                                 e += ')';
106                                 lbracket--;
107 
108                             }
109 
110                         }
111 
112                     }
113                     if (count == 0) {
114                         e = e + "(" + (int) (Math.random() * range) + ""
115                                 + symbol[(int) (Math.random() * 4)] + "";
116                         whe[rbracket] = (int) (Math.random()
117                                 * (exlength - j - 1) + j + 1);
118                         lbracket++;
119                         rbracket++;
120                     } else {
121                         e += "" + symbol[(int) (Math.random() * 4)] + "("
122                                 + (int) (Math.random() * range) + ""
123                                 + symbol[(int) (Math.random() * 4)] + "";
124                         whe[rbracket] = (int) (Math.random()
125                                 * (exlength - j - 1) + j + 1);
126                         rbracket++;
127                         lbracket++;
128                     }
129                 }
130 
131             }
132             char[] strChar = e.toCharArray();
133             strChar[strChar.length - 1] = '=';
134             for(int g=0 ;g<strChar.length;g++){
135                 if(strChar[g]=='/'){
136                     if(strChar[g+1]=='0'){
137                         i=i-1;
138                         System.out.print("�Ƿ����ʽ");
139                     }
140                     
141                 }
142             }
143             System.out.print(eHead);
144             System.out.println(strChar);
145             calculate ee = new calculate();
146             double result = ee.calcualte(e);
147             out.write(eHead+"�𰸣�"+result+"\r\n"); 
148             out.flush(); 
149 
150         }
151         out.close(); 
152           } catch (Exception e1) {  
153                 e1.printStackTrace();  
154             }  
155     }
156 
157 }

timu.java

3.2、测试用例设计

由于并未将算法的加减乘除划分为不同模块，所以在测试用例的设计上只对算法函数整体进行测试。

　　函数实现了四则运算功能，随机生成四则运算题目并返回正确答案，因此设置如下测试：

　　-函数返回值即题目正确答案是否在0-100范围内；

　　-函数返回值即题目正确答案是否是整数不包含分数；

　　-函数返回值即题目正确答案是否为空；

3.3 选择的测试框架介绍、安装过程

JUnit测试框架介绍

　　因为此次实验代码是由Java语言编写而成，从而采用JUnit。JUnit是一个开发源代码的Java测试框架，用于编写和运行可重复的测试。它是用于单元测试框架体系xUnit的一个实例（用于java语言)。Junit有其自己的JUnit扩展生态圈,多数Java的开发环境已集成了JUnit作为单元测试的工具,用于测试期望结果的断言，用于共享共同测试数据的测试工具，用于方便的组织和运行测试的测试套件及图形和文本的测试运行器。Eclipse 集成了 JUnit，可以非常方便地编写 Test Case。Eclipse 自带了一个 JUnit 插件，不用安装就可以在项目中测试相关的类，并且可以调试测试用例和被测类。

安装过程

　　打开eclipse,进入项目文件的属性，选择Java构建路径中的库（L），点击ADD Library，添加库类型，选择Junit，在Junit库版本中选择Junit4，完成后点击Apply and Close即可。

3.4 测试代码

选中calculate.java，右击新建—>其他,选中创建JUnit测试用例，点击下一步；

勾选setUp()(U),点击下一步；

选择calculate和priority方法；

生成初始测试代码

代码测试

四、思考题

比较以下二个工匠的做法，你认为哪种好？结合编码和单元测试，谈谈你的认识。

答：工匠一更好，首先工匠一、二都知道砖有对不齐的可能，而测试人员都知道，软件或多或少会有问题，如果能在开发之前预见开发过程中会出什么样的问题，测试将会有质的改变。开发人员根据测试人员所预见的问题开发，防止这些问题的发生。这是测试过程质的改变，测试不再是去找bug，而是引导开发避免问题的发生。测试的流程和作用也发生了改变，测试不是再等墙砌完了，推了再砌，而是和开发一起努力，争许一次把墙砌好，要以最小返工率为目标。所以在编码的开始阶段，就应该规范进行，确定好整体架构和内容，按照标准规则进行，避免测试时出现较大的错误又重新编码，解决不必要的麻烦。

五、实验总结

　　通过本次实验第一次了解到了单元测试，并知道了单元测试是什么以及它的作用，在以后的学习和编程中会更加注意这方面的规范，使自己更加熟悉编程，去编写出更好的程序。

posted @ 2020-06-01 18:57 Zeroli 阅读(213) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

Zeroli

实验五 单元测试