【软件测试与质量保证】期末考试总复习——电子科技大学2023期末考试

文章共分三部分：

1. 各章重点问题探讨：针对可能考察的问答题做分析。
2. 重要知识点分析：包括各种测试方法，单元测试，集成测试，系统测试等。
3. 综合题：对考试可能出现的题目做练习。

考试真题可以看这篇文章：https://blog.csdn.net/spicy_chicken123/article/details/131498010

各章重点问题探讨

1. 编程完成后才进行测试存在哪些问题？

   • 延迟测试直到编程完成后可能会导致时间压力、修改困难、资源浪费和预期偏差等问题，大大提高错误修复的成本。
   • 为了更好地管理项目和提高软件质量，建议把软件测试贯穿到软件开发的各个阶段。

2. V模型相对传统模型改进了什么？

   • 该模型将测试的各个阶段和分析设计的各个阶段关联起来，单元测试验证详细设计，系统测试验证总体设计，验收测试验证需求分析。

3. 软件质量保证SQA与软件测试的关系：

   • SQA指导软件测试的计划与执行，监督测试工作结果的客观性、准确性与有效性，并协助软件测试的工作流程改进。
   • 软件测试是SQA工作落实的重要手段，它为SQA提供所需的质量数据，作为软件质量评价的客观依据。
   • SQA是一项软件质量管理性工作，侧重于对软件开发流程进行评审与监控。
   • 软件测试是一项技术性工作，侧重于对软件质量特性进行检测与验证。

4. 软件质量的分类？

   • 软件质量分为使用质量，外部质量，内部质量，过程质量
   • 使用质量：有效性，生产率，安全性，满意度
   • 外部质量：功能性，可靠性，易用性，效率，维护性，可移植性
   • 内部质量：代码耦合性，数据耦合性，程序规范性，需求可溯性，代码复杂度

5. 软件测试的三个维度：

   • 测试目标维度：功能测试，性能测试，安全性测试，兼容性测试，适用性测试，可靠性测试
   • 测试层次维度：单元测试，集成测试，系统测试，验收测试
   • 测试方法维度：黑盒测试，白盒测试

6. 软件测试的层次：

   • 单元测试：针对最小功能单元代码，主要采用白盒测试，通常需要写驱动模块和桩模块，编程和测试人员共同完成，开发人员为主，采用代码评审方法（可发现50%-70%代码缺陷）
   • 集成测试：是一种在单元测试的基础上，将若干单元模块按照设计要求组装起来所进行的测试，其目标是发现模块接口相关问题。
   • 系统测试是在集成测试之后，在系统层面所进行的功能特性测试和非功能特性测试。
   • 验收测试是在软件提交用户前，在实际用户环境中，验证软件系统功能、性能及其它特性是否符合用户需求。
     • α测试——采用实际运行环境和真实数据在软件公司内部进行的验收测试。
     • β测试——在公司外部用户中进行试用测试。通过收集试用户的反馈意见，对该版本软件进行修正与完善，最终得到正式发布的版本。

7. 软件测试方法总结：

   • 基于直觉和经验方法：Ad-hoc测试方法，ALAC测试方法，错误推测方法
   • 基于输入域方法（只适用于单因素输入）：等价类划分法，边界值分析法
   • 基于组合及其优化方法（针对多因素输入）：判定表，因果图，成对组合，正交实验；后两个针对多因素多取值
   • 基于逻辑覆盖方法：语句覆盖，判定覆盖，条件覆盖，判定-条件覆盖，条件组合覆盖，基本路径覆盖

8. 系统性能测试的“拐点”代表什么?如何判断什么时刻出现拐点?

   当并发用户访问系统达到一定数量时，被测系统出现平均响应时间急剧增加、吞吐量陡然下降、计算机资源利用已近饱和状态。该时刻的就是系统性能拐点。

9. 测试需求分析与制定测试计划。

   • 测试需求分析内容：了解项目背景，分析客户需求，确定测试目标，确定功能特性和非功能特性，确定测试项优先级……
   • 功能测试范围：页面链接，控件功能，输入文本框，web图形测试，表单测试……
   • 非功能测试范围：性能测试，安全测试，容错测试，兼容性测试，可用性测试……
   • 测试策略与方法、准入/准出条件、测试资源配置、进度安排、测试风险分析等。

