SCMLife.com

 找回密码
 立即注册

QQ登录

只需一步,快速开始

扫一扫,访问微社区

查看: 3473|回复: 1

[转贴] 应用JUnit实施单元测试

[复制链接]
发表于 2012-5-11 17:34:50 | 显示全部楼层 |阅读模式

$ n# x* [0 K" [) G# h6 i  H# b测试的概念
9 q. x4 W6 e: g6 H4 a6 L+ g6 ^7 d3 z# V: m
长期以来,我所接触的软件开发人员很少有人能在开发的过程中进行测试工作。大部分的项目都是在最终验收的时候编写测试文档。有些项目甚至没有测试文档。现在情况有了改变。我们一直提倡UML、RUP、软件工程、CMM,目的只有一个,提高软件编写的质量。举一个极端的例子:如果你是一个超级程序设计师,一个传奇般的人物。(你可以一边喝咖啡,一边听着音乐,同时编写这操作系统中关于进程调度的模块,而且两天时间内就完成了!)我真得承认,有这样的人。(那个编写UNIX中的vi编辑器的家伙就是这种人。)然而非常遗憾的是这些神仙们并没有留下如何修成正果的README。所以我们这些凡人--在同一时间只能将注意力集中到若干点(据科学统计,我并不太相信,一般的人只能同时考虑最多7个左右的问题,高手可以达到12个左右),而不能既纵览全局又了解细节--只能期望于其他的方式来保证我们所编写的软件质量。
1 B2 x$ T( U8 H" ^& v5 X$ F1 J
2 i( a; b8 C. Z为了说明我们这些凡人是如何的笨。有一个聪明人提出了软件熵(software entropy)的概念:一个程序从设计很好的状态开始,随着新的功能不断地加入,程序逐渐地失去了原有的结构,最终变成了一团乱麻。你可能会争辩,在这个例子中,设计很好的状态实际上并不好,如果好的话,就不会发生你所说的情况。是的,看来你变聪明了,可惜你还应该注意到两个问题:1)我们不能指望在恐龙纪元(大概是十年前)设计的结构到了现在也能适用吧。2)拥有签字权的客户代表可不理会加入一个新功能是否会对软件的结构有什么影响,即便有影响也是程序设计人员需要考虑的问题。如果你拒绝加入这个你认为致命的新功能,那么你很可能就失去了你的住房贷款和面包(对中国工程师来说也许是米饭或面条,要看你是南方人还是北方人)。
  |4 ]6 \8 z; h" d& e
