湖北科技学院
软件测试实验报告
课程名称
软件测试方法与技术
班级
实验日期
姓名
学号
实验成绩
实验名称
白盒测试实验
实验目的与要求
(1)掌握白盒测试技术,并能应用白盒测试技术设计测试用例
(2)能用Junit 实施测试
实验环境
主流 PC 机一套,需安装windows 操作系统、Office、Eclipse 和Junit
题目一:用逻辑覆盖测试方法测试以下程序段
void DoWork (int x,int y,int z){
1 int k=0, j=0;
2 if ( (x>3)&&(z<10) )
3 {
4 k=x*y-1;
5 j=sqrt(k);
6 }
7 if((x==4)||(y>5))
8 j=x*y+10;
9 j=j%3;
10 }
说明:程序段中每行开头的数字(1~10)是对每条语句的编号。
1)画出程序的控制流图(用题中给出的语句编号表示)。
2)分别以语句覆盖、判定覆盖、条件覆盖、判定/条件覆盖、组合覆盖和路径覆盖方法设计测试用例,并写出每个测试用例的执行路径(用题中给出的语句编号表示)。
题目二、折半查
请按要求对下面的java 代码进行测试。代码的功能是:用折半查法在元素呈升序排列的数组中查值为key 的元素。
public int binSearch ( int array[], int key ) {
int mid, low, high;
low = 0;
high = array.length-1;
while ( low <= high ) {
mid = (low high)/2;
if ( key = = array [mid] )
return mid;
else if ( key < array [mid] )
high = mid -1;
else
low = mid 1
}
return -1;
}
1 试计算此程序段的McCabe 复杂性;
2 用基本路径覆盖法给出测试路径;
3 为各测试路径设计测试用例。
1)题目一
程序的流程图如下:
程序的控制流图如下:
语句覆盖的测试用例:
语句覆盖是设计足够的测试用例使程序中的每一条可执行语句至少执行一次。这题中,两个if语句的判定之后,只要确保使两个判定都为真,那么所有的执行语句就都可以执行了,即可达到语句覆盖的要求。所以设计的测试用例如下:x = 4 , y = 6 , z = 8 。
这组测试用例的执行路径是1—2—3—4—5—6—7—8—9—10
判定覆盖的测试用例:
判定覆盖要求程序中每个判断的取真分支和取假分支至少经历一次。这题中,有两个判定语句,至少需要设计两组测试用例,才能分别覆盖两个if语句的真分支和假分支。所以设计的测试用例如下:
用例1:x = 4 , y = 6 , z = 8 ,其执行路径是
1—2—3—4—5—6—7—8—9—10 ;
用例2:x = 3 , y = 5 , z = 8 ,其执行路径是1—2—3—6—7—9—10。
条件覆盖的测试用例
条件覆盖要求每个判断中每个条件的可能取值至少要满足一次。这道题目中的条件有四个,分别如下: ① x > 3 ; ② z < 10 ;③ x = = 4 ;④ y > 5 ;
设计用例时要使每个条件分别取真和取假。设计的测试用例如下表。
测试用例编号
测试数据
覆盖条件
执行路径
1
x=3,y=8,z=8
①假②真③假④真
1-2-3-6-7-8-9-10
2
x=4,y=5,z=13
①真②假③真④假
1-2-3-6-7-8-9-10
判定条件覆盖:
判定/条件覆盖要求判断中每个条件的所有可能至少出现一次,并且每个判断本身的可能判定结果也至少出现一次。题目中的条件有四个,分别如下:
1x > 3 ; ② z < 10 ;③ x = = 4 ;④ y > 5 ;
该程序中的分支有四个 。所以设计的测试用例如下表所示:
测试用例编号
测试数据
覆盖条件
执行路径
1
x=4,y=8,z=8
①真②真③真④真
1-2-3-4-5-6-7-8-9-10
2
x=3,y=5,z=13
①假②假③假④假
1-2-3-6-7-9-10
条件组合覆盖:
条件组合覆盖要求每个判定的所有可能条件取值组合至少执行一次。这道题目中共有四个条件分别如下:
1 x > 3 ; ② z < 10 ;③ x = = 4 ;④ y > 5 ;
设定x > 3 为真时,记作T1 ;为假时,即x 3 , 记作F1 ;
z < 10为真时,记作T2 ;为假时,即z 10 , 记作F2 ;
x = = 4为真时,记作T3 ;为假时,即x ≠ 4 , 记作F3 ;
y > 5为真时,记作T4 ; 为假时,即y ≤ 5 , 记作F4 。
条件组合如下表:
编号
具体条件取值
覆盖条件
判定取值
1
x > 3 , z < 10
T1,T2
第一个判定:取真分支
2
x > 3 , z 10
T1,F2
第一个判定:取假分支
3
x 3 ,z < 10
F1,T2
第一个判定:取假分支
4
x 3 ,z 10
F1,F2
第一个判定:取假分支
5
x = = 4 ,y > 5
T3,T4
第二个判定:取真分支
6
x = = 4 ,y ≤ 5
T3,F4
第二个判定:取真分支
7
x ≠ 4 , y > 5
F3,T4
第二个判定:取真分支
8
x ≠ 4 , y ≤ 5
F3,F4
第二个判定:取假分支
设计的测试用例如下:
测试用例编号
测试数据
覆盖条件
执行路径
1
x = 4 , y = 8 , z = 8
T1,T2,T3,T4
1-2-3-4-5-6-7-8-9-10
2
x = 4 , y = 3 , z = 13
while语句流程图的例题
T1,F2,T3,F4
1-2-3-6-7-8-9-10
3
x = 2 , y = 8 , z = 8
F1,T2,F3,T4
1-2-3-6-7-8-9-10
4
x = 2 , y = 3 , z = 13
F1,F2,F3,F4
1-2-3-6-7-9-10
路径覆盖:
路径覆盖要求覆盖程序中所有可能的路径。这道题中可能的执行路径共有4条,所以需要设计4个测试用例:
测试用例编号
测试数据
执行路径
1
x = 4 , y = 8 , z = 8
1-2-3-4-5-6-7-8-9-10
2
x = 4 , y = 3 , z = 13
1-2-3-6-7-8-9-10
3
x = 6 , y = 2 , z = 8
1-2-3-4-5-6-7-9-10
4
x = 2 , y = 3 , z = 13
1-2-3-6-7-9-10
2 题目二
程序编号后如下:
public int binSearch ( int array[], int key ) {
1.int mid, low, high;
2.low = 0;
3.high = array.length-1;
4.while ( low <= high ) {
5.mid = (low high)/2;
6.if ( key = = array [mid] )
7.return mid;
8.else if ( key < array [mid] )
9.high = mid -1;
10.else
11.low = mid +1
12.}
13.return -1;
14.}
程序的流程图如下:
程序的控制流图如下:
程序的环路复杂性即McCabe复杂性度量,简单的定义为控制流图的区域数。从程序的环路复杂性可导出程序基本路径集合中的独立路径条数,这是确保程序中每个可执行语句至少执行一次所必需的最少测试用例数。
通常环路复杂性可用以下三种方法求得。
(1)通过控制流图的边数和节点数计算。设E为控制流图的边数,N为控制流图的节点数,则定义环路复杂性为 V(G)= E N + 2 ;
该图中共有16条边,14个节点,因此 E = 16 ,N = 14 ,
V(G)=E-N+2=16-14+2 = 4 ,程序的环路复杂性为4。
(2)通过控制流图中判定节点数计算。若设P为控制流图中的判定节点数,则有V(G) = P + 1
该图中有3个判定节点,因此其环路复杂性为V(G)=P+1=3+1=4,所以该程序的环路复杂性为4。
(3)将环路复杂性定义为控制流图中的区域数。该控制流图中有4个区域:R1、R2、R3、R4,因此其环路复杂性为4。
通过程序的控制流图导出基本路径集,列出程序的独立路径。
PATH1:1-2-3-4-13-14
PATH2:1-2-3-4-5-6-7-12-4-13-14
PATH3:1-2-3-4-5-6-8-9-12-4-13-14
PATH4:1-2-3-4-5-6-8-10-11-12-4-13-14
根据程序结构和程序环路复杂性设计用例输入数据和预期结果,确保基本路径集中的每一条路径的执行。
用例编号
路径
输入数据
预期输出
1
path1:
1-2-3-4-13-14
array[0]={};
key = 1
-1
2
path2:
1-2-3-4-5-6-7-12-4-13-14
array[3]={2,4,6};
key = 4
1
3
path3:1-2-3-4-5-6-8-9-12-4-13-14
array[4]={2,4,6,8};
key = 2
0
4
path4:1-2-3-4-5-6-8-10-11-12-4-13-14
array[4]={2,4,6,8};
key = 6
2
实验过程中由于初次使用junit测试工具,在测试过程中对测试方法存在部分问题,已经得到了解决。
本次实验结果基本上与预期结果一致。
白盒测试并不是简单地按照代码设计测试用例,而是需要根据不同的测试需求,结合不同的测试对象,使用合适的方法进行测试。同时白盒测试与程序内部结构相关,因此也称为结构测试或逻辑驱动测试。而在进行白盒测试时,测试者必须检查程序的内部结构,从程序的逻辑结构着手,得出测试数据。因此测试者需要了解程序结构的实现细节等知识,才能有效进行测试用例的设计工作。
1.源程序:
package gy.test2;
public class DoWork{
    public DoWork(int x,int y,int z){
        int k=0,j=0;
        if((x>3) && (z<10)){
            k=x*y-1;
            j=(int) Math.sqrt(k);
        }
        if((x==4)||(y>5))
            j=x*y+10;
        j=j%3;
    }
    public boolean doWork(int x,int y,int z){
        return true;
    }
}
测试程序:
(1)
package gy.test2;
import junit.framework.*;
import org.junit.Test;
public class DoWorkTest1 extends TestCase {
    private static int x,y,z;
    private static DoWork dowork=new DoWork(x,y,z);
    public void setUp() throws Exception {
       
    }
    @Test
    public void testDoWork() {
        assertEquals(true, dowork.doWork(4, 8, 8));
    }
}
(2)
package gy.test2;
import static org.junit.Assert.*;
import org.junit.Test;
public class DoWorkTest2 {
    private static int x,y,z;
    private static DoWork dowork=new DoWork(x,y,z);
    public void setUp() throws Exception {
       
    }
    @Test
    public void testDoWork() {
        assertEquals(true, dowork.doWork(4, 3, 13));
    }
}
(3)
package gy.test2;
import static org.junit.Assert.*;
import org.junit.Test;
public class DoWorkTest3 {
    private static int x,y,z;
    private static DoWork dowork=new DoWork(x,y,z);
    public void setUp() throws Exception {
       
    }
    @Test
    public void testDoWork() {
        assertEquals(true, dowork.doWork(6, 2, 8));
    }
}
(4)
package gy.test2;
import static org.junit.Assert.*;
import org.junit.Test;
public class DoWorkTest4 {
    private static int x,y,z;
    private static DoWork dowork=new DoWork(x,y,z);
    public void setUp() throws Exception {
       
    }
    @Test
    public void testDoWork() {
        assertEquals(true, dowork.doWork(2, 3, 13));
    }
}
2.源程序:
package gy.test;
public class BinSearch {
    public int binSearch (int array[],int key) {
        int mid,low,high;
        low = 0;
        high = array.length-1;
        while (low <= high) {
            mid = (low+high)/2;
            if (key == array[mid])
                return mid;
            else if (key < array [mid])
                high = mid -1;
            else
                low = mid+1;
        }
        return -1;
    }
}
测试程序:
(1)
package gy.test;
import junit.framework.*;
public class BinSearchTest1 extends TestCase{
    private static BinSearch search= new BinSearch();
    private int array[] = {};
    public void setUp() throws Exception {
    }
    public void testBinSearch() {   
        assertEquals(-1, search.binSearch(array, 1));
    }
}
(2)
package gy.test;
import junit.framework.*;
public class BinSearchTest2 extends TestCase {
    private static BinSearch search= new BinSearch();
    private int array[] = {2,4,6};
    public void setUp() throws Exception {
    }
    public void testBinSearch() {   
        assertEquals(1, search.binSearch(array, 4));
    }
}
(3)
package gy.test;
import junit.framework.*;
public class BinSearchTest3 extends TestCase{
    private static BinSearch search= new BinSearch();
    private int array[] = {2,4,6,8};
    public void setUp() throws Exception {
    }
    public void testBinSearch() {   
        assertEquals(0, search.binSearch(array, 2));
    }
}
(4)
package gy.test;
import junit.framework.*;
public class BinSearchTest4 extends TestCase {
    private static BinSearch search= new BinSearch();
    private int array[] = {2,4,6,8};
    public void setUp() throws Exception {
    }
    public void testBinSearch() {   
        assertEquals(2, search.binSearch(array, 6));
    }
}

版权声明:本站内容均来自互联网,仅供演示用,请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198,我们将在24小时内删除。