10. 软件本地化测试的内容：

    • 安装/升级测试：是否可以在本地语言操作系统上进行正确的安装/升级，安装/升级前后的软件界面快捷图标、程序图标和注册表的变化是否与源语言程序一致
    • 功能性测试：是否与源语言软件功能相同，是否支持当地语言的输入和输出，是否支持当地语言的文件名和目录名
    • 数据格式测试：时间/日期/货币，地址/邮编/电话
    • 界面测试：硬编码字符串，嵌入控制，隐藏控制
    • 其他本地化测试内容：兼容性测试，文档测试，文化、宗教、法律等适用性测试
    • 翻译验证：检查翻译是否不完整、不确切

静态测试&动态测试

1. 在代码审查中，静态测试可发现如下编程缺陷:

   • 变量在初始化前使用、变量声明后未使用、变量在两次赋值之间从未使用
   • 数组访问越界
   • 存在不可到达代码
   • 循环中无条件分支
   • 接口参数类型或数目不匹配
   • 空指针或指针类型错误
   • 存在未被调用的函数和过程

2. 动态测试可发现的主要缺陷:

   • 程序逻辑错误
   • 异常输入的功能失效
   • 空指针使用
   • 内存没有及时释放关闭的对象资源
   • Session失效
   • 没有处理在空输入时点取Enter键情况

3. 静态测试：可以在循环之前记录 attributeList 的长度，提前将长度存储在变量中。以避免在每次循环迭代中都调用 length() 方法。

   for (int i=0; i<(int)attributeList.length(); i++) {
   //do something
   }
   

4. 静态测试：变量未初始化

   int i;
   printf("i= %d \n",i);
   

5. 静态测试：数组下标越界

   public class ArrayDemo {
   	public static void main(String args[]) {
   		int array[] = null ; //声明数组
   		array = new int[3] ;//为数组开辟空间，大小为3
           for(int i=0 ; i<=array.length; i++) {
   			System.out.println("array["+i+"]="+ array[i]);
   		}
   	}
   }
   

6. 静态测试：缺少对命令行参数数组的检查，缺少对无法将参数转换为整数的异常处理

   public class ExceptionDemo {
     public static void main(String args[]) {
       System.out.println("**********计算开始***********");
       int i = 0;
       int j = 0;
       try {
         String str1 = args[0];
         String str2 = args[1];
         i = Integer.parseInt(str1);
         j = Integer.parseInt(str2);
         int temp = i / j;
         System.out.println("两个数字相除的结果:" + temp);
       } catch (ArithmeticException e) {
         System.out.println("出现异常了:" +e);
       }
       System.out.println("**********计算结束***********");
     }
   };
   

7. 动态测试：没有实例化对象

   class Person {
     String name; // 声明姓名属性
     int age; // 声明年龄属性
     public void tell(){ // 取得信息
       System.out.println("姓名:" + name + "，年龄:" + age);
     }
   }
   public class ClassDemo {
     public static void main(String args[]){
       Person per = null; // 声明对象
       per.name = "张三"; // 为姓名赋值
       per.age = 30; // 为年龄赋值
       per.print(); // 调用方法，打印信息
     }
   }
   

8. 动态测试：在关闭 OutputStream 对象之前，应该先确保其不为 null。应将判断和关闭的代码都放到finally块中。

   OutputStream os = null;
   try {
     os = new OutputStream();
     // 在此处对 os 进行操作
     os.close();
   } catch (Exception e) {
     if (os != null)
       os.close();
   }
   

   修正后的代码如下：

   OutputStream os = null;
   try {
   	os=new OutputStream ();
       // Do something with os here
   }finally {
   	if (os != null)
           os.close();
   }
   