4 \) b' X$ f) d另外,需要说明的是我看过的一些讲解测试的书都没有我写的这么有人情味(不好意思...)。我希望看到这片文章的兄弟姐妹能很容易地接受测试的概念,并付诸实施。所以有些地方写的有些夸张,欢迎对测试有深入理解的兄弟姐妹能体察民情,并不吝赐教。 & b* n2 p! R2 [* H8 W* ]( u
3 \* \2 U# R& a: I+ N8 T$ u* ~
好了,我们现在言归正传。要测试,就要明白测试的目的。我认为测试的目的很简单也极具吸引力:写出高质量的软件并解决软件熵这一问题。想象一下,如果你写的软件和Richard Stallman(GNU、FSF的头儿)写的一样有水准的话,是不是很有成就感?如果你一致保持这种高水准,我保证你的薪水也会有所变动。 : p5 M3 K/ j9 @4 _
# |' I& M3 A) Q' P3 G
测试也分类,白箱测试、黑箱测试、单元测试、集成测试、功能测试...。我们先不管有多少分类,如何分类。先看那些对我们有用的分类,关于其他的测试,有兴趣的人可参阅其他资料。白箱测试是指在知道被测试的软件如何(How)完成功能和完成什么样(What)的功能的条件下所作的测试。一般是由开发人员完成。因为开发人员最了解自己编写的软件。本文也是以白箱测试为主。黑箱测试则是指在知道被测试的软件完成什么样(What)的功能的条件下所作的测试。一般是由测试人员完成。黑箱测试不是我们的重点。本文主要集中在单元测试上,单元测试是一种白箱测试。目的是验证一个或若干个类是否按所设计的那样正常工作。集成测试则是验证所有的类是否能互相配合,协同完成特定的任务,目前我们暂不关心它。下面我所提到的测试,除非特别说明,一般都是指单元测试。
( {& e5 |& v! O: W& {6 }/ `% @  j. z8 y' r. |7 W9 i/ [3 q
需要强调的是:测试是一个持续的过程。也就是说测试贯穿与开发的整个过程中,单元测试尤其适合于迭代增量式(iterative and incremental)的开发过程。Martin Fowler(有点儿像引用孔夫子的话)甚至认为:“在你不知道如何测试代码之前,就不应该编写程序。而一旦你完成了程序,测试代码也应该完成。除非测试成功,你不能认为你编写出了可以工作的程序。”我并不指望所有的开发人员都能有如此高的觉悟,这种层次也不是一蹴而就的。但我们一旦了解测试的目的和好处,自然会坚持在开发过程中引入测试。
  S7 q5 D7 Q7 M. ?
8 r9 c7 T( e1 _- x% {$ B因为我们是测试新手,我们也不理会那些复杂的测试原理,先说一说最简单的:测试就是比较预期的结果是否与实际执行的结果一致。如果一致则通过,否则失败。看下面的例子:
+ s9 J8 g$ N5 f0 z! N) q8 Q3 G
$ ]: {% l. [& Q. {5 ^( J
8 c+ ]. z, f% p8 r' \//将要被测试的类
+ j) |! o/ U6 g  e( ~* ?/ m9 apublic class Car { 2 Z: I: j# s- S7 R, X
    public int getWheels() { 8 q# n# Z4 q' ~( s
return 4;
$ b( V1 y5 M+ K- S9 T3 H} # o. P2 _! R; o
}
5 Z/ ]7 c' K6 d  }% X% W+ M3 I- U, S
//执行测试的类   w; E9 x5 h6 s/ C# U
public class testCar {
  r* M$ d0 ]4 G+ l; A% ~public static void main(String[] args) {
( s6 X, N" A# K- E2 y/ _testCar myTest = new testCar(); $ j( G; o+ g" g# g+ b+ f% r
myTest.testGetWheels(); $ d& `& y1 V, w
}
" \9 ?7 ^3 J1 G/ Z& ~! C7 |5 n
; H% I6 X- i% k; @+ Spublic testGetWheels() { # g* L6 T5 f! b7 j' m7 ^9 {
int expectedWheels = 4;
" j* o/ f& F2 w7 i" aCar myCar = Car(); , n) d/ y7 |8 D- Y" L. R  [" P9 v
if (expectedWheels==myCar.getWheels())  7 L! K( V  I8 T6 q' K
System.out.println("test [Car]: getWheels works perfected!");
% V4 P7 ~8 v: n& W7 w1 P5 uelse
! @  c! F+ ^( F; m. q  ~3 BSystem.out.println("test [Car]: getWheels DOESN'T work!");
- Z# Z% u% }. D} ! d; ~) V% R" }" M( D4 C5 a
} : L& [2 _( b; h/ J- G( h5 w  w+ j1 A
4 v$ y) V2 n: C2 C% k
如果你立即动手写了上面的代码,你会发现两个问题,第一,如果你要执行测试的类testCar,你必须必须手工敲入如下命令:
3 |' U+ u7 P/ m/ I5 R% u# {) b2 Q' z# j
[Windows] d:>java testCar  
+ b8 j7 K: u, X9 S. j5 R6 c. p- ]   [Unix] % java testCar 1 L* J! C% x! _
8 J4 ~9 Z# E; e) W
即便测试如例示的那样简单,你也有可能不愿在每次测试的时候都敲入上面的命令,而希望在某个集成环境中(IDE)点击一下鼠标就能执行测试。后面的章节会介绍到这些问题。第二,如果没有一定的规范,测试类的编写将会成为另一个需要定义的标准。没有人希望查看别人是如何设计测试类的。如果每个人都有不同的设计测试类的方法,光维护被测试的类就够烦了,谁还顾得上维护测试类?另外有一点我不想提,但是这个问题太明显了,测试类的代码多于被测试的类!这是否意味这双倍的工作?不!1)不论被测试类-Car 的 getWheels 方法如何复杂,测试类-testCar 的testGetWheels 方法只会保持一样的代码量。2)提高软件的质量并解决软件熵这一问题并不是没有代价的。testCar就是代价。 0 Y! Z" @0 j5 E3 h8 t. g2 [

- e2 ]2 x  G* V& m2 ~我们目前所能做的就是尽量降低所付出的代价:我们编写的测试代码要能被维护人员容易的读取,我们编写测试代码要有一定的规范。最好IDE工具可以支持这些规范。 好了,你所需要的就是JUnit。一个Open Source的项目。用其主页上的话来说就是:“JUnit是由 Erich Gamma 和 Kent Beck 编写的一个回归测试框架(regression testing framework)。用于Java开发人员编写单元测试之用。”所谓框架就是 Erich Gamma 和 Kent Beck 定下了一些条条框框,你编写的测试代码必须遵循这个条条框框:继承某个类,实现某个接口。其实也就是我们前面所说的规范。好在JUnit目前得到了大多数软件工程师的认可。遵循JUnit我们会得到很多的支持。回归测试就是你不断地对所编写的代码进行测试:编写一些,测试一些,调试一些,然后循环这一过程,你会不断地重复先前的测试,哪怕你正编写其他的类,由于软件熵的存在,你可能在编写第五个类的时候发现,第五个类的某个操作会导致第二个类的测试失败。通过回归测试我们抓住了这条大Bug。
) @: n* h4 F) c
$ q" h* x/ R) |1 T& ?
1 v7 T  X' i$ j5 F$ t2 }回归测试框架-JUnit
7 A+ L: W6 d% b" ]; E通过前面的介绍,我们对JUnit有了一个大概的轮廓。知道了它是干什么的。现在让我们动手改写上面的测试类testCar使其符合Junit的规范--能在JUnit中运行。
5 u: E% y4 `" w6 ^( }: Z0 {# {; F2 G# p1 Y$ e7 [/ V/ b
//执行测试的类(JUnit版) ( t" l+ W# a) s6 V7 M! I
import junit.framework.*;
* A! P! p- X' s  {% s* D) d1 K+ |+ }. Q, m7 e9 ~# U% k0 K
public class testCar extends TestCase {
8 K9 D* \7 j; Y  N9 x
9 |2 D" {7 H( Z8 Y+ y$ wprotected int expectedWheels; ( V7 _, M4 t4 Q& N, b$ y. z  Q& I5 y
protected Car myCar;
8 {4 j. ]- f$ ~6 o
' y. {7 B3 N/ w3 L+ J# [* ipublic testCar(String name) {
& n5 B/ }" a+ \+ W: {, a$ F' J' Gsuper(name);
+ t4 I. K% n8 f# [: E1 x} 6 }# b; S* r2 a$ `) j, {

) Q  s3 @0 h1 S. `7 [1 lprotected void setUp() { # O* I9 z3 O, k7 R/ T
expectedWheels = 4;
$ W) H& a, z; k3 ?( `3 umyCar = new Car(); 6 e; z6 B9 E: k- D% n
}
  y* D* ]/ [4 }
