白盒测试------基本路径测试（附示例，最详细解释！）

白盒测试– Basis Path Testing

来自PKU
题干：以测试插入排序为例

Insertion Sort
void insertionSort(int numbers[], int array_size)
{
int i, j, index;

for (i=1; i < array_size; i++)
{
index = numbers[i];
j = i;
while ((j > 0) && (numbers[j-1] > index))
{
numbers[j] = numbers[j-1];
j = j - 1;
}
numbers[j] = index;
}
}

注意：你可能发现有些路径没有相应的数据使得程序执行时走这些路径. 如果有，给出描述.

答:

基本路径方法设计测试用例步骤（白盒测试）
1、画出控制流程图 ;
2、计算圈复杂度（环路复杂度）;
3、整理基本路径集合 ;
4、导出测试用例。

控制流图
制作步骤：

给程序源码每行标上序号；
画出控制流图；

2、计算圈复杂度（环路复杂度）
根据 McCabe度量法 ,环路复杂性等于控制流图中的区域数
(一) 方法一：根据流图中区域的数量得CC(G) = 4；
(二) 方法二：CC(G) = E - N + 2 = 11 – 9 + 2 = 4；（E为流图中边的个数，N为节点的个数）
(三) 方法三：CC(G) = P + 1 = 3 + 1 = 4；（P为流图中判定条件的个数）
故4是构成基本路径集的独立路径的上界。

3、整理基本路径集合
首先要确定整体的开始（3.1）和结束（12），无论哪条路径，开始和结束必须是这两个节点。

路径1：
3.1–3.2–12
//i < array_size不满足,0或1的数组
路径2：
3.1–3.2–4,5–6.1–10–3.3–3.2–12
路径3：
3.1–3.2–4,5–6.1–6.2–10–3.3–3.2–12
//未进入while循环,最开始因(numbers[j-1] > index)不满足
路径4：
3.1–3.2–4,5–6.1–6.2–7,8–6.1–10–3.3–3.2–12
//进入了while循环,j>0还是满足,但因numbers[j-1] > index)不满足
路径1，路径2，路径3, 路径4组成了控制流图的一个基本路径集。

4、测试用例
为了确保基本路径集中的每一条路径的执行，根据判断节点给出的条件，选择适当的数据以确保每一条路径可以被测试到。
(1)空数组.
此时Array_size = 0; i = 1时，i< Array_size的条件不成立，执行第一条路径
3.1–3.2–12
(2)数组只有一个元素.
Array_size = 1，当i = 1时，i< Array_size的条件不成立，执行第一条路径
3.1–3.2–12
(3)数组中至少有两个元素，且元素递增，执行第三条路径
3.1–3.2–4,5–6.1–6.2–10–3.3–3.2–12
(4)数组中至少有两个元素，且非递增元素排序，执行第四条路径
3.1–3.2–4,5–6.1–6.2–7,8–6.1–10–3.3–3.2–12
(5)因为程序中6.1在未进入while循环自减是j=1恒成立，故不存在任何数据能使程序走第二条路径.

基本路径覆盖
1）主要特点：设计足够的测试用例，覆盖程序中所有可能的路径。
2）测试：
测试代码：（运行环境：win10 64位；IDEA2018.3.3； JDK1.8.0）

代码如下：

//直接插入排序
import java.util.Arrays;
public class InsertSortTest {
public static void main(String[] args) {
//测试用例1，空数组，执行第一条路径
int[] arr1 = {};
testEmpty(arr1);
//测试用例2，一个元素，执行第一条路径
int[] arr2 = {1};
testOne(arr2);
//测试用例3，两个元素，且按递增的顺序排列，执行第三条路径
int[] arr3 = {1,5};
testTwo(arr3);
//测试用例4，三个元素，非递增顺序排列，执行第四条路径
int[] arr4 = {4, 1, 2};
testThree(arr4);
}
public static int[] testEmpty(int[] arr){
System.out.println("---------------------空元素的测试开始---------------------");
System.out.println(“输入参数为：”+ Arrays.toString(arr));
InsertSort(arr, 0);
System.out.println(“期望结果为：[]”);
System.out.println(“输出结果为：”+ Arrays.toString(arr));
System.out.println(“与期望结果一致”);
System.out.println("---------------------空元素的测试结束---------------------");
System.out.println();
return null;
}
public static int[] testOne(int[] arr){
System.out.println("-----------------只包含一个元素的测试开始-----------------");
System.out.println(“输入参数为：”+ Arrays.toString(arr));
InsertSort(arr, 1);
System.out.println(“期望结果为：[1]”);
System.out.println(“输出结果为：”+ Arrays.toString(arr));
System.out.println(“与期望结果一致”);
System.out.println("-----------------只包含一个元素的测试结束-----------------");
System.out.println();
return null;
}
public static int[] testTwo(int[] arr){
System.out.println("---------------------包含两个递增元素的测试开始---------------------");
System.out.println(“输入参数为：”+ Arrays.toString(arr));
InsertSort(arr, 2);
System.out.println(“期望结果为：[1, 5]”);
System.out.println(“输出结果为：”+ Arrays.toString(arr));
System.out.println(“与期望结果一致”);
System.out.println("---------------------包含两个递增元素的测试结束---------------------");
System.out.println();
return null;
}
public static int[] testThree(int[] arr){
System.out.println("---------------------包含三个非递增元素的测试开始---------------------");
System.out.println(“输入参数为：”+ Arrays.toString(arr));
InsertSort(arr, 3);
System.out.println(“期望结果为：[1, 2, 4]”);
System.out.println(“输出结果为：”+ Arrays.toString(arr));
System.out.println(“与期望结果一致”);
System.out.println("---------------------包含三个非递增元素的测试结束---------------------");
System.out.println();
return null;
}
//直接插入排序
public static void InsertSort(int[] numbers, int array_size) {
int i, j, index;
for (i=1; i < array_size; i++)
{
index = numbers[i];
j = i;
while ((j > 0) && (numbers[j-1] > index))
{
numbers[j] = numbers[j-1];
j = j - 1;
}
numbers[j] = index;
}
}
}