9. 代码审查：

   public string getUserRole (HttpServletRequest request) {
   	string userRole = "";
   	String userName = request.getParameter ("userName");
       if (userName.equals ("schadmin")) 
   		//这是系统初始化时默认的管理员账号，如果是,则做以下的验证操作..
   	}
   	//非系统初始化的账号,做以下验证操作......
   	return userRole;
   }
   
   

   userName可能会出现空指针情况。

   应改为"schadmin".equals(username)

10. 代码审查：

    int age = 0;
    String userAge = request.getParameter ("userage");
    if (userAge != null) 
     age = Integer.parseInt(userAge);
    
    

    useAge可能不是字符型数字。

    写一个工具类，使用类中的isnumeric方法，判断是否为数字类型

11. 在Java中，需要关闭的文件包括以下几种类型：

    • 输入流（InputStream）和输出流（OutputStream）：当使用文件的输入流或输出流进行读取或写入操作时，需要在使用完毕后关闭它们。例如，FileInputStream、FileOutputStream、BufferedInputStream、BufferedOutputStream等。
    • 读取器（Reader）和写入器（Writer）：当使用文件的读取器或写入器进行字符级别的读取或写入操作时，也需要在使用完毕后关闭它们。例如，FileReader、FileWriter、BufferedReader、BufferedWriter等。

12. 在文件处理过程中，可能会出现多种异常情况。以下是一些常见的导致异常的情况：

    • 文件不存在：当尝试打开或访问不存在的文件时，会抛出FileNotFoundException异常。
    • 无法读取文件：如果文件无法被读取，可能由于文件被其他进程锁定、权限不足、文件损坏等原因导致。这可能会引发IOException或其子类的异常。
    • 无法写入文件：当试图将数据写入文件时，可能会由于磁盘已满、权限不足等原因导致写入失败。这也可能引发IOException或其子类的异常。
    • 文件路径错误：如果提供的文件路径无效、不完整或包含特殊字符，可能会导致文件操作失败并引发InvalidPathException或其他异常。
    • 文件格式错误：在读取文件内容时，如果数据格式与预期不符，例如无法解析的数据结构、编码不匹配等，可能会导致IOException或IllegalArgumentException等异常。
    • 文件操作权限不足：当尝试读取或写入文件时，如果没有足够的权限，例如只读文件或只写文件，可能会导致SecurityException或AccessDeniedException等异常。
    • 文件操作被中断：在进行文件操作期间，如果操作被中断，例如由于线程中断或程序终止，可能会抛出InterruptedException或其他异常。

    这些异常情况需要根据具体的文件操作进行适当的异常处理和错误处理。通常，使用try-catch语句捕获这些异常，并根据需要进行适当的错误处理、日志记录或恢复操作。

等价类划分&边界值分析

1. 确定等价类方法：

   • 取值范围或给定值：3个等价类（2个有效1个无效）
   • 有效输入值集合：1个有效等价类和1个无效等价类
   • 1个布尔量：1个有效等价类和1个无效等价类
   • n组数据值，且程序对每组分别处理：n个有效等价类和1个无效等价类
   • 规定输入数据必须遵守特定规则：1个有效等价类和若干无效等价类

2. 确定边界值的方法：如果输入数据规定了值的范围，则可以选取刚达到这个范围的边界值，以及刚刚超越这个范围边界的值作为测试输入数据。

3. 针对电子科技大学信息门户的“密码找回”界面的邮箱输入域进行验证，采用等价划分法设计相应的测试用例，包括尽量多的无效等价类。

   有效等价类：

   ①@uestc.edu.cn（*为字母或数字）

   无效等价类：

   ②*中有非字母、数字其它字符

   ③缺少@

   ④有2个或多个@

   ⑤@后不是标准域名字段

   后面需要给出5个测试用例

   分成很多部分的时候可以列表格，先覆盖有效，再分别覆盖无效。

4. 综合运用边界值方法和等价类方法，针对三角形问题设计相应的测试用例。假定输入三个整数（a、b、c）作为边，分别满足一般三角形、等腰三角形和等边三角形。

   思路：

   可以使用逻辑联结词，析取，合取写测试用例

   a,b,c不用分开写

   测试用例最后写，应该有5个

   一般，等腰，等边各1个，非三角形有2个

