Junit测试报告.docx
《Junit测试报告.docx》由会员分享，可在线阅读，更多相关《Junit测试报告.docx（15页珍藏版）》请在冰点文库上搜索。
Junit测试报告
Junit单元测试
版本号：
0.1
制定日期：
2010-12
编制
冯宝鹏
日期
2012-04-14
审核
日期
批准
日期
文档修订记录
修订日期
修订内容
修订人
Junit单元测试4
一实验目的4
二实验环境4
三实验内容4
四实验步骤4
五测试用例4
六测试计划6
七测试计划6
八覆盖率测试报告9
1.测试一元二次方程有两个实根的情况9
2.测试二元一次方程有两个虚根的情况10
3.测试一元一次方程有一个根的情况11
4测试不为方程的情况12
九实验总结14
Junit单元测试
一实验目的
1.掌握白盒测试方法，并按单元测试的要求设计测试用例。
2.能熟练应用junit测试工具进行单元测试。
3.进行代码覆盖检查。
二实验环境
主流PC机一套，windows操作系统eclipse开发平台。
三实验内容
1、用java语言编写一个求一元二次方程根的函数
2、设计白盒测试用例，达到分支覆盖
3、使用弱健壮等价类分析方法设计测试用例。
4、根据以上设计的测试用例，编写junit测试代码，并进行测试。
5、利用EclEmma完成测试代码覆盖分析，并生成html格式代码覆盖测试报告。
四实验步骤
（1）根据白盒法设计测试用例，并撰写单元测试计划书。
（2）根据每个测试用例，编写基本Junit的单元测试脚本。
（3）生成html格式的代码覆盖测试报告。
五测试用例
采用条件覆盖法设计用例，使判断中的每个条件的可能取值至少满足一次。
分为四种情况：
（1）一元二次方程有两个实根（简单起见，将方程有两个相同实根，归类为方程有两个实根）
测试用例ID
Equation
测试用例名称
方程有两个实根
测试目的
测试一元二次方程有两个实根情况的正确性
前置条件
a!
=0&&b*b-4*a*c>0
操作步骤与输入
a=1.0f,b=2.0f.,c=1.0f
预期结果
x1=-1.0f,x2=-1.0f
实际结果
x1=-1.0f,x2=-1.0f
执行人
冯宝鹏
日期
4.10
执行人
冯宝鹏
（2）一元二次方程有两个虚根的情况
测试用例ID
Equation
测试用例名称
方程有两虚根
测试目的
测试一元二次方程有两个实根情况的正确性
前置条件
a!
=0&&b*b-4*a*c<0
操作步骤与输入
a=1.0f,b=2.0f,c=2.0f
预期结果
x1=-1.0f,x2=1.0f
实际结果
x1=-1.0f,x2=1.0f
执行人
冯宝鹏
日期
4.10
执行人
冯宝鹏
（3）方程为一元一次方程的情况
测试用例ID
Equation
测试用例名称
方程有一根
测试目的
测试方程为一元一次方程根情况的正确性
前置条件
a=0.0f
操作步骤与输入
a=0.0f,b=2.0f,c=4.0f
预期结果
x1=-2.0,x2=-2.0
实际结果
x1=-2.0,x2=-2.0
执行人
冯宝鹏
日期
4.10
执行人
冯宝鹏
（4）不为方程的情况
测试用例ID
Equation
测试用例名称
不为方程
测试目的
不是方程情况的正确性
前置条件
a=0.0f,b=0.0f
操作步骤与输入
a=0.0f,b=0.0f,c=3.0f
预期结果
x1=x2=1.0f
实际结果
x1=x2=1.0f
执行人
冯宝鹏
日期
4.10
执行人
冯宝鹏
六测试计划
（1）编写一元二次方程源代码，并通过JunitTestCase生成测试代码，并编写测试用例代码。
（2）通过不同的测试用例，分别对源代码进行结构化测试。
（3）生成测试代码覆盖率，并对数据进行分析。
七测试计划
1.功能实现类（采用工具类的方式）
package
import
publicclassEquation{
privatestaticfloatx1;
privatestaticfloatx2;
privatestaticfloatx;
privatestaticfloatreal;
privatestaticfloatimag;
privatestaticfloat[]results;
privatestaticfloata;
privatestaticfloatb;
privatestaticfloatc;
privatestaticfloatdelt;
publicstaticfloat[]calc（floatw,floatp,floatq）throwsException{
results=newfloat[2];
a=w;b=p;c=q;
if（0.0f==a）{//bx+c=0;x=-c/b;
if（0.0f!
=b）{
x=-c/b;
results[0]=x;
print（）;
returnresults;
}
else{
thrownewMyArithmeticException（"除数不能为0"）;
}
}else{
delt=b*b-4*a*c;
if（delt>=0）{
x1=（float）（（-b+Math.sqrt（delt））/（2*a））;
x2=（float）（（-b-Math.sqrt（delt））/（2*a））;
results[0]=x1;
results[1]=x2;
print（）;
returnresults;
}else{
real=-b/（2*a）;
imag=（float）（Math.sqrt（-delt）/（2*a））;
results[0]=real;
results[1]=imag;
print（）;
returnresults;
}
}
}
publicstaticvoidprint（）{
if（0.0f==a）{
if（0.0f!
=b）{
System.out.println（"该方程是一元一次方程，其根为：
x="+results[0]）;
}else{
System.err.println（"不是一个方程！
"）;
}
}else{
if（delt>=0）{
System.out.println（"该方程是一元二次方程，两根分别为：
x1="+results[0]+",x2="+results[1]）;
}else{
System.out.println（"该一元二次方程的根为复数,两根分别为:
x1="+results[0]+"+"+results[1]+"i"+",x2="+results[0]+"-"+results[1]+"i"）;
}
}
}
}
2.自定义异常类
package
publicclassMyArithmeticExceptionextendsException{
publicMyArithmeticException（）{
}
publicMyArithmeticException（Stringmessage）{
super（message）;
}
publicMyArithmeticException（Throwablecause）{
super（cause）;
}
publicMyArithmeticException（Stringmessage,Throwablecause）{
super（message,cause）;
}
}
3.Junit单元测试类
packagetest;
import
import
import
publicclassEquationTest{
@Test
publicvoidtestCalc（）{
floata=1.0f;
floatb=2.0f;
floatc=1.0f;
float[]expecteds={-1.0f,-1.0f};
//float[]expecteds={-0.5f,0.5f};
//floatexpecteds=-0.5f;
float[]results;
try{
results=Equation.calc（a,b,c）;
Assert.assertArrayEquals（expecteds,results,0.0f）;
//Assert.assertEquals（expecteds,results[0],0.0f）;
}catch（Exceptione）{
e.printStackTrace（）;
}
}
}
八覆盖率测试报告
1.测试一元二次方程有两个实根的情况
OVERALL?
COVERAGE?
SUMMARY
name
class,?
%
method,?
%
block,?
%
line,?
%
all?
classes
67%?
?
（2/3）
44%?
?
（4/9）
50%?
?
（124/249）
46%?
?
（23/50）
OVERALL?
STATS?
SUMMARY
total?
packages:
3
total?
executable?
files:
3
total?
classes:
3
total?
methods:
9
total?
executable?
lines:
50
COVERAGE?
BREAKDOWN?
BY?
PACKAGE
name
class,?
%
method,?
%
block,?
%
line,?
%
0%?
?
?
（0/1）
0%?
?
?
（0/4）
0%?
?
?
（0/16）
0%?
?
?
（0/8）
100%?
（1/1）
67%?
?
（2/3）
47%?
?
（93/199）
47%?
?
（15/32）
test
100%?
（1/1）
100%?
（2/2）
91%?
?
（31/34）
80%?
?
（8/10）
覆盖代码：
Equation.java
results=newfloat[2];
a=w;b=p;c=q;
if（0.0f==a）{//bx+c=0;x=-c/b;
}else{
delt=b*b-4*a*c;
if（delt>=0）{
x1=（float）（（-b+Math.sqrt（delt））/（2*a））;
x2=（float）（（-b-Math.sqrt（delt））/（2*a））;
results[0]=x1;
results[1]=x2;
print（）;
returnresults;
}else{
if（delt>=0）{
System.out.println（"该方程是一元二次方程，两根分别为：
x1="+results[0]+",x2="+results[1]）;
2.测试二元一次方程有两个虚根的情况
OVERALL?
COVERAGE?
SUMMARY
name
class,?
%
method,?
%
block,?
%
line,?
%
all?
classes
67%?
?
（2/3）
44%?
?
（4/9）
52%?
?
（129/249）
46%?
?
（23/50）
OVERALL?
STATS?
SUMMARY
total?
packages:
3
total?
executable?
files:
3
total?
classes:
3
total?
methods:
9
total?
executable?
lines:
50
COVERAGE?
BREAKDOWN?
BY?
PACKAGE
name
class,?
%
method,?
%
block,?
%
line,?
%
0%?
?
?
（0/1）
0%?
?
?
（0/4）
0%?
?
?
（0/16）
0%?
?
?
（0/8）
100%?
（1/1）
67%?
?
（2/3）
49%?
?
（98/199）
47%?
?
（15/32）
test
100%?
（1/1）
100%?
（2/2）
91%?
?
（31/34）
80%?
?
（8/10）
代码覆盖情况：
results=newfloat[2];
a=w;b=p;c=q;
if（0.0f==a）{//bx+c=0;x=-c/b;
delt=b*b-4*a*c;
if（delt>=0）{
real=-b/（2*a）;
imag=（float）（Math.sqrt（-delt）/（2*a））;
results[0]=real;
results[1]=imag;
print（）;
returnresults;
if（0.0f==a）{
if（delt>=0）{
System.out.println（"该一元二次方程的根为复数,两根分别为:
x1="+results[0]+"+"+results[1]+"i"+",x2="+results[0]+"-"+results[1]+"i"）;
3.测试一元一次方程有一个根的情况
OVERALL?
COVERAGE?
SUMMARY
name
class,?
%
method,?
%
block,?
%
line,?
%
all?
classes
67%?
?
（2/3）
44%?
?
（4/9）
31%?
?
（76/244）
40%?
?
（20/50）
OVERALL?
STATS?
SUMMARY
total?
packages:
3
total?
executable?
files:
3
total?
classes:
3
total?
methods:
9
total?
executable?
lines:
50
COVERAGE?
BREAKDOWN?
BY?
PACKAGE
name
class,?
%
method,?
%
block,?
%
line,?
%
0%?
?
?
（0/1）
0%?
?
?
（0/4）
0%?
?
?
（0/16）
0%?
?
?
（0/8）
100%?
（1/1）
67%?
?
（2/3）
25%?
?
（50/199）
38%?
?
（12/32）
test
100%?
（1/1）
100%?
（2/2）
90%?
?
（26/29）
80%?
?
（8/10）
代码覆盖情况：
results=newfloat[2];
a=w;b=p;c=q;
if（0.0f==a）{//bx+c=0;x=-c/b;
if（0.0f!
=b）{
x=-c/b;
results[0]=x;
print（）;
returnresults;
if（0.0f==a）{
if（0.0f!
=b）{
System.out.println（"该方程是一元一次方程，其根为：
x="+results[0]）;
4测试不为方程的情况
抛出自定义异常：
OVERALL?
COVERAGE?
SUMMARY
name
class,?
%
method,?
%
block,?
%
line,?
%
all?
classes
100%?
（3/3）
44%?
?
（4/9）
14%?
?
（33/234）
23%?
?
（11/48）
OVERALL?
STATS?
SUMMARY
total?
packages:
3
total?
executable?
files:
3
total?
classes:
3
total?
methods:
9
total?
executable?
lines:
48
COVERAGE?
BREAKDOWN?
BY?
PACKAGE
name
class,?
%
method,?
%
block,?
%
line,?
%
100%?
（1/1）
33%?
?
（1/3）
11%?
?
（22/199）
16%?
?
（5/32）
100%?
（1/1）
25%?
?
（1/4）
25%?
?
（4/16）
25%?
?
（2/8）
test
100%?
（1/1）
100%?
（2/2）
37%?
?
（7/19）
50%?
?
（4/8）
代码覆盖情况：
Equation.java
results=newfloat[2];
a=w;b=p;c=q;
if（0.0f==a）{//bx+c=0;x=-c/b;
if（0.0f!
=b）{
thrownewMyArithmeticException（"除数不能为0"）;
MyArithmeticException.java
publicMyArithmeticException（Stringmessage）{
super（message）;
}
EquationTest.java
publicclassEquationTest{
}catch（Exceptione）{
e.printStackTrace（）;
}
}
九实验总结
通过本次实验，对Junit单元测试框架有了一定的理解。
同时，熟悉了开源框架的使用，通过查找API
函数，比如Assert.assertArrayEquals、Assert.assertEquals可以进行断言测试等等。
总之，通过本次实验，使我对软件测试有了一个初步的认识，开启了今后学习软件测试之门。
升级会员 