白盒测试练习及答案

1、在白盒测试用例设计中，有语句覆盖、分支覆盖、条件覆盖、路径覆盖等，其中（  A  ）是最强的覆盖准则。为了对如下图所示的程序段进行覆盖测试，必须适当地选取测试用例组。若x, y是两个变量，可供选择的测试用例组共有Ⅰ、Ⅱ、Ⅲ、Ⅳ四组，如表中给出，则实现判定覆盖至少应采取的测试用例组是（  B  ）或（  C  ）；实现条件覆盖至少应采取的测试用例组是（  D  ）；实现路径覆盖至少应采取的测试用例组是（  E  ）或（  F  ）。
 
 
供选择的答案
A：① 语句覆盖    ② 条件覆盖    ③ 判定覆盖    ④ 路径覆盖
B～F:① Ⅰ和Ⅱ组    ② Ⅱ和Ⅲ组   ③ Ⅲ和Ⅳ组  ④ Ⅰ和Ⅳ组 ⑤ Ⅰ、Ⅱ、Ⅲ组     ⑥ Ⅱ、Ⅲ、Ⅳ组    ⑦ Ⅰ、Ⅲ、Ⅳ组 ⑧ Ⅰ、Ⅱ、Ⅳ组
解答：A. ④    B. ⑤    C. ⑧    D. ④    E. ⑤    F. ⑧

2. 阅读下面这段程序，使用逻辑覆盖法进行测试，请问哪一组关于（a,b,c）的输入值可以达到条件覆盖。（  B  ）

int func(int a,b,c){

         int k=1;

if ( (a>0) || (b<0) || (a+c>0) )  k=k+a;
else  k=k+b;
if (c>0)  k=k+c;
return k;
}
A. (a,b,c) = (3,6,1)、(-4,-5,7)  B. (a,b,c) = (2,5,8)、(-4,-9,-5)           C. (a,b,c) = (6,8,-2)、(1,5,4)       D. (a,b,c) = (4,9,-2)、(-4,8,3)

3. 阅读下面这段程序，使用逻辑覆盖法进行测试，请问哪一组关于（a,b,c）的输入值可以达到判定覆盖。（ D   ）
int func(int a,b,c){
int k=1;
if ( (a>0) &&(b<0) && (a+c>0) )  k=k+a;
else  k=k+b;
if (c>0)  k=k+c;
return k;
}
A. (a,b,c) = (3,6,1)、(-4,-5,7) B. (a,b,c) = (2,5,8)、(-4,-9,-5)             C. (a,b,c) = (6,8,-2)、(1,5,4) D. (a,b,c) = (4,-9,-2)、(-4,8,3)

4. 阅读下面这段程序，使用逻辑覆盖法进行测试，请问哪一组关于（a,b,c）的输入值可以达到判定条件覆盖。（ B ）
int func(int a,b,c){
int k=1;
if ( (a>0) || (b<0) || (a+c>0) )  k=k+a;
else  k=k+b;
if (c>0)  k=k+c;
return k;
}
A. (a,b,c) = (3,6,1)、(-4,-5,7) B. (a,b,c) = (2,-5,8)、(-4,9,-5)       C. (a,b,c) = (6,8,-2)、(1,5,4) D. (a,b,c) = (4,9,-2)、(-4,8,3)


5、下面是一段求最大值的程序，其中datalist是数据表，n是datalist的长度。
       int GetMax(int n, int datalist[ ]){
               int k=0; 
               for ( int j=1; j<n; j++ ) 
                        if ( datalist[j] > datalist[k] ) k=j;
                return k;
       } 
       （1） 画出该程序的控制流图，并计算其McCabe环路复杂性。 
       （2） 用基本路径覆盖法给出测试路径。 
       （3） 为各测试路径设计测试用例。 
答：  1      int  k = 0;
          2      int  j = 1;
          3      while ( j < n )
          4       { 
          5         if  ( datalist[j] > datalist[k] )
          6                      k = j;
          7         j++;
          8        }
          9       return  k;
         
控制流图如上，McCabe环路复杂性为3。

    2. 测试路径：
       Path1： 2→3 →9
       Path2： 2→3→5→6→7 →8→3→9
       Path3： 2→3→5→7 →8→3→9 
    3. 测试用例： 
       Path1： 取n=1，datalist[0] = 1， 
               预期结果：k=0 
       Path2： 取n=2，datalist[0] = 1，datalist[1] = 0， 
               预期结果：k=0 
       Path3： 取n=2，datalist[0] = 0，datalist[1] = 1， 
               预期结果：k=1