判定表

1. 如果多因素的输入和输出关系较简单，则可以根据输入数据组合就能直接判断输出结果集合。在这种场景下，可以采用判定表（决策表）方法对系统功能进行测试。

2. 判定表方法是一种借助表格方式完成多条件输入组合下测试用例设计，达到完全覆盖输出结果的测试方法。其表格组成样式如下:

3. 设计步骤：列出所有条件桩和动作桩，填入条件桩和动作桩，设计初始判定表，最后简化合并相似规则

4. 系统的年、月、日数据由Y、M、D单元来存储相应值，若要测试NextData（Y,M,D）函数，采用判定表方法设计相应的测试用例。

   提示：将Y,M,D分别按数值划分

   年份：Y1：平年，Y2：闰年

   月份：M1：1,3,5,7,8,10月，M2：4,6,9,11月，M3：2月，M4：12月

   日期：D1：1-27日，D2：28日，D3：29日，D4：30日，D5：31日

   动作有四个：

   日期后移1天，年月均不变
   日期改为1，月份后移1月，年份不变
   日期和月份均改为1，年份后移1年
   提示输入错误

   画完判定表注意根据判定表的列来设计测试用例。

因果图

1. 因果关系符号：

2. 针对某机构人员管理的业务规则需求：

   1）年薪制员工：严重过失，扣年终风险金的4%；过失，扣年终风险金的2%。

   2）非年薪制员工：严重过失，扣当月薪资的8%；过失，扣当月薪资的4%。

   请绘制出因果图和判定表，并给出相应的测试用例。

   提示：

   令C1为年薪制员工，C2为严重过失，C3为过失。

   结果分别为e1,e2,e3,e4。

   相应的，判定表绘制8列，结果除了这四种外加上不操作和不可能。

   注意设计相应的测试用例。

3. 程序的规格说明要求:

   1）输入的第一个字符必须是“A”或 B"，常二个字符必须是一个数字，在此情况下进行文件的修改;

   2）如果第一个字符不是“A”或“B”，则给出信息L;

   3）如果第二个字符不是数字，则给出信息M。

   请绘制出因果图和判定表，并给出相应的测试用例。

   转换为判定表后一共有8列，结果为E1,E2,E3和不可能

   有2个不可能，设计6个测试用例即可

4. 有一个自动售货机软件。若投入1元5角硬币，按下“可乐”、“雪碧”或“红茶”按钮，相应的饮料就送出来。若投入的是两元硬币，在送出饮料的同时退还5角硬币。请设计其因果图和判定表，并给出相应的测试用例。

   转化为判定表，设计的有效测试用例共有6个。

成对组合测试

1. 基本思想：每两个输入变量所有取值组合形成不同测试用例。

2. 测试一个登录页面在不同浏览器和语言下的功能正确性，其输入条件如下:

   1）输入项（账号、密码）

   2）浏览器（IE、chrome、FireFox、360）

   3）语言（中文、英文）

   请问进行完整组合的兼容性测试需要多少个测试用例？采用成对组合的兼容性测试需要多少个测试用例？给出成对组合测试用例表。

   答： 进行完整组合的兼容性测试需要2×2×4×2=32个测试用例

   采用成对组合的兼容性测试需要8个测试用例，下面是成对组合测试用例表

   提示：输入条件仅考虑两种可能，空值和填值

   编号	账号	密码	浏览器	语言
   1	无效账号	无效密码	IE	中文
   2	无效账号	有效密码	Chrome	中文
   3	有效账号	无效密码	Firefox	中文
   4	有效账号	有效密码	360浏览器	中文
   5	有效账号	有效密码	IE	英文
   6	有效账号	无效密码	Chrome	英文
   7	无效账号	有效密码	Firefox	英文
   8	无效账号	无效密码	360浏览器	英文

正交表

1. 行数:正交表中的行个数，即实验的次数，也是我们通过正交实验法设计的测试用例个数。
   $$行数(即测试用例次数)=\sum (每列水平数-1)+1$$

2. 因素数:正交表中列的个数，即测试功能点的因子数。

