软件测试报告Junit白盒测试测试用例pairwise等价类覆盖率EMMA.docx
《软件测试报告Junit白盒测试测试用例pairwise等价类覆盖率EMMA.docx》由会员分享，可在线阅读，更多相关《软件测试报告Junit白盒测试测试用例pairwise等价类覆盖率EMMA.docx（23页珍藏版）》请在冰豆网上搜索。
软件测试报告Junit白盒测试测试用例pairwise等价类覆盖率EMMA
软件测试报告
目录
一、简介3
1.1、编写目的3
1.2、测试范围3
二、测试资源3
2.1、人力资源3
2.2、测试环境3
2.3、测试工具4
三、测试4
3.1、greatCircleDistance（）函数4
3.2、compareBytes（）函数7
3.3、getHue（）函数9
3.4、arraycopy（）函数11
3.5、computeIntersection（）函数15
四、遇到的困难及解决方法18
一、简介
1.1、编写目的
使用等价类划分方法对于所选的五个功能模块进行测试，并使用pair-wise方法减少测试用例，并且比较两种测试方法的代码覆盖率。
1.2、测试范围
本次测试主要测试五个模块的功能，使用等价类划分的方法生成JUnit测试用例，并使用pair-wise方法减少测试用例，比较两种方法的覆盖率。
二、测试资源
2.1、人力资源
姓名
角色
具体职责和注释
***
方案设计人、测试技术设计人
策划总体规模，测试内容，规划测试方案；测试并记录测试情况。
***
测试人、记录人、文档整理人
制定测试方案，确定测试深度，测试技术设计；测试并记录测试情况，编写软件测试报告。
2.2、测试环境
下表列出了测试的系统环境
机器环境
工作计算机
软件环境
（相关软件、操作系统等）
WindowsXPSP3
jdk1.6.0_06
EclipsePlatformVersion:
3.3.3
硬件环境
（设备、网络等）
笔记本电脑
2.3、测试工具
用途
工具名称
生产厂商
版本
单元测试
JUNIT
JUnit.org
4.8.2
覆盖率测试
EMMA
EclEmma.org
1.4.3
三、测试
3.1、greatCircleDistance（）函数
greatCircleDistance（）方法计算球面距离，输入的分别为两个点的经度和纬度以及球的半径，以下为其源码：
publicstaticdoublegreatCircleDistance（doublelatitudeS,
doublelongitudeS,doublelatitudeF,doublelongitudeF,doubler）
{
if（latitudeS<=-90||latitudeS>=90||
latitudeF<=-90||latitudeF>=90||
longitudeS<=-180||longitudeS>=180||
longitudeF<=-180||longitudeF>=180||r<0）{
thrownewIllegalArgumentException（）;
}
latitudeS=Math.toRadians（latitudeS）;
latitudeF=Math.toRadians（latitudeF）;
longitudeS=Math.toRadians（longitudeS）;
longitudeF=Math.toRadians（longitudeF）;
doubledeltaLongitude=longitudeF-longitudeS;
doublea=Math.cos（latitudeF）*Math.sin（deltaLongitude）;
doubleb=Math.cos（latitudeS）*Math.sin（latitudeF）;
b-=Math.sin（latitudeS）*Math.cos（latitudeF）
*Math.cos（deltaLongitude）;
doublec=Math.sin（latitudeS）*Math.sin（latitudeF）;
c+=Math.cos（latitudeS）*Math.cos（latitudeF）
*Math.cos（deltaLongitude）;
if（c<0）
c=-c;
returnMath.atan（Math.sqrt（a*a+b*b）/c）*r;
}
一、针对此函数我们运用了等价类划分的方法生成JUnit测试用例总共划分出25个用例，等价类分别是：
●对latitudeS划分：
-90到0,0到90以及不合法输入；
●对longitudeS划分：
-180到0,0到180以及不合法输入；
●对latitudeF划分：
-90到0,0到90以及不合法输入；
●对longitudeF划分：
-180到0,0到180以及不合法输入；
●对半径r的划分：
大于0以及不合法的输入；
以下为具体的测试用例：
latitudeS
longitudeS
latitudeF
longitudeF
r
预期结果
实际测试结果
30
30
30
30
100
0
通过
30
30
30
-120
100
115.98
通过
30
30
-60
30
100
157.08
通过
30
30
-60
-120
100
63.003
通过
30
-60
30
30
100
131.812
通过
30
-60
30
-120
100
89.566
通过
30
-60
-60
30
100
112.296
通过
30
-60
-60
-120
100
135.256
通过
-60
30
30
30
100
157.08
通过
-60
30
30
-120
100
63.003
通过
-60
30
-60
30
100
0
通过
-60
30
-60
-120
100
100.807
通过
-60
-60
30
30
100
112.296
通过
-60
-60
30
-120
100
135.256
通过
-60
-60
-60
30
100
72.273
通过
-60
-60
-60
-120
100
50.536
通过
120
30
60
120
100
抛出异常
通过
-120
30
60
120
100
抛出异常
通过
60
30
120
120
100
抛出异常
通过
60
30
-120
120
100
抛出异常
通过
30
-210
60
120
100
抛出异常
通过
30
210
60
120
100
抛出异常
通过
30
30
60
-210
100
抛出异常
通过
30
30
60
210
100
抛出异常
通过
30
30
60
120
-100
抛出异常
通过
使用EMMA来测量这些测试的代码覆盖率结果如下：
二、使用pair-wise减少测试用例，此次测试总共有13个用例，比原来减少12个用例，此时的代码覆盖率为：
三、对greatCircleDistance（）方法测试的结论：
综合一和二可以看出，直接使用等价类划分的方法对此模块进行测试需要25个用例，而使用pair-wise后用例数减少一半，但是测试时其代码的覆盖率仍然保持100%，从此可以看出使用pair-wise方法的有效性。
3.2、compareBytes（）函数
compareBytes（）方法实现了数组的比较，将数组a的内容与数组b的内容比较，比较时将数组中数据视为无符号数。
当a小于b时返回-1，a大于b时返回1，相等时返回0。
以下为源代码：
publicstaticintcompareBytes（byte[]a,intaOff,byte[]b,intbOff,intlen）
{
if（a==null||b==null）{
thrownewIllegalArgumentException（"Illegalarray"）;
}
if（aOff<0||bOff<0）{
thrownewIllegalArgumentException（"Illegaloffset"）;
}
if（len<0）{
thrownewIllegalArgumentException（"Illegallen"）;
}
if（len>a.length-aOff||len>b.length-bOff）{
thrownewIllegalArgumentException（"Notenoughbyteslefttocompare!
"）;
}
for（inti=0;i//wewantourcomparisontobeunsigned.
finalintab=a[aOff+i]&0xff;
finalintbb=b[bOff+i]&0xff;
if（ab>bb）{
return1;
}elseif（abreturn-1;
}
}
return0;
}
一、针对此函数我们运用了等价类划分的方法生成JUnit测试用例总共划分出22个用例，分别是：
●数组a:
可划分为合法输入与不合法输入（具体为null）；
●aOff:
可以划分为<0以及>=a.length;
●数组b:
可划分为合法输入与不合法输入（具体为null）;
●bOff:
可以划分为<0以及>=b.length;
●len:
可以划分为合法与不合法（具体包括len<0以及len>a.length-aOff||len>b.length–bOff；
●此外，数组a,b还需考虑符号扩展问题。
对于数组中元素，需分别考虑其大于0、小于0的情况（此时，其对应的无符号数大于或等于0x80）。
以下为具体的测试用例：
数组a
aOff
数组b
bOff
len
预期结果
实际测试结果
null
1
{5,6,2,3}
2
2
抛出异常
通过
{1,2,3}
-1
{5,6,2,3}
2
2
抛出异常
通过
{1,2,3}
3
{5,6,2,3}
2
2
抛出异常
通过
{1,2,3}
1
null
2
2
抛出异常
通过
{1,2,3}
1
{5,6,2,3}
-2
2
抛出异常
通过
{1,2,3}
1
{5,6,2,3}
4
2
抛出异常
通过
{1,2,3}
1
{5,6,2,3}
2
-1
抛出异常
通过
{1,2,3,4}
1
{5,6,2,3}
2
3
抛出异常
通过
{1,2,3}
1
{5,6,3,3}
2
2
-1
通过
{1,2,3}
1
{5,6,0xf0,3}
2
2
-1
通过
{1,0xf0,3}
1
{5,6,0xf1,3}
2
2
-1
通过
{1,3,3}
1
{5,6,2,3}
2
2
1
通过
{1,0xff,3}
1
{5,6,2,3}
2
2
1
通过
{1,0xf1,3}
1
{5,6,0xf0,3}
2
2
1
通过
{1,3,2}
1
{5,6,3,3}
2
2
-1
通过
{1,3,0xf0}
1
{5,6,3,0xf1}
2
2
-1
通过
{1,3,3}
1
{5,6,3,2}
2
2
1
通过
{1,3,0xf1}
1
{5,6,3,3}
2
2
1
通过
{1,3,0xf1}
1
{5,6,3,0xf0}
2
2
1
通过
{1,3,0xf0}
1
{5,6,3,0xf0}
2
2
0
通过
使用EMMA来测量这些测试的代码覆盖率结果如下:
二、使用pair-wise减少测试用例，此次测试总共用例数为13个，而未使用之前测试用例数为22个，此时代码的覆盖率为：
三、对compareBytes（）方法测试的结论
综合一和二可以看出，直接使用等价类划分的方法对此模块进行测试需要22个用例，而使用pair-wise后用例数减少一半，但是测试时其代码的覆盖率仍然保持100%，从此可以看出使用pair-wise方法的有效性。
3.3、getHue（）函数
getHue（）方法是计算HSL颜色模型中的Hue参数，以下为其源码：
publicstaticfloatgetHue（floatred,floatgreen,floatblue,floatmax,floatmin）
{
floathue=max-min;
if（hue>0.0f）{
if（max==red）{
hue=（green-blue）/hue;
if（hue<0.0f）{
hue+=6.0f;
}
}
elseif（max==green）{
hue=2.0f+（blue-red）/hue;
}
elseif（max==blue）{
hue=4.0f+（red-green）/hue;
}
else{
thrownewIllegalArgumentException（"invalidmax"）;
}
hue*=60f;
}
elseif（hue<0.0f）{
thrownewIllegalArgumentException（"max}
returnhue;
}
一、针对此函数我们运用了等价类划分的方法生成JUnit测试用例总共划分出6个用例，分别是：
●对max参数进行划分：
max=blue，max=red,max=red
max=green,max不等于以上三种参数中的任何一种，max●当max=red时，进行如下划分：
green>blue，green<=blue
以下为具体的测试用例：
red
green
blue
max
min
预期结果
实际测试结果
0.2
0.6
0.8
0.8
0.2
200
通过
0.8
0.6
0.2
0.8
0.2
40
通过
0.8
0.2
0.6
0.8
0.2
320
通过
0.6
0.8
0.2
0.8
0.2
80
通过
0.6
0.8
0.2
0.5
0.2
抛出异常
通过
0.6
0.8
0.2
0.2
0.8
抛出异常
通过
使用EMMA来测量这些测试的代码覆盖率结果如下:
二、使用pair-wise减少测试用例，此次测试用例数为4个，未使用之前的测试用例数为6个，此次测试的代码覆盖率为：
三、对getHue（）方法测试的结论:
综合一和二可以看出，直接使用等价类划分的方法对此模块进行测试需要6个用例，而使用pair-wise后用例数减少三分之一，但是测试时其代码的覆盖率仍然保持100%，从此可以看出使用pair-wise方法的有效性。
3.4、arraycopy（）函数
Arraycopy（）方法实现了数组的复制，将源数组src的内容复制到数组dst中，以下为源代码：
publicstaticvoidarraycopy（byte[]src,intsrc_position,byte[]dst,intdst_position,intlength）
{
if（src==null）
thrownewIllegalArgumentException（"srcwasnull"）;
if（dst==null）
thrownewIllegalArgumentException（"dstwasnull"）;
if（length<0）
thrownewIllegalArgumentException（"lengthwaslessthan0"）;
if（src_position<0）
thrownewIllegalArgumentException（"src_positionwaslessthan0.Actualvalue"+src_position）;
if（src_position+length>src.length）
thrownewIllegalArgumentException（"src_position+lengthwouldoverrunthesrcarray.Expectedendat"+（src_position+length）+"actualendat"+src.length）;
if（dst_position<0）
thrownewIllegalArgumentException（"dst_positionwaslessthan0.Actualvalue"+dst_position）;
if（dst_position+length>dst.length）
thrownewIllegalArgumentException（"dst_position+lengthwouldoverrunthedstarray.Expectedendat"+（dst_position+length）+"actualendat"+dst.length）;
System.arraycopy（src,src_position,dst,dst_position,length）;
}
一、针对此函数我们运用了等价类划分的方法生成JUnit测试用例总共划分出15个用例，分别是：
●数组Src:
可划分为合法输入与不合法输入（具体为null）；
●src_position:
可分为合法输入以及不合法输入，其中不合法输入包括：
小于0，src_position+length>=src.length，其中合法输入又可分为等于0和大于0；
●数组dst:
可划分为合法输入与不合法输入（具体为null），其中合法输入可分为和src是同一数组以及不是同一数组的情况；
●dst_position:
可分为合法输入以及不合法输入，其中不合法输入包括：
小于0，dst_position+length>=dst.length，其中合法输入又可分为等于0和大于0；
●length:
可划分为合法输入以及不合法输入（具体指length<0）;
以下为具体的测试用例：
数组src
src_position
数组dst
dst_position
length
预期结果
实际测试结果
null
0
{1,2}
0
2
抛出异常
通过
{1,2}
0
null
0
2
抛出异常
通过
{1,2}
-1
{3,4}
0
2
抛出异常
通过
{1,2}
0
{3,4}
-1
2
抛出异常
通过
{1,2}
0
{3,4}
0
-1
抛出异常
通过
{1,2,3}
1
{3,4,5,6}
1
3
抛出异常
通过
{1,2,3,4}
1
{3,4,5}
1
3
抛出异常
通过
{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
0
与src为同一数组
0
5
数组dst最终结果{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
通过
同上
0
同上
2
5
数组dst最终结果{0,1,0,1,2,3,4,,7,8,9,10,11,12,13,14,15,16}
通过
同上
2
同上
0
5
数组dst的最终结果{2,3,4,5,6,5,6,7,8,9,10,11,12,13,14,15,16}
通过
同上
10
同上
3
5
数组dst的最终结果{0,1,2,10,11,12,13,14,8,9,10,11,12,13,14,15,16}
通过
同上
0
{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16}
0
5
数组dst不变
通过
同上
0
同上
2
5
数组dst的最终结果{0,1,0,1,2,3,4,,7,8,9,10,11,12,13,14,15,16}
通过
同上
2
同上
0
5
数组dst的最终结果{2,3,4,5,6,5,6,7,8,9,10,11,12,13,14,15,16}
通过
同上
10
同上
3
5
数组dst的最终结果{0,1,2,10,11,12,13,14,8,9,10,11,12,13,14,15,16}
通过
使用EMMA来测量这些测试的代码覆盖率结果如下：
二、使用pair-wise减少测试用例，此次测试用例数为11个，而未使用之前的测试用例总数为15个，此次测试的覆盖率：
三、对arraycopy（）方法测试的结论:
综合一和二可以看出，直接使用等价类划分的方法对此模块进行测试需要15个用例，而使用pair-wise后用例数减少到11个，但是测试时其代码的覆盖率仍然保持100%，从此可以看出使用pair-wise方法的有效性。
3.5、computeIntersection（）函数
computeIntersection（）方法计算两个矩形相交部分所形成的矩形的坐标，以下为其源码：
publicstaticRectanglecomputeIntersection（intx,inty,intwidth,intheight,Rectangledest）
{
if（dest==null）
returnnull;
if（x<0||y<0||width<0||height<0）
returnnull;
intx1=（x>dest.x）?
x
升级会员 