6、下面是选择排序的程序，其中datalist是数据表，它有两个数据成员：一是元素类型为Element的数组V，另一个是数组大小n。算法中用到两个操作，一是取某数组元素V[i]的关键码操作getKey ( )，一是交换两数组元素内容的操作Swap( )：
void SelectSort ( datalist & list ) {
//对表list.V[0]到list.V[n-1]进行排序,  n是表当前长度。
for ( int i = 0; i < list.n-1; i++ ) {
int k = i;   //在list.V[i].key到list.V[n-1].key中找具有最小关键码的对象
for ( int j = i+1; j < list.n; j++)
if ( list.V[j].getKey ( ) < list.V[k].getKey ( ) ) k = j;
//当前具最小关键码的对象
if ( k != i ) Swap ( list.V[i], list.V[k] );//交换
    }
}
 (1) 试计算此程序段的McCabe复杂性；
 (2) 用基本路径覆盖法给出测试路径；
 (3) 为各测试路径设计测试用例。
解答：(1)
         1      int i = 0;
         2      while  ( i < list.n-1 )
         3      {   int  k = i;
         4          int j = i+1;
         5          while ( j < list.n )
         6           {    if ( list.V[j].getKey ( ) < list.V[k].getKey ( ) )
         7                      k = j;
         8                 j++;
         9            }
         10          if ( k != i )
         11              Swap ( list.V[i], list.V[k] );
         12          i++;
         13      }


 
 McCabe环路复杂性 = 5
 
 (2) 独立路径有5条： 
              Path1： 1→2→14
              Path2： 1→2→3→5→10→11→12→13→2→14
              Path3： 1→2→3→5→10→12→13→2→14
              Path4: 1→2→3→5→6→7→8→9→5→10→11→12→13→2→14 
              Path5:  1→2→3→5→6→8→9→5→10→11→12→13→2→14
      ①③
      ①②⑤⑧……
      ①②⑤⑨……
      ①②④⑥……
      ①②④⑦……
 (3) 为各测试路径设计测试用例:
     Path1： 取n = 1
     路径①②⑤⑧……：取n = 2,
       预期结果：路径⑤⑧③不可达  
     路径①②⑤⑨……：取n = 2,
       预期结果：路径⑤⑨③不可达
     路径①②④⑥⑤⑧③：
         取n = 2, V[0] = 2, V[1] = 1, 预期结果：k = 1, V[0] = 1, V[1] = 2
     路径①②④⑥⑤⑨③：
         取n = 2, V[0] = 2, V[1] = 1, 预期结果：k = 1, 路径⑨③不可达
     路径①②④⑦⑤⑧③：
         取n = 2, V[0] = 1, V[1] = 2, 预期结果：k = 0, 路径⑧③不可达
     路径①②④⑦⑤⑨③：
         取n = 2, V[0] = 1, V[1] = 2, 预期结果：k = 0, V[0] = 1, V[1] = 2

7、下面是快速排序算法中的一趟划分算法，其中datalist是数据表，它有两个数据成员：一是元素类型为Element的数组V，另一个是数组大小n。算法中用到两个操作，一是取某数组元素V[i]的关键码操作getKey ( )，一是交换两数组元素内容的操作Swap( )：
int Partition ( datalist &list, int low, int high ) {
//在区间[ low, high ]以第一个对象为基准进行一次划分，k返回基准对象回放位置。
int  k = low;  Element pivot = list.V[low]; //基准对象
for ( int i = low+1; i <= high; i++ ) //检测整个序列，进行划分
if ( list.V[i].getKey ( ) < pivot.getKey( ) && ++ k != i ) 
Swap ( list.V[k], list.V[i] ); //小于基准的交换到左侧去
Swap ( list.V[low], list.V[k] ); //将基准对象就位 
return k; //返回基准对象位置
    }
 (1) 试画出它的程序流程图；
 (2) 试利用路径覆盖方法为它设计足够的测试用例（循环次数限定为0次，1次和2次）。
解答：（1）流程图如下。
 
(2) 测试用例设计  

8、下面是一段插入排序的程序，将R[k+1]插入到R[1…k]的适当位置。
　　R[0] = R[k+1]; 
　　j = k;
　　while (R[j] > R[0]) 
　　　{
　　　　R[j+1] = R[j];
　　　　j--; 
　　　}
　　R[j+1] = R[0];
用路径覆盖方法为它设计足够的测试用例（while循环次数为0、1、2次）。
答：　　画出该程序的流程图：
 

测试用例设计：