3. 水平数:任何单个因素能够取值的个数。正交表中包含值为从0到“水平数-1”或从1到“水平数”。即要测试功能点的输入取值数。

4. 正交表的表示形式:
   $$L_{行数}(水平{数}^{因子数})$$
   L代表正交表，它是运用数学理论在拉丁方和正交拉丁方基础上构造的规格化数据表格，常用的有L4(2^3)、L8(27)、L9(3^4)、L16(45)等。

5. 正交表特性
   1）每一列中各数字出现的次数都一样多;
   2）任何两列所构成的各有序数对出现的次数都一样多。

6. 在一个客户信息查询界面中，输入条件有“姓名”、“身份证号”、“手机”，采用正交表方式设计该界面查询功能的测试用例。

   答：若采用正交实验测试方法，则将“姓名”、“身份证号”、“手机”作为查询条件功能的因子，每个因子可以填写内容，也可以不填写内容，即水平数为2。可以选择L4(2^3)正交表。

基于逻辑覆盖的方法

1. 语句覆盖

   • 思想：使得被测程序每个可执行语句至少被执行一次。
   • 语句覆盖测试能解决的问题:发现程序中一些永远不能被执行的语句缺陷，但不能发现程序中语句逻辑错误。

2. 判定覆盖

   • 思想：使得程序中每个判定语句的取真分支和取假分支至少执行一次。又叫分支覆盖。
   • 也不能发现程序中语句逻辑错误。

3. 条件覆盖

   • 思想：使每个判断中每个条件的可能取值至少满足一次
   • 满足条件覆盖不一定满足判定覆盖

4. 条件组合覆盖：

   • 基本思想是设计足够的测试用例，使得判断中每个条件的所有取值情况至少出现一次，并且每个判断本身的判定结果也至少出现一次。
   • 问题：不能覆盖所有路径。

5. 判定-条件覆盖：

   • 符合条件覆盖的测试用例并不一定满足判定覆盖要求，反之，符合判定覆盖的测试用例也不一定满足条件覆盖要求。因此，需要找出符合两者的测试用例交集，该方法称为判定-条件覆盖。
   • 不一定发现程序逻辑错误。

6. 基本路径覆盖：

   • 思想：覆盖程序中所有可能的基本分支路径。

   • 环路复杂度计算：

     计算程序环路复杂度V(G)有如下三种方法:

     v(G)=区域数目

     V(G)=边界数目-节点数目+2

     v(G)=判断节点数目+1

7. 根据所示的程序流程图，分别使用语句覆盖测试、判定覆盖测试、条件覆盖测试和路径覆盖测试进行测试用例设计。

   

   以语句覆盖为示例：

   用例序号	输入数据	预期输出	覆盖语句
   1	(X,Y)=(1,11)	(X,Y)=(1,11)	X>0 AND Y>10; Y = Y/X; X<-10 OR Y<0;
   2	(X,Y)=(0,-1)	(X,Y)=(0,1)	X>0 AND Y>10; X<-10 OR Y<0; Y =-(Y+X);

   后面的覆盖一样，写四列，分别为序号、输入数据、预期输出和覆盖语句/判定/条件/路径

   写判定覆盖时：

   令条件M = {A>1 && B0}，条件N = {A2 || X>1}

   写条件覆盖时：

   第一个判定分支：条件A＞1，取真为T1，取假为F1；条件B＝0，取真为T2，取假为F2

   第二个判定分支：条件A＝2，取真为T3，取假为F3；条件X＞1，取真为T4，取假为F4

   除了路径覆盖有3个用例，其余均有2个用例。

   特别注意判定覆盖和条件覆盖的写法，使用M为真,N为假,T1,F2等符号简化覆盖条件

