当前页面: 开发资料首页 → Java 专题 → JUnit实战篇 (二)

JUnit实战篇 (二)

摘要: JUnit实战篇 (二)

三、安装
1. 获取JUnit的软件包，从Junit(http://www.junit.org/index.htm或
http://download.sourceforge.net/junit/)下载最新的软件包。这里我使用的是
http://download.sourceforge.net/junit/junit2.zip。
2. 将其在适当的目录下解包（我安装在D:\junit2）。这样在安装目录（也就
是你所选择的解包的目录）下你找到一个名为junit.jar的文件。将这个jar文件加
入你的CLASSPATH系统变量。（IDE的设置会有所不同，参看你所喜爱的IDE的配置指
南）JUnit就安装完了。
四、运行
通过前面的介绍，我们对JUnit有了一个大概的轮廓。知道了它是干什么的。现
在让我们动手改写上面的测试类testCar使其符合Junit的规范－－能在JUnit中运行。
//执行测试的类（JUnit版）
import junit.framework.*;
public class testCar extends TestCase {
protected int expectedWheels;
protected Car myCar;
public testCar(String name) {
super(name); }
protected void setUp() {
expectedWheels = 4;
myCar = new Car(); }
public static Test suite() {
/** the type safe way */ /*
TestSuite suite= new TestSuite();
suite.addTest(
new testCar("Car.getWheels") {
protected void runTest() {
testGetWheels(); } } );
return suite; */
/** the dynamic way */
return new TestSuite(testCar.class); }
public void testGetWheels() {
assertEquals(expectedWheels, myCar.getWheels()); } }
改版后的testCar已经面目全非。先让我们了解这些改动都是什么含义，再看如何执行这个测试。
1>import语句，引入JUnit的类。（没问题吧）
2>继承 TestCase 。可以暂时将一个TestCase看作是对某个类进行测试的方法的集
合。详细介绍请参看JUnit资料
3>setUp()设定了进行初始化的任务。我们以后会看到setUp会有特别的用处。
4>testGetWheeels()对预期的值和myCar.getWheels()返回的值进行比较，并打印比
较的结果。assertEquals是junit.framework.Assert中所定义的方法，
junit.framework.TestCase继承了junit.framework.Assert。
5>suite()是一个很特殊的静态方法。JUnit的TestRunner会调用suite方法来确定有
多少个测试可以执行。上面的例子显示了两种方法：静态的方法是构造一个内部类
，并利用构造函数给该测试命名(test name, 如 Car.getWheels)，其覆盖的
runTest()方法，指明了该测试需要执行那些方法－－testGetWheels()。动态的方
法是利用内省（reflection）来实现runTest()，找出需要执行那些测试。此时测试
的名字即是测试方法（test method，如testGetWheels）的名字。JUnit会自动找出
并调用该类的测试方法。
6>将TestSuite看作是包裹测试的一个容器。如果将测试比作叶子节点的话，
TestSuite就是分支节点。实际上TestCase，TestSuite以及TestSuite组成了一个
composite Pattern。JUnit的文档中有一篇专门讲解如何使用Pattern构造Junit框
架。有兴趣的朋友可以查看JUnit资料。
如何运行该测试呢？手工的方法是键入如下命令：
[Windows] D:\>java junit.textui.TestRunner testCar
[Unix] ％ java junit.textui.TestRunner testCar
别担心你要敲的字符量，以后在IDE中，只要点几下鼠标就成了。运行结果应该如下
所示，表明执行了一个测试，并通过了测试： . Time: 0
OK (1 tests)
如果我们将Car.getWheels()中返回的的值修改为3，模拟出错的情形，则会得到如下结果： .F
Time: 0.16
FAILURES!!!
Test Results:
Run: 1 Failures: 1 Errors: 0
There was 1 failure:
1) testCar.testGetWheels "expected:<3> but was:<4>"
注意：Time上的小点表示测试个数，如果测试通过则显示OK。否则在小点的后边标
上F，表示该测试失败。注意，在模拟出错的测试中，我们会得到详细的测试报告“
expected:<3> but was:<4>”，这足以告诉我们问题发生在何处。下面就是你调试
，测试，调试，测试...的过程，直至得到期望的结果。
五、Design by Contract（这句话我没法翻译）
Design 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的细节，而是希望其在测试中能发挥其作用。
前置条件在执行测试之前可以用于判断是否允许进入测试，即进入测试的条件
。如 expectedWheels > 0, myCar != null。后置条件用于在测试执行后判断测试
的结果是否正确。如 expectedWheels==myCar.getWheels()。而不变式在判断交易
(Transaction)的一致性（consistency）方面尤为有用。我希望JUnit可以将Design
by Contract作为未来版本的一个增强。
六、Refactoring（这句话我依然没法翻译）
Refactoring本来与测试没有直接的联系，而是与软件熵有关，但既然我们说
测试能解决软件熵问题，我们也就必须说出解决之道。（仅仅进行测试只能发现软
件熵，Refactoring则可解决软件熵带来的问题。）软件熵引出了一个问题：是否需
要重新设计整个软件的结构？理论上应该如此，但现实不允许我们这么做。这或者
是由于时间的原因，或者是由于费用的原因。重新设计整个软件的结构会给我们带
来短期的痛苦。而不停地给软件打补丁甚至是补丁的补丁则会给我们带来长期的痛
苦。（不管怎样，我们总处于水深火热之中）
Refactoring是一个术语，用于描述一种技术，利用这种技术我们可以免于重
构整个软件所带来的短期痛苦。当你refactor时，你并不改变程序的功能，而是改
变程序内部的结构，使其更易理解和使用。如：该变一个方法的名字，将一个成员
变量从一个类移到另一个类，将两个类似方法抽象到父类中。所作的每一个步都很
小，然而1－2个小时的Refactoring工作可以使你的程序结构更适合目前的情况。
Refactoring有一些规则：
1> 不要在加入新功能的同时refactor已有的代码。在这两者间要有一个清晰的界限
。如每天早上1-2个小时的Refactoring，其余时间添加新的功能；
2> 在你开始Refactoring前，和Refactoring后都要保证测试能顺利通过，否则
Refactoring没有任何意义；
3> 进行小的Refactoring，大的就不是Refactoring了。如果你打算重构整个软件，
就没有必要Refactoring了。只有在添加新功能和调试bug时才又必要Refactoring。
不要等到交付软件的最后关头才Refactoring。那样和打补丁的区别不大。
Refactoring 用在回归测试中也能显示其威力。要明白，我不反对打补丁，但要记
住打补丁是应该最后使用的必杀绝招。（打补丁也需要很高的技术，详情参看微软网站）
七、IDE对JUnit的支持
目前支持JUnit的Java IDE 包括 IDE 方式
分数（1－5，满分5）
Forte for Java 3.0 Enterprise Edition plug-in 3
Jbuilder 9 Enterprise Edition
integrated with IDE 4
Visual Age for Java support N/A
在IDE中如何使用JUnit,是非常具体的事情。不同的IDE有不同的使用方法。一
旦理解了JUnit的本质，使用起来就十分容易了。所以我们不依赖于具体的IDE，而
是集中精力讲述如何利用JUnit编写单元测试代码。心急的人可参看资料。
八、小结
你一旦安装完JUnit，就有可能想试试我们的Car和testCar类，没问题，我已
经运行过了,你得到的结果应该和我列出的结果类似。接下来，你可能会先写测试代
码，再写工作代码，或者相反，先写工作代码，再写测试代码。我更赞成使用前一
种方法：先写测试代码，再写工作代码。因为这样可以使我们编写工作代码时清晰
地了解工作类的行为。
要注意编写一定能通过的测试代码（如文中的例子）并没有任何意义，只有测
试代码能帮助我们发现bug，测试代码才有其价值。此外测试代码还应该对工作代码
进行全面的测试。如给方法调用的参数传入空值、错误值和正确的值，看看方法的
行为是否如你所期望的那样。
你现在已经知道了编写测试类的基本步骤：
1> 扩展TestCase类；
2> 覆盖runTest()方法（可选）；
3> 写一些testXXXXX()方法。
Fixture
接下来的问题是，如果你要对一个或若干个的类执行多个测试，该怎么办？
JUnit对此有特殊的解决办法。如果需要在一个或若干个的类执行多个测试，这些类
就成为了测试的context。在JUnit中被称为Fixture（如testCar类中的 myCar 和
expectedWheels ）。当你编写测试代码时，你会发现你花费了很多时间配置/初始
化相关测试的Fixture。将配置Fixture的代码放入测试类的构造方法中并不可取，
因为我们要求执行多个测试，我并不希望某个测试的结果意外地（如果这是你要求
的，那就另当别论了）影响其他测试的结果。通常若干个测试会使用相同的Fixture
，而每个测试又各有自己需要改变的地方。为此，JUnit提供了两个方法，定义在
TestCase类中。
protected void setUp() throws java.lang.Exception
protected void tearDown() throws java.lang.Exception
覆盖setUp()方法，初始化所有测试的Fixture（你甚至可以在setUp中建立网
络连接），将每个测试略有不同的地方在testXXX()方法中进行配置。覆盖
tearDown()（我总想起一首叫雨滴的吉他曲），释放你在setUp()中分配的永久性资
源，如数据库连接。当JUnit执行测试时，它在执行每个testXXXXX()方法前都调用
setUp()，而在执行每个testXXXXX()方法后都调用tearDown()方法，由此保证了测
试不会相互影响。
TestCase
需要提醒一下，在junit.framework.Assert类中定义了相当多的assert方法，
主要有assert(),assertEquals(), assertNull(), assertSame(), assertTrue(),
fail()等方法。如果你需要比较自己定义的类，如Car。assert方法需要你覆盖
Object类的equals()方法，以比较两个对象的不同。实践表明:如果你覆盖了Object
类的equals()方法，最好也覆盖Object类的hashCode()方法。再进一步，连带
Object类的toString()方法也一并覆盖。这样可以使测试结果更具可读性。
当你设置好了Fixture后，下一步是编写所需的testXXX()方法。一定要保证
testXXX()方法的public属性，否则无法通过内省（reflection）对该测试进行调用
。每个扩展的TestCase类（也就是你编写的测试类）会有多个testXXX()方法。一个
testXXX()方法就是一个测试。要想运行这个测试，你必须定义如何运行该测试。如
果你有多个testXXX()方法，你就要定义多次。JUnit支持两种运行单个测试的方法
：静态的和动态的方法。
静态的方法就是覆盖TestCase类的runTest()方法，一般是采用内部类的方式
创建一个测试实例：
TestCase test01 = new testCar("test getWheels") {
public void runTest() {
testGetWheels(); } }
采用静态的方法要注意要给每个测试一个名字（这个名字可以任意起，但你肯
定希望这个名字有某种意义），这样你就可以区分那个测试失败了。
动态的方法是用内省（Introspection，检查标准管理构件接口和应用设计模
式的过程）来实现runTest()以创建一个测试实例。这要求测试的名字就是需要调用
的测试方法的名字：
TestCase test01 = new testCar("testGetWheels");
JUnit会动态查找并调用指定的测试方法。动态的方法很简洁，但如果你键入
了错误的名字就会得到一个令人奇怪的NoSuchMethodException异常。动态的方法和
静态的方法都很好，你可以按照自己的喜好来选择。（先别着急选择，后面还有一
种更酷的方法等着你呢。）
TestSuite
一旦你创建了一些测试实例，下一步就是要让他们能一起运行。我们必须定义一个
TestSuite。在JUnit中，这就要求你在TestCase类中定义一个静态的suite()方法。
suite()方法就像main()方法一样，JUnit用它来执行测试。在suite()方法中，你将
测试实例加到一个TestSuite对象中，并返回这个TestSuite对象。一个TestSuite对
象可以运行一组测试。TestSuite和TestCase都实现了Test接口（interface），而
Test接口定义了运行测试所需的方法。这就允许你用TestCase和TestSuite的组合创
建一个TestSuite。这就是为什么我们前面说TestCase，TestSuite以及TestSuite组
成了一个composite Pattern的原因。例子如下：
public static Test suite() {
TestSuite suite= new TestSuite();
suite.addTest(new testCar("testGetWheels"));
suite.addTest(new testCar("testGetSeats"));
return suite; }
从JUnit 2.0开始，有一种更简单的动态定义测试实例的方法。你只需将类传
递给TestSuite，JUnit会根据测试方法名自动创建相应的测试实例。所以你的测试
方法最好取名为testXXX()。例子如下：
public static Test suite() {
return new TestSuite(testCar.class); }
从JUnit的设计我们可看出，JUnit不仅可用于单元测试，也可用于集成测试。
关于如何用JUnit进行集成测试请参考相关资料。
为了兼容性的考虑，下面列出使用静态方法的例子：
public static Test suite() {
TestSuite suite= new TestSuite();
suite.addTest(
new testCar("Car.getWheels") {
protected void runTest() {
testGetWheels(); } } );
return suite; }
TestRunner
有了TestSuite我们就可以运行这些测试了，JUnit提供了三种界面来运行测试
[Text UI] junit.textui.TestRunner
[AWT UI] junit.awtui.TestRunner
[Swing UI] junit.swingui.TestRunner
我们前面已经看过文本界面了，下面让我们来看一看图形界面：
界面很简单，键入类名－testCar。或在启动UI的时候键入类名：
[Windows] D:\>java junit.swingui.TestRunner testCar
[Unix] ％ java junit.swingui.TestRunner testCar
从图形UI可以更好的运行测试可查单测试结果。还有一个问题需要注意：如果
JUnit报告了测试没有成功，JUnit会区分失败（failures）和错误（errors）。失
败是一个期望的被assert方法检查到的结果。而错误则是意外的问题引起的，如
ArrayIndexOutOfBoundsException。
由于TestRunner十分简单，界面也比较直观，故不多介绍。朋友们可自行参考相关资料。
JUnit最佳实践
Martin Fowler（又是这位高人）说过：“当你试图打印输出一些信息或调试
一个表达式时，写一些测试代码来替代那些传统的方法。”一开始，你会发现你总
是要创建一些新的Fixture，而且测试似乎使你的编程速度慢了下来。然而不久之后
，你会发现你重复使用相同的Fixture，而且新的测试通常只涉及添加一个新的测试方法。
你可能会写许多测试代码，但你很快就会发现你设想出的测试只有一小部分是
真正有用的。你所需要的测试是那些会失败的测试，即那些你认为不会失败的测试
，或你认为应该失败却成功的测试。
我们前面提到过测试是一个不会中断的过程。一旦你有了一个测试，你就要一
直确保其正常工作，以检验你所加入的新的工作代码。不要每隔几天或最后才运行
测试，每天你都应该运行一下测试代码。这种投资很小，但可以确保你得到可以信
赖的工作代码。你的返工率降低了，你会有更多的时间编写工作代码。
不要认为压力大，就不写测试代码。相反编写测试代码会使你的压力逐渐减轻
，应为通过编写测试代码，你对类的行为有了确切的认识。你会更快地编写出有效
率地工作代码。下面是一些具体的编写测试代码的技巧或较好的实践方法：
1. 不要用TestCase的构造函数初始化Fixture，而要用setUp()和tearDown()方法；
2. 不要依赖或假定测试运行的顺序，因为JUnit利用Vector保存测试方法。所以不
同的平台会按不同的顺序从Vector中取出测试方法；
3. 避免编写有副作用的TestCase。例如：如果随后的测试依赖于某些特定的交易数
据，就不要提交交易数据。简单的回滚就可以了；
4. 当继承一个测试类时，记得调用父类的setUp()和tearDown()方法；
5. 将测试代码和工作代码放在一起，一边同步编译和更新（使用Ant中有支持junit
的task）；
6. 测试类和测试方法应该有一致的命名方案。如在工作类名前加上test从而形成测试类名；
7. 确保测试与时间无关，不要依赖使用过期的数据进行测试。导致在随后的维护过
程中很难重现测试；
8. 如果你编写的软件面向国际市场，编写测试时要考虑国际化的因素。不要仅用母
语的Locale进行测试；
9. 尽可能地利用JUnit提供地assert/fail方法以及异常处理的方法，可以使代码更为简洁；
10.测试要尽可能地小，执行速度快。
事实上，JUnit还可用于集成测试，但我并没涉及到，原因有两个：一是因为
没有单元测试，集成测试无从谈起。我们接受测试地概念已经很不容易了，如果再
引入集成测试就会更困难。二是我比较懒，希望将集成测试的任务交给测试人员去
做。在JUnit的网站上有一些相关的文章，有空大家可以翻一翻。
JUnit与J2EE
如果大家仔细考虑一下的话，就会发现，JUnit有自己的局限性，比如对图形界
面的测试，对servlet/JSP以及EJB的测试我们都没有举相关的例子。实际上，JUnit
对于GUI界面，servlet/JSP，JavaBean以及EJB都有办法测试。关于GUI的测试比较
复杂，适合用一整篇文章来介绍。这里就不多说了。
前面我们所做的测试实际上有一个隐含的环境，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的方法。
这里所指的JavaBean同样没有UI的问题，比如，我们用JavaBean来访问数据库
，或用JavaBean来包裹EJB。如果这类JavaBean没有用到Container的提供的服务，
则可直接进行测试，同我们前面所说的一般的类的测试方法一样。如果这类
JavaBean用到了Container的提供的服务，则需要将其部署在Container中才能进行
测试。方法与EJB类似。对于servlet/JSP的测试则比较棘手，有人建议在测试代码
中构造HttpRequest和HttpResponse，然后进行比较，这就要求开发人员对HTTP协议
以及servlet/JSP的内部实现有比较深的认识。我认为这招不太现实。也有人提出使
用HttpUnit。由于我对Cactus和HttpUnit了解不多，所以无法做出合适的建议。希
望各位先知们能不吝赐教。
正是由于JUnit的开放性和简单易行，才会引出这篇介绍文章。但技术总在不断
地更新，而且我对测试并没有非常深入的理解；我可以将一个复杂的概念简化成一
句非常容易理解的话。但我的本意只是希望能降低开发人员步入测试领域的门槛，
而不是要修改或重新定义一些概念。这一点是特别要强调的。最后，如果有些兄弟
姐妹能给我指出一些注意事项或我对某些问题的理解有误，我会非常感激的。
参考
JUnit实施
作者：eric 原址：http://www.neweasier.com/article/2002-08-
07/1028723459.html
怎样使用Junit Framework进行单元测试的编写
作者：cinc 原址：http://www.chinaunix.net/bbsjh/14/546.html
主要是引用了cinc的评论，至于申文波先生的《怎样使用Junit Framework进行单元
测试的编写》原文我建议大家有时间看一下，写得很好，我这里没有整合进来。
创建Junit测试案例
作者： BUILDER.COM 原址：
http://www.zdnet.com.cn/developer/code/story/0,2000081534,39033729,00.htm
↑返回目录
前一篇: JUnit实战篇 (一)
后一篇: JSP中写数据库前的一个过滤方法.