- W& |% T' @' s6 S! x! U6 ipublic static Test suite() {
- D2 L8 c# V3 E% S! X/* ; U. M( N- m0 O9 b) t
* the type safe way 8 @* c! V7 r7 a9 s3 {
*
/ H/ |8 w' P1 Y9 z. `' rTestSuite suite= new TestSuite(); $ g4 J! D# C. @3 ^
suite.addTest(
2 n# U. B2 O; @; unew testCar("Car.getWheels") { 3 g  C* W$ A1 @$ |1 T
protected void runTest() { testGetWheels(); }
/ B1 z! V( k1 r) t} : z, j! |6 g2 j, K# T9 \2 m
); . k3 ?3 g# `4 f! m' E. c& ^! t
return suite;
2 ^+ @1 U9 @+ M1 O4 z" L/ X1 z6 R( d*/
8 X8 n, d/ D- U7 o) k3 x$ g  f( W
5 w4 T. F& K8 W3 F/ v/*
" ]2 g& R4 b% s, ?% ?) u* the dynamic way
# ~" p( P" C" W) [/ Y  }. u7 v2 E$ ^*/
+ v4 Y: H) l4 @" breturn new TestSuite(testCar.class); . u. K3 ^/ g7 V+ t- d, R+ p2 N0 \
}
' b  H9 Z/ R& Q( i( w6 i, h9 |" E% z  e" F7 J
public void testGetWheels() { 4 b' i! v) ]2 q% \3 _' ~8 v
assertEquals(expectedWheels, myCar.getWheels());
, x! H# {+ C" T3 ~) {, n! @$ v9 C}
& e5 u$ ~/ s9 t- v; M+ g+ D( ~}   Y9 H7 @/ R1 r1 l
/ F( A; n# K9 d  B
改版后的testCar已经面目全非。先让我们了解这些改动都是什么含义,再看如何执行这个测试。
3 n9 Z- @9 C8 O4 o5 J) Y* ?- V" b/ `# W" N/ ^& a$ [# i4 H* x
1>import语句,引入JUnit的类。(没问题吧) ( t, V( `/ f2 f2 M  g+ p
. |) k# V4 f* p* _8 V: t4 h
2>继承 TestCase 。可以暂时将一个TestCase看作是对某个类进行测试的方法的集合。详细介绍请参看JUnit资料
$ M! t6 b) w7 g, x0 \
8 ]. s6 r7 z2 ?0 T2 E; E3>setUp()设定了进行初始化的任务。我们以后会看到setUp会有特别的用处。 9 l: v5 E' N4 a- {' I; f" {

0 r4 O( a; V, G, ^" S; x) r$ t4>testGetWheeels()对预期的值和myCar.getWheels()返回的值进行比较,并打印比较的结果。assertEquals是junit.framework.Assert中所定义的方法,junit.framework.TestCase继承了junit.framework.Assert。 . H3 e- J4 W1 z# \
/ i0 W% C& L4 ^& f9 z; n0 W
5>suite()是一个很特殊的静态方法。JUnit的TestRunner会调用suite方法来确定有多少个测试可以执行。上面的例子显示了两种方法:静态的方法是构造一个内部类,并利用构造函数给该测试命名(test name, 如 Car.getWheels ),其覆盖的runTest()方法,指明了该测试需要执行那些方法--testGetWheels()。动态的方法是利用内省(reflection )来实现runTest(),找出需要执行那些测试。此时测试的名字即是测试方法(test method,如testGetWheels)的名字。JUnit会自动找出并调用该类的测试方法。
5 q9 G, g6 _( _' Q9 j5 `% Y# P! B" W; K
6>将TestSuite看作是包裹测试的一个容器。如果将测试比作叶子节点的话,TestSuite就是分支节点。实际上TestCase,TestSuite以及TestSuite组成了一个composite Pattern。 JUnit的文档中有一篇专门讲解如何使用Pattern构造Junit框架。有兴趣的朋友可以查看JUnit资料。
3 e# f  Q3 J1 b, k5 z( i! j0 Q
& Q" l' x$ `8 s, ~( j- Z) f1 B; z如何运行该测试呢?手工的方法是键入如下命令:
; G9 d- `) h; |& U" ]; X) a5 c. `! o# {& F2 E, S
[Windows] d:>java junit.textui.TestRunner testCar  
  \- R$ I( h$ E6 T3 T# k( J% q/ v   [Unix] % java junit.textui.TestRunner testCar
/ H4 T( V; V7 v% _; y, R- G. V
5 K* y1 d9 p! a0 N# w% v6 G别担心你要敲的字符量,以后在IDE中,只要点几下鼠标就成了。运行结果应该如下所示,表明执行了一个测试,并通过了测试: / Z8 T+ ?& _9 L6 X9 r9 x: \
) L0 z+ E- f) v8 p6 u( E' q8 K1 T4 c
.
, t, M; ~) i, E1 H- P, uTime: 0
# Z' s' j& v% P) _
2 O0 v' [0 o+ ?. d/ l& T8 @OK (1 tests)
% {, X8 s2 \$ t& Q1 F& p0 T3 C% \- l$ }) t$ }
如果我们将Car.getWheels()中返回的的值修改为3,模拟出错的情形,则会得到如下结果:  
5 f- t* }6 G# H  D* Z! b9 k- L.F 6 z3 r3 @0 _. _
Time: 0 . a/ k& [, S0 `. J' R3 v+ N$ @$ e
There was 1 failure:
$ K' C7 A; C  e& Y1) testGetWheels(testCar)junit.framework.AssertionFailedError: expected:<4> but was:<3> & Z. t$ _5 n7 s  H5 B. V* {
at testCar.testGetWheels(testCar.java:37) 1 O2 B# H) `0 E, d
+ e8 I  c# N$ Q5 c8 T: q
FAILURES!!! & K& b0 r7 l& [# F
Tests run: 1,  Failures: 1,  Errors: 0 - Y8 d+ x5 S' a0 Y% F; N
/ c( i! q; |) w& D  _
注意:Time上的小点表示测试个数,如果测试通过则显示OK。否则在小点的后边标上F,表示该测试失败。注意,在模拟出错的测试中,我们会得到详细的测试报告“expected:<4> but was:<3>”,这足以告诉我们问题发生在何处。下面就是你调试,测试,调试,测试...的过程,直至得到期望的结果。
8 m4 B; K% O8 F! j6 y4 r5 X1 }8 K

: }) G4 |. ]  L0 ?! r0 \Design by Contract(这句话我没法翻译)
, M# n5 G$ s8 h) w
9 k! j7 a2 T6 SDesign by Contract本是Bertrand Meyer(Eiffel语言的创始人)开发的一种设计技术。我发现在JUnit中使用Design by Contract会带来意想不到的效果。Design by Contract的核心是断言(assersion)。断言是一个布尔语句,该语句不能为假,如果为假,则表明出现了一个bug。Design by Contract使用三种断言:前置条件(pre-conditions)、后置条件(post-conditions)和不变式(invariants)这里不打算详细讨论Design by Contract的细节,而是希望其在测试中能发挥其作用。 + u3 M2 c; k8 V% f# l% Z9 X