8. 针对如下样本程序，分析该程序逻辑覆盖测试方法中的语句覆盖、判定覆盖、条件覆盖和基本路径覆盖，并说明哪种方法覆盖率高？为什么？

   import java.util.Scanner;
   public class Coverage {
       public static void main(String[] args){
            System.out.println("start main function:path a...");
            int A=0,B=0,X=0;
            Scanner s = new Scanner(System.in);
            System.out.println("输入A：");  A = s.nextInt();
            System.out.println("输入B=");  B = s.nextInt();
            System.out.println("输入X=");  X = s.nextInt();
            s.close();  
            if (A>1 && B==0) {
               X=X/A;
               System.out.println("path c");
            } else {
               System.out.println("path b");  }
            if (A==2 || X>1) {
               X=X+1;
               System.out.println("path e");
            } else {
               System.out.println("path d");  
            }
            System.out.println("end main function.");
   	}
   }
   

   和上一题一样，先画流程图再分析

   最完整的一定是条件组合覆盖

编程题（JUnit单元测试）

public class getMax {
	public int get_max(int x, int y, int z) {
		int max;
		if (x >= y) 
			max = x;
		else 
			max = y;
		if (z >= max)
			max = z;
		return max;
	}
}

测试上述程序，请写出JUnit测试脚本：

import static org.junit.Assert.*;
import org.junit.Test;

public class getMaxTest {
	@Test
	public void test() {
		getMax r = new getMax();
		int expected = 2;
        int result = r.get_max(0, 2, 1);
		assertEquals(expected, result);			
	}
}

另一个完整的框架示例：

import static org.junit.Assert.*;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;

public class SaleMachinePathTest {

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
	}

	@AfterClass
	public static void tearDownAfterClass() throws Exception {
	}

	@Before
	public void setUp() throws Exception {
	}

	@After
	public void tearDown() throws Exception {
	}

	@Test
	public void testOperationS1() {
		SaleMachine saleMachine1 = new SaleMachine(10, 10, 10, 10);
		String actualResult = saleMachine1.operation("Beer", "5J");
		String expectedResult = "Input Information \n" + "Type: Beer; Money: 5 Jiao; Change: 0\n\n";
		assertEquals(expectedResult, actualResult);
	}
	

}

单元测试与集成测试

1. 单元测试任务：
   • 单元测试的路径测试
     • 误解或用错了运算符优先级
     • 混合类型运算
     • 变量初值错
     • 精度不够
     • 表达式符号错
     • 逻辑判断错误
     • 路径是否被覆盖
     • 循环终止条件错误
     • 其它
   • 局部数据结构测试
     • 不适合或不相容的类型说明
     • 变量无初值
     • 变量初始化或默认值有错
     • 不正确的变量名或从来未被使用过
     • 出现上溢或下溢和地址异常
     • 其它
   • 单元接口测试
     • 在对本单元接口进行调用时，输入的实际参数与本单元形式参数是匹配(个数、数据类型、参数顺序)
     • 本单元调用其他模块的实际参数与被调模块的形参是否匹配
     • 全局变量的定义在各模块是否一致。
     • 外部输入、输出是否正确
     • 其它
   • 单元边界条件的测试
     • 普通合法数据的处理
     • 普通非法数据的处理
     • 边界值内合法边界数据的处理
     • 边界值外非法边界数据的处理
     • 其它
   • 单元容错性测试
     • 输出的错误提示信息是否难以理解
     • 记录的错误信息与实际错误是否相符
     • 异常处理是否恰当
     • 是否提供足够的出错定位信息
     • 其它
   • 内存分析
     • 是否发生内存泄漏
     • 是否发生内存分配错误
     • 其他
2. 单元静态测试：见“静态测试&动态测试”
3. 单元动态测试：见“编程题（Junit单元测试）”
4. 集成测试：将已经通过单元测试的若干模块按设计要求组装起来，然后再进行的测试，它主要检查这些单元模块之间的接口是否存在问题，包括接口参数的一致性引用、业务流程端到端的正确性等。
5. postman步骤：选择请求方式GET，写请求URL地址，填写请求参数，点send发送请求
6. 编写测试脚本：可以判断接口请求返回的状态码是否为200，测试响应时间，检查正文中的特定值等等。

系统测试

1. 系统测试分类：

   系统功能测试：功能测试，回归测试

   系统非功能测试：性能测试，安全性测试，容错测试，兼容性测试，可靠性测试

2. 典型的功能测试要求:

   • 程序安装、启动正常，有相应对话框及错误提示等
   • 每项功能符合实际要求
   • 系统的界面清晰、美观
   • 菜单、按钮操作正常、灵活，能处理一些异常操作
   • 能接受正确的数据输入，对异常输入的容错处理
   • 数据的输出结果准确，格式清晰，可以保存和读取
   • 功能逻辑清楚，符合使用者习惯
   • 系统的各种状态按照业务流程而变化，并保持稳定
   • 支持多种应用环境

3. 例：会员登录Web页面功能测试

   • 页面链接:页面是否存在、页面是否正确跳转
   • 控件功能:按钮功能是否正确、列表内容是否正确、光标位置移动是否顺序正确。
   • 输入文本框:数据格式、数据类型、数据长度是否检查
   • Web图形测试:图片文字提示是否正确、图片链接是否正确、图片在不同分辨率下显示是否正确
   • 表单测试:请求是否响应、脚本是否正确执行

4. 系统性能需求：

   事务吞吐量TPS：200事务/秒，响应时间RT：2秒以内，事务成功率：100%

5. 负载测试：模拟实际软件系统所承受的访问负荷，通过变换系统负载（如渗入测试和峰谷测试）来观察不同负载下系统性能表现，如系统响应时间、数据吞吐量、系统占用的资源（如CPU、内存）等，测评对象的行为特性。

6. 压力测试：长时间强负载（大数据量、大量并发用户等)
   下对系统进行的测试，查看系统在高负载情况下表现的行为，从而有效地发现系统稳定性的隐患和系统在负载峰值条件下功能缺陷等。

7. 安全性测试：验证系统安全功能，扫描系统内部漏洞，模拟系统外部黑客攻击

8. 容错性测试：

   • 输入异常数据或进行异常操作的系统测试，以检验系统的保护性。如果系统的容错性好的话，系统只给出提示或内部消化掉，而不会导致系统出错甚至崩溃。
   • 灾难恢复性测试。通过各种手段，让软件强制性地发生故障，然后验证系统是否可以将丢失的数据进行恢复处理。

9. 兼容性测试：测试软件在特定的硬件平台上、不同的应用软件之间、不同的操作系统平台上、不同的网络等环境中是否能够很友好的运行。