$ k9 A' M/ C1 |前置条件在执行测试之前可以用于判断是否允许进入测试,即进入测试的条件。如 expectedWheels > 0, myCar != null。后置条件用于在测试执行后判断测试的结果是否正确。如 expectedWheels==myCar.getWheels()。而不变式在判断交易(Transaction)的一致性(consistency)方面尤为有用。我希望JUnit可以将Design by Contract作为未来版本的一个增强。
: o3 Z) I/ d$ b& J
! J; L7 o0 {  o* P$ [  S  y
9 R( O; B$ w1 E7 X! {1 L+ ARefactoring(这句话我依然没法翻译)
) t0 L" Q9 \6 q1 n; y% l5 N+ R
  s* W& A; O+ {% uRefactoring本来与测试没有直接的联系,而是与软件熵有关,但既然我们说测试能解决软件熵问题,我们也就必须说出解决之道。(仅仅进行测试只能发现软件熵,Refactoring则可解决软件熵带来的问题。)软件熵引出了一个问题:是否需要重新设计整个软件的结构?理论上应该如此,但现实不允许我们这么做。这或者是由于时间的原因,或者是由于费用的原因。重新设计整个软件的结构会给我们带来短期的痛苦。而不停地给软件打补丁甚至是补丁的补丁则会给我们带来长期的痛苦。(不管怎样,我们总处于水深火热之中) ' g# V7 N$ V; L
- H+ H0 {( K9 `
Refactoring是一个术语,用于描述一种技术,利用这种技术我们可以免于重构整个软件所带来的短期痛苦。当你refactor时,你并不改变程序的功能,而是改变程序内部的结构,使其更易理解和使用。如:该变一个方法的名字,将一个成员变量从一个类移到另一个类,将两个类似方法抽象到父类中。所作的每一个步都很小,然而1-2个小时的Refactoring工作可以使你的程序结构更适合目前的情况。Refactoring有一些规则: . F! L1 K! q9 L! w% j
& t* P. }4 E; w6 w
1> 不要在加入新功能的同时refactor已有的代码。在这两者间要有一个清晰的界限。如每天早上1-2个小时的Refactoring,其余时间添加新的功能。
* P3 d( v( \8 b7 O; y# d
7 {  R, t' L4 U5 Z9 m2> 在你开始Refactoring前,和Refactoring后都要保证测试能顺利通过。否则Refactoring没有任何意义。
% S% |6 F- ?) w$ v, @. e% }& P+ O  B+ W* P5 N2 z
3> 进行小的Refactoring,大的就不是Refactoring了。如果你打算重构整个软件,就没有必要Refactoring了。
) y' d* M6 f2 ^6 q: J+ f
7 f0 S2 g9 C! D! a1 v6 F8 {9 V0 [只有在添加新功能和调试bug时才又必要Refactoring。不要等到交付软件的最后关头才Refactoring。那样和打补丁的区别不大。Refactoring 用在回归测试中也能显示其威力。要明白,我不反对打补丁,但要记住打补丁是应该最后使用的必杀绝招。(打补丁也需要很高的技术,详情参看微软网站)
8 r; X! M% Z6 r9 `, Z9 ]% {
& E, d8 K8 J9 r7 y2 ?0 W$ Q; q! }* E& ?2 y/ w7 X
IDE对JUnit的支持
; Y6 h6 a8 G  r: O" A! m( E3 z8 k- ]7 U( m# Z2 O- {0 A2 k7 ~
目前支持JUnit的Java IDE 包括 IDE 方式 个人评价(1-5,满分5)  & t+ O1 i0 K5 h" x9 w
Forte for Java 3.0 Enterprise Edition plug-in 3  ! u8 M+ A5 r0 b- o: c/ F7 }1 w
JBuilder 6 Enterprise Edition integrated with IDE 4  
, }1 s. p7 x# d: E2 x$ ]Visual Age for Java  support N/A  + t9 ?+ O- V+ D4 \! v. e
! l7 P5 I: [5 s( V$ B
在IDE中如何使用JUnit,是非常具体的事情。不同的IDE有不同的使用方法。一旦理解了JUnit的本质,使用起来就十分容易了。所以我们不依赖于具体的IDE,而是集中精力讲述如何利用JUnit编写单元测试代码。心急的人可参看资料。
, q$ c: U0 b! z& K
  j, {. M. L; [3 M$ D( F. l
8 ^: r4 ?% ]3 oJUnit简介 4 ~7 p( U) _" A" S4 J; i. g

" |& D9 L) h% P: I' ^4 d7 d- V! t4 j5 O既然我们已经对JUnit有了一个大致的了解,我希望能给大家提供一个稍微正式一些的编写JUnit测试文档的手册,明白其中的一些关键术语和概念。但我要声明的是这并不是一本完全的手册,只能认为是一本入门手册。同其他OpenSource的软件有同样的问题,JUnit的文档并没有商业软件文档的那种有规则,简洁和完全。由开发人员编写的文档总是说不太清楚问题,全整的文档需要参考"官方"指南,API手册,邮件讨论组的邮件,甚至包括源代码中及相关的注释。 ; t$ T/ R- R% e
6 y- X1 K+ Y9 W- K
事实上问题并没有那么复杂,除非你有非常特别的要求,否则,只需参考本文你就可以得到所需的大部分信息。 % `! J0 a- ?; B8 h

) I' {" h' D  L/ |
+ j7 Q( w; C5 Q9 ^1 e" ~; Q/ T安装
6 e6 l' o9 l: p# o
) Z+ H" j: `2 t/ \3 F首先你要获取JUnit的软件包,从JUnit下载最新的软件包(截至写作本文时,JUnit的最新版本是3.7)。将其在适当的目录下解包。这样在安装目录(也就是你所选择的解包的目录)下你找到一个名为junit.jar的文件。将这个jar文件加入你的CLASSPATH系统变量。(IDE的设置会有所不同,参看你所喜爱的IDE的配置指南)JUnit就安装完了。太easy了!
0 Y. s  I0 b9 S: B& N6 u+ ], E7 E
& C( b6 \" w. @5 J' b你一旦安装完JUnit,就有可能想试试我们的Car和testCar类,没问题,我已经运行过了,你得到的结果应该和我列出的结果类似。(以防新版JUnit使我的文章过时)
. J  x8 ?) T. V9 O5 x9 W
: W/ ^: y2 [0 ?. U7 B, i接下来,你可能会先写测试代码,再写工作代码,或者相反,先写工作代码,再写测试代码。我更赞成使用前一种方法:先写测试代码,再写工作代码。因为这样可以使我们编写工作代码时清晰地了解工作类的行为。
4 _6 c% W( l3 \/ m/ Y5 u% v# d5 `! J' A
要注意编写一定能通过的测试代码(如文中的例子)并没有任何意义,只有测试代码能帮助我们发现bug,测试代码才有其价值。此外测试代码还应该对工作代码进行全面的测试。如给方法调用的参数传入空值、错误值和正确的值,看看方法的行为是否如你所期望的那样。 . Y" |% H0 D9 }& n  k+ T
$ z- w3 p: Q$ \8 {( ~
你现在已经知道了编写测试类的基本步骤: 0 j5 d* E  @' `0 H
1>扩展TestCase类;
. _& R0 L* A4 I+ k: ], M2>覆盖runTest()方法(可选);
/ P' C& P/ _& Q" ^: z3 R, D3>写一些testXXXXX()方法; . f) s& E( e1 w
' F9 |: c6 p" M  @
6 t% ~) g. j+ @$ l% J6 f" I8 H7 t% ~
Fixture
2 _% G6 d* d6 z8 A1 W
- f, m& Y+ E: C2 m' r* R( g  r4 p# ?' l解下来的问题是,如果你要对一个或若干个的类执行多个测试,该怎么办?JUnit对此有特殊的解决办法。 ' F+ E1 w! i) T

4 O! w5 U# L- c" m: \5 h; o' Y0 B如果需要在一个或若干个的类执行多个测试,这些类就成为了测试的context。在JUnit中被称为Fixture(如testCar类中的 myCar 和 expectedWheels )。当你编写测试代码时,你会发现你花费了很多时间配置/初始化相关测试的Fixture。将配置Fixture的代码放入测试类的构造方法中并不可取,因为我们要求执行多个测试,我并不希望某个测试的结果意外地(如果这是你要求的,那就另当别论了)影响其他测试的结果。通常若干个测试会使用相同的Fixture,而每个测试又各有自己需要改变的地方。
/ x3 h2 n/ [/ L2 G9 Y( b0 Y2 f* I5 O/ }( X9 D* B: j/ D/ I
为此,JUnit提供了两个方法,定义在TestCase类中。 ) d* f. a" I/ @5 N& \3 ?+ S

' ?  z2 u# A/ V$ A0 gprotected void setUp() throws java.lang.Exception
: d( T( r$ Q4 k3 C% Iprotected void tearDown() throws java.lang.Exception ) y! b, G( c& ?. B: f

2 D" X" l6 Z4 [" b6 q) @覆盖setUp()方法,初始化所有测试的Fixture(你甚至可以在setUp中建立网络连接),将每个测试略有不同的地方在testXXX()方法中进行配置。 " P) P; Z# A1 `
. G# b! x! g, E/ n# [  ]: U
覆盖tearDown()(我总想起一首叫雨滴的吉他曲),释放你在setUp()中分配的永久性资源,如数据库连接。
4 E% `% @4 {2 \, i5 x) c& \7 D1 D8 T: s( W* C* u2 ?$ i/ b
当JUnit执行测试时,它在执行每个testXXXXX()方法前都调用setUp(),而在执行每个testXXXXX()方法后都调用tearDown()方法,由此保证了测试不会相互影响。 8 s$ s# M' s  y7 i- X
: @! x; s$ b/ A* h; P/ |
! d' d8 \% i, r" n! w3 I% D
TestCase ! M3 F* P$ j) P) \7 ?* R- @
0 v( Y  o, B- @; {6 u
需要提醒一下,在junit.framework.Assert类中定义了相当多的assert方法,主要有assert(), assert(), assertEquals(), assertNull(), assertSame(), assertTrue(), fail()等方法。如果你需要比较自己定义的类,如Car。assert方法需要你覆盖Object类的equals()方法,以比较两个对象的不同。实践表明:如果你覆盖了Object类的equals()方法,最好也覆盖Object类的hashCode()方法。再进一步,连带Object类的toString()方法也一并覆盖。这样可以使测试结果更具可读性。 $ u8 g8 j+ u% _8 {; R# Y6 J

" b0 Y+ A% y) I" U" d$ k当你设置好了Fixture后,下一步是编写所需的testXXX()方法。一定要保证testXXX()方法的public属性,否则无法通过内省(reflection)对该测试进行调用。
5 N' f: w: p; {
' \! X. V& m5 P3 a3 w每个扩展的TestCase类(也就是你编写的测试类)会有多个testXXX()方法。一个testXXX()方法就是一个测试。要想运行这个测试,你必须定义如何运行该测试。如果你有多个testXXX()方法,你就要定义多次。JUnit支持两种运行单个测试的方法:静态的和动态的方法。 ; S& O: f  q( H

9 p7 C- H$ D3 \0 {0 {  R! P4 L+ ]静态的方法就是覆盖TestCase类的runTest()方法,一般是采用内部类的方式创建一个测试实例:  9 Z' v5 V) \$ q0 j4 D
TestCase test01 = new testCar("test getWheels") { ; s" N2 d5 o! ?0 L* }( f
public void runTest() {
; u' w% @$ O. N  }" D! ZtestGetWheels(); ' D- `' i6 h5 N- u
}
6 O- }* l# g  s; m3 H}
4 e- z. ?, G2 U6 J. G& J6 K$ E9 Z
' ^1 ?  C  W* J, |! l1 q1 w采用静态的方法要注意要给每个测试一个名字(这个名字可以任意起,但你肯定希望这个名字有某种意义),这样你就可以区分那个测试失败了。
4 a' s- ?. Z, O' Q* p! o8 m3 W
( V* c  D# v$ X) y5 [# L1 m/ |3 m动态的方法是用内省来实现runTest()以创建一个测试实例。这要求测试的名字就是需要调用的测试方法的名字:  
: v4 E# T/ y0 x1 G; T0 xTestCase test01 = new testCar("testGetWheels");
/ r3 ?$ n  y7 b' t7 q
  a0 W* W7 W; N2 Y8 g7 i* cJUnit会动态查找并调用指定的测试方法。动态的方法很简洁,但如果你键入了错误的名字就会得到一个令人奇怪的NoSuchMethodException异常。动态的方法和静态的方法都很好,你可以按照自己的喜好来选择。(先别着急选择,后面还有一种更酷的方法等着你呢。)
1 P2 n0 R5 f- g
' L# h5 e, c! K" a! t& ^# B* \- l
% Z; x% P4 n1 _$ T* {6 [TestSuite
5 b8 C5 Y. T& ]- ^; s9 y) I) `: P& ?: z, {- \
一旦你创建了一些测试实例,下一步就是要让他们能一起运行。我们必须定义一个TestSuite。在JUnit中,这就要求你在TestCase类中定义一个静态的suite()方法。suite()方法就像main()方法一样,JUnit用它来执行测试。在suite()方法中,你将测试实例加到一个TestSuite对象中,并返回这个TestSuite对象。一个TestSuite对象可以运行一组测试。TestSuite和TestCase都实现了Test接口(interface),而Test接口定义了运行测试所需的方法。这就允许你用TestCase和TestSuite的组合创建一个TestSuite。这就是为什么我们前面说TestCase,TestSuite以及TestSuite组成了一个composite Pattern的原因。例子如下:  % c/ }# c1 J  f  ]
public static Test suite() { ; _9 D" L- f2 p9 t- r; h
TestSuite suite= new TestSuite();
- e5 B2 x" j1 F! q- d' h3 wsuite.addTest(new testCar("testGetWheels")); 5 J" }0 i8 p2 B6 e: D/ J
suite.addTest(new testCar("testGetSeats"));
, v  A9 \5 r5 u% A4 Xreturn suite;
8 k: P0 }0 e7 r8 x} , w2 i. f* N2 J' S# @
+ Z( U  Y7 Z. g/ v( \& h+ K
从JUnit 2.0开始,有一种更简单的动态定义测试实例的方法。你只需将类传递给TestSuite,JUnit会根据测试方法名自动创建相应的测试实例。所以你的测试方法最好取名为testXXX()。例子如下:  
- E7 z; d- ~2 {3 P/ O. z( K( Opublic static Test suite() {
. v: h/ {- j0 N1 l- \* V- {return new TestSuite(testCar.class);
4 z" d* A2 b/ u: y$ f* k! _}
! Y1 w5 y( t4 m4 E# K& [0 }/ L
! R8 t$ {/ g8 N从JUnit的设计我们可看出,JUnit不仅可用于单元测试,也可用于集成测试。关于如何用JUnit进行集成测试请参考相关资料。
  c# u5 J, e( \5 C6 \* S
8 V  \' u. |9 v1 u9 E+ \. F5 V2 N为了兼容性的考虑,下面列出使用静态方法的例子:  8 |5 A4 G, K4 A
public static Test suite() { " x8 X3 _: z: b  K# M5 d# C- W. a
TestSuite suite= new TestSuite();
% A3 v* J/ C5 c+ K# t; o+ vsuite.addTest( # X; G) i- T) u( o6 r8 P
new testCar("getWheels") {
, T7 i# P( e1 Oprotected void runTest() { testGetWheels(); }
1 E# L& f* B# r+ Y}
5 n. D+ C. H9 p); & S' w; Q! R7 M3 D
% e, Y$ B3 B" X% ^
suite.addTest( ' b! ]5 B4 a# V) ]+ H! {
new testCar("getSeats") {
* X4 N& F) Z/ ^' Z  k2 m9 nprotected void runTest() { testGetSeats(); } - N  f1 L6 n  ]/ m& G2 n# G
}
1 K* }. Z, z: {. H& V" u8 I1 S);
/ R1 ~; {- ?' v8 [$ r# Sreturn suite;
; {/ p* j$ K) l6 z; u}
( h1 {' C; e. g- ^. s# r! G" R  ^! S2 m& C* Y! W
TestRunner
0 f" m% Q  B) t* Y
+ [) _; c9 _. b有了TestSuite我们就可以运行这些测试了,JUnit提供了三种界面来运行测试  8 G" U8 k7 J! a( O( J" K& g
[Text  UI] junit.textui.TestRunner
/ Y, ]1 v! K  q0 l/ M[AWT   UI] junit.awtui.TestRunner " E/ M6 g* b' Y3 u4 o6 z
[Swing UI] junit.swingui.TestRunner
; o' q% `! p0 W$ r5 l" v, e
; a! G3 M5 V( I0 [2 Y& W我们前面已经看过文本界面了,下面让我们来看一看图形界面:
1 l: p5 _/ ?/ M
. B- L5 F& J1 k% E3 I+ a  
% R0 W$ [* E+ o
2 Y1 `' c2 h# I; }$ Z( O/ _界面很简单,键入类名-testCar。或在启动UI的时候键入类名:  
) X# t2 s6 N4 H" B( b$ E# ~[Windows] d:>java junit.swingui.TestRunner testCar  
. j; x3 B! `. t. E. `   [Unix] % java junit.swingui.TestRunner testCar
* M1 H3 g$ Y0 }5 T2 j
) V  K6 ?, H9 N" C* T) m2 B从图形UI可以更好的运行测试可查单测试结果。还有一个问题需要注意:如果JUnit报告了测试没有成功,JUnit会区分失败(failures)和错误(errors)。失败是一个期望的被assert方法检查到的结果。而错误则是意外的问题引起的,如ArrayIndexOutOfBoundsException。 ( u  M5 x$ v3 r' A' `2 y

: K' H' r& b; S0 ^/ P  W8 M由于TestRunner十分简单,界面也比较直观,故不多介绍。朋友们可自行参考相关资料。 $ H6 d3 g" B1 k# b$ c

/ P/ g9 V, t) O$ i% ?+ @  O# U+ r7 _; U! e
JUnit最佳实践  
  U$ L: X6 X3 m% [& W/ L
! C8 c1 O6 q3 W% B2 AMartin Fowler(又是这位高人)说过:“当你试图打印输出一些信息或调试一个表达式时,写一些测试代码来替代那些传统的方法。”一开始,你会发现你总是要创建一些新的Fixture,而且测试似乎使你的编程速度慢了下来。然而不久之后,你会发现你重复使用相同的Fixture,而且新的测试通常只涉及添加一个新的测试方法。
' M* p( G; k* m* b8 c& d6 I
- P/ g2 r: a: u) D% r9 p' ]你可能会写许多测试代码,但你很快就会发现你设想出的测试只有一小部分是真正有用的。你所需要的测试是那些会失败的测试,即那些你认为不会失败的测试,或你认为应该失败却成功的测试。 : G4 o! n! d3 s

* t- o( G6 V7 ]我们前面提到过测试是一个不会中断的过程。一旦你有了一个测试,你就要一直确保其正常工作,以检验你所加入的新的工作代码。不要每隔几天或最后才运行测试,每天你都应该运行一下测试代码。这种投资很小,但可以确保你得到可以信赖的工作代码。你的返工率降低了,你会有更多的时间编写工作代码。
. A3 G! P* q- `/ K8 E5 _# x  R2 I  _" q3 @1 ^# ?$ R, \' ]2 A4 w
不要认为压力大,就不写测试代码。相反编写测试代码会使你的压力逐渐减轻,应为通过编写测试代码,你对类的行为有了确切的认识。你会更快地编写出有效率地工作代码。下面是一些具体的编写测试代码的技巧或较好的实践方法: 4 ^+ j' Q  q: j1 `) C
( ~) |0 }; `( h- W! U7 G% k
1. 不要用TestCase的构造函数初始化Fixture,而要用setUp()和tearDown()方法。 ' J" W* q0 e, X4 h7 U5 ?
2. 不要依赖或假定测试运行的顺序,因为JUnit利用Vector保存测试方法。所以不同的平台会按不同的顺序从Vector中取出测试方法。 $ X3 w; Y4 c  w
3. 避免编写有副作用的TestCase。例如:如果随后的测试依赖于某些特定的交易数据,就不要提交交易数据。简单的会滚就可以了。 " |0 R% f2 l: q0 j6 q4 V
4. 当继承一个测试类时,记得调用父类的setUp()和tearDown()方法。 ; A( j# b3 U: F/ ^, X( E
5. 将测试代码和工作代码放在一起,一边同步编译和更新。(使用Ant中有支持junit的task.)
- v: q7 j& u- f1 d6. 测试类和测试方法应该有一致的命名方案。如在工作类名前加上test从而形成测试类名。
8 X  l4 }9 y+ c. h. ?+ x7. 确保测试与时间无关,不要依赖使用过期的数据进行测试。导致在随后的维护过程中很难重现测试。
/ ^6 i" B& n( o; P. ]8 r# _8. 如果你编写的软件面向国际市场,编写测试时要考虑国际化的因素。不要仅用母语的Locale进行测试。
; D/ \. o1 f5 U  H3 u9. 尽可能地利用JUnit提供地assert/fail方法以及异常处理的方法,可以使代码更为简洁。
: A" m" a6 N1 P( t10.测试要尽可能地小,执行速度快。 & H% M8 [1 m6 S- y" N0 J* K
: N: [0 R% I: ~$ v$ x
事实上,JUnit还可用于集成测试,但我并没涉及到,原因有两个:一是因为没有单元测试,集成测试无从谈起。我们接受测试地概念已经很不容易了,如果再引入集成测试就会更困难。二是我比较懒,希望将集成测试的任务交给测试人员去做。在JUnit的网站上有一些相关的文章,有空大家可以翻一翻。
: I+ k" I/ b2 k) @1 f: l! n: R" y- W  F& X8 k) C
2 ~/ {) a! D% Q1 E8 C
JUnit与J2EE  1 b, L( D! e  A# W) [

& p' w4 R# E; Q% p0 j* F如果大家仔细考虑一下的话,就会发现,JUnit有自己的局限性,比如对图形界面的测试,对servlet/JSP以及EJB的测试我们都没有举相关的例子。实际上,JUnit对于GUI界面,servlet/JSP,JavaBean以及EJB都有办法测试。关于GUI的测试比较复杂,适合用一整篇文章来介绍。这里就不多说了。 ( w9 b0 o' h8 V' V  r

, L( v' K5 H3 x% h0 i前面我们所做的测试实际上有一个隐含的环境,JVM我们的类需要这个JVM来执行。而在J2EE框架中,servlet/JSP,EJB都要求有自己的运行环境:Web Container和EJB Container。所以,要想对servlet/JSP,EJB进行测试就需要将其部署在相应的Container中才能进行测试。由于EJB不涉及UI的问题(除非EJB操作XML数据,此时的测试代码比较难写,有可能需要你比较两棵DOM树是否含有相同的内容)只要部署上去之后就可以运行测试代码了。此时setUp()方法显得特别有用,你可以在setUp()方法中利用JNDI查找特定的EJB。而在testXXX()方法中调用并测试这些EJB的方法。 # O- n  ?# U0 _5 _$ D' J# e; ^* o. r

8 @: I. n: y/ X  }, G# f: p这里所指的JavaBean同样没有UI的问题,比如,我们用JavaBean来访问数据库,或用JavaBean来包裹EJB。如果这类JavaBean没有用到Container的提供的服务,则可直接进行测试,同我们前面所说的一般的类的测试方法一样。如果这类JavaBean用到了Container的提供的服务,则需要将其部署在Container中才能进行测试。方法与EJB类似。 % ~: k2 c4 F" I( _! {

" q6 a7 p7 q1 O5 F" w- A& v# Q对于servlet/JSP的测试则比较棘手,有人建议在测试代码中构造HttpRequest和HttpResponse,然后进行比较,这就要求开发人员对HTTP协议以及servlet/JSP的内部实现有比较深的认识。我认为这招不太现实。也有人提出使用HttpUnit。由于我对Cactus和HttpUnit 了解不多,所以无法做出合适的建议。希望各位先知们能不吝赐教。
- `, X( i/ l% Z6 W
) l4 d$ g( e& g4 ~; Y3 d正是由于JUnit的开放性和简单易行,才会引出这篇介绍文章。但技术总在不断地更新,而且我对测试并没有非常深入的理解;我可以将一个复杂的概念简化成一句非常容易理解的话。但我的本意只是希望能降低开发人员步入测试领域的门槛,而不是要修改或重新定义一些概念。这一点是特别要强调的。最后,如果有些兄弟姐妹能给我指出一些注意事项或我对某些问题的理解有误,我会非常感激的。3 C& j, ?6 ^: I" {
发表于 2013-7-5 13:52:38 | 显示全部楼层
学习了!!!
回复 支持 反对

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|小黑屋|手机版|无图版|SCMLife.com ( 京ICP备06056490号-1 )

GMT+8, 2018-1-20 11:51 , Processed in 0.080972 second(s), 8 queries , Gzip On, MemCache On.

Powered by SCMLife X3.4 Licensed

© 2001-2017 JoyShare.

快速回复 返回顶部 返回列表