10. 可靠性测试：软件系统在规定时间内及规定环境条件下，完成特定功能的能力。

    可靠性评估：

    MTTF (Mean Time To Failure）——系统平均无故障时间. MTTR (Mean Time To Recover) ——故障平均修复时间
    可用性度量=MTTF /(MTTF+MTTR)
    例:如果系统每运行100个时间单位，会有1个时间单位无法提供服务，其系统的可用性是99%。

综合题：称重三次找到假球

使用白盒测试用例设计方法为下面的程序设计测试用例（基本路径测试）并在JUnit下测试。

程序要求：10个铅球中有一个假球（比其他铅球的重量要轻），用天平三次称出假球。

程序设计思路：第一次使用天平分别称5个球，判断轻的一边有假球；拿出轻的5个球，取出其中4个第二次称，两边分别放2个球：如果两边同重，则剩下的球为假球；若两边不同重，拿出轻的两个球称第三次，轻的为假球。、

程序代码如下：

package module;

public class SearchBall {
    private static int x[]=new int[10];
    public SearchBall(){}
    public void setBWeight(int w[]){
        for(int i=0;i<w.length;i++){
             x[i]=w[i];
        }
    }
    public String BeginSearch(){
        if(x[0]+x[1]+x[2]+x[3]+x[4]<x[5]+x[6]+x[7]+x[8]+x[9]){
            if(x[1]+x[2]==x[3]+x[4]){
                return "1号是假球";
            }
            if(x[1]+x[2]<x[3]+x[4]){
                if (x[1]<x[2]) {
                    return "2号是假球";
                }else {
                    return "3号是假球";
                }
            }else {
                if (x[3]<x[4]){
                    return "4号是假球";
                }
                else{
                    return "5号是假球";
                }
            }
        }else {
            if(x[6]+x[7]==x[8]+x[9]){
                return "6号是假球";
            }
            if(x[6]+x[7]<x[8]+x[9]) {
            	if (x[6]<x[7]) {
            		return "7号是假球";
            	}else {
            		return "8号是假球";
            	}
            }else {
            	if (x[8]<x[9]) {
            		return "9号是假球";
            	}else {
            		return "10号是假球";
            	}
            }
        }
     }
}

解题步骤：

1. 画出程序控制流图，计算环路复杂度，计算结果为10，共有10条基本路径。

2. 设计测试用例，完成测试用例表填写

   路径编号	用例输入	期待输出
   1		“1号是假球”
   2		“2号是假球”
   3		“3号是假球”
   4		“4号是假球”
   5		“5号是假球”
   6		“6号是假球”
   7		“7号是假球”
   8		“8号是假球”
   9		“9号是假球”
   10		“10号是假球”

3. 设计Junit单元测试程序：

   import static org.junit.Assert.*;
   
   import org.junit.Test; 
   import org.junit.Before; 
   import org.junit.After; 
   
   public class SearchBallTest { 
   
       @Before
       public void before() throws Exception { 
       } 
   
       @After
       public void after() throws Exception { 
       } 
   
       @Test
       public void testBeginSearch() {
           SearchBall obj = new SearchBall();
           int[] input;
           int ballIndex;
           // 遍历测试各个基本路径
           for(int i=0;i<10;++i){
               // 生成用例输入
               input = new int[]{10, 10, 10, 10, 10, 10, 10, 10, 10, 10};
               input[i]=5;
               obj.setBWeight(input);
               // 测试用例输出
               ballIndex = i+1;
               assertEquals(ballIndex+"号是假球", obj.BeginSearch());
           }
       } 
   }
   
   

综合题：登录界面的测试用例

以B站和网易云的登录界面为例

1. 功能测试
   • 登录功能测试：
     • 输入正确的用户名和密码，是否登录成功
     • 输入错误的密码，提示密码错误
     • 输入不存在的用户名，提示用户名不存在
     • 用户名为空，提示用户名不能为空
     • 各种登录方式是否能正常切换
     • 各种登录方式是否均可正常登录
   • 链接跳转功能测试：点击忘记密码、用户协议、隐私政策链接时能否正确跳转
   • 控件功能测试：按钮功能是否正确，单选框功能是否正确，列表功能是否正确（网易云+86那里）
   • 界面测试：界面是否清晰美观，布局是否合理，文字是否简洁易懂
2. 性能测试：
   • 压力测试：模拟用户在正常登录下系统所承受的访问负荷，包括输入正确的用户名密码，输入错误的用户名密码等，通过系统响应时间、数据吞吐量、事务成功率等指标测评。
   • 负载测试：长时间强负载下对系统进行测试，查看系统在高负载情况下表现的行为。
3. 安全性测试：
   • 密码是否以密文的形式显示
   • 错误登录是否有次数限制
   • 用户名和密码是否通过加密的方式发送给浏览器
   • cookie有效时间验证
   • 是否允许多用户同时登陆
4. 兼容性测试：
   • 不同浏览器下，验证登录页面的显示以及功能正确性；
   • 相同浏览器的不同版本下，验证登录页面的显示以及功能正确性；
   • 不同的平台上，验证登录界面的显示以及功能正确性；
   • 不同移动设备终端的不同浏览器下，验证登录页面的显示以及功能正确性；
   • 不同分辨率的界面下，验证登录页面的显示以及功能正确性。

功能测试用例表的书写

要点：

1. 表题：《表1 用户登录功能测试用例》
2. 从上到下分别为：用例描述，用例目的，前提条件，具体用例
3. 用例编号有三列：输入/动作，期望的输出，测试结果评判

结果分析表如下：

性能测试用例表的书写

要点：

1. 第一部分为用例ID，业务名称，URL，前置条件，测试步骤等基本信息。
2. 第二部分为脚本操作信息，包括参数设置，事务设置。
3. 第三部分为场景设计，介绍测试场景。
4. 第四部分为期望的结果。