怎样使用Junit Framework进行单元测试的编写

随着Refactoring技术和XP软件工程技术的广泛推广，单元测试的作用在软件工程
中变得越来越重要，而一个简明易学、适用广泛、高效稳定的单元测试框架则对成
功的实施单元测试有着至关重要的作用。在java编程语句环境里，Junit
Framework是一个已经被多数java程序员采用和实证的优秀的测试框架，但是多数
没有尝试Junit Framework的程序员在学习如何Junit Framework来编写适应自己开
发项目的单元测试时，依然觉得有一定的难度，这可能是因为Junit随框架代码和
实用工具附带的用户指南和文档的着重点在于解释单元测试框架的设计方法以及简
单的类使用说明，而对在特定的测试框架（Junit）下如何实施单元测试，如何在
项目开发的过程中更新和维护已经存在的单元测试代码没有详细的解释。因此本文
档就两个着重点对Junit所附带的文档进行进一步的补充和说明，使Junit能被更多
的开发团队采用，让单元测试乃至Refactoring、XP技术更好在更多的开发团队中
推广。

1. 单元测试的编写原则

Junit附带文档所列举的单元测试带有一定的迷惑性，因为几乎所有的示例单元都
是针对某个对象的某个方法，似乎Junit的单元测试仅适用于类组织结构的静态约
束，从而使初学者怀疑Junit下的单元测试所能带来的效果。因此我们需要重新定
义如何确定有价值的单元测试以及如何编写这些单元测试、维护这些单元测试，从
而让更多的程序员接受和熟悉Junit下的单元测试的编写。

在Junit单元测试框架的设计时，作者一共设定了三个总体目标，第一个是简化测
试的编写，这种简化包括测试框架的学习和实际测试单元的编写；第二个是使测试
单元保持持久性；第三个则是可以利用既有的测试来编写相关的测试。从这三个目
标可以看出，单元测试框架的基本设计考虑依然是从我们现有的测试方式和方法出
发，而只是使测试变得更加容易实施和扩展并保持持久性。因此编写单元测试的原
则可以从我们通常使用的测试方法借鉴和利用。

2. 如何确定单元测试

在我们通常的测试中，一个单元测试一般针对于特定对象的一个特定特性，譬如，
假定我们编写了一个针对特定数据库访问的连接池的类包实现，我们会建立以下的
单元测试：

在连接池启动后，是否根据定义的规则在池中建立了相应数量的数据库连接
申请一个数据库连接，是否根据定义的规则从池中直接获得缓存连接的引用，还是
建立新的连接
释放一个数据库连接后，连接是否根据定义的规则被池释放或者缓存以便以后使用

后台Housekeeping线程是否按照定义的规则释放已经过期的连接申请
如果连接有时间期限，后台Housekeeping线程是否定期释放已经过期的缓存连接
这儿只列出了部分的可能测试，但是从这个列表我们可以看出单元测试的粒度。一
个单元测试基本是以一个对象的明确特性为基础，单元测试的过程应该限定在一个
明确的线程范围内。根据上面所述，一个单元测试的测试过程非常类似于一个
Use Case的定义，但是单元测试的粒度一般来说比Use Case的定义要小，这点是容
易理解的，因为Use Case是以单独的事务单元为基础的，而单元测试是以一组聚合
性很强的对象的特定特征为基础的，一般而言一个事务中会利用许多的系统特征来
完成具体的软件需求。

从上面的分析我们可以得出，测试单元应该以一个对象的内部状态的转换为基本编
写单元。一个软件系统就和一辆设计好的汽车一样，系统的状态是由同一时刻时系
统内部的各个分立的部件的状态决定的，因此为了确定一个系统最终的行为符合我
们起始的要求，我们首先需要保证系统内的各个部分的状态会符合我们的设计要求
，所以我们的测试单元的重点应该放在确定对象的状态变换上。

然而需要注意的并不是所有的对象组特征都需要被编写成独立的测试单元，如何在

对象组特征里筛选有价值的测试单元的原则在JUnitTest Infected:
Programmers Love Writing Tests一文中得到了正确的描述，你应该在有可能引入
错误的地方引入测试单元，通常这些地方存在于有特定边界条件、复杂算法以及需
求变动比较频繁的代码逻辑中。除了这些特性需要被编写成独立的测试单元外，还
有一些边界条件比较复杂的对象方法也应该被编写成独立的测试单元，这部分单元
测试已经在Junit文档中被较好的描述和解释过了。

在基本确定了需要编写的单元测试，我们还应该问自己：编写好了这些测试，我们
是否可以有把握地告诉自己，如果代码通过了这些单元测试，我们能认定程序的运
行是正确的，符合需求的。如果我们不能非常的确定，就应该看看是否还有遗漏的
需要编写的单元测试或者重新审视我们对软件需求的理解。通常来说，在开始使用
单元测试的时候，更多的单元测试总是没有错的。

一旦我们确定了需要被编写的测试单元，接下来就应该

3. 如何编写单元测试

在XP下强调单元测试必须由类包的编写者负责编写，这个限定对于我们设定的测试
目标是必须的。因为只有这样，测试才能保证对象的运行时态行为符合需求，而仅
通过类接口的测试，我们只能确保对象符合静态约束，因此这就要求我们在测试的
过程中，必须开放一定的内部数据结构，或者针对特定的运行行为建立适当的数据
记录，并把这些数据暴露给特定的测试单元。这也就是说我们在编写单元测试时必

须对相应的类包进行修改，这样的修改也发生在我们以前使用的测试方法中，因此
以前的测试标记及其他一些测试技巧仍然可以在Junit测试中改进使用。

由于单元测试的总体目标是负责我们的软件在运行过程中的正确无误，因此在我们
对一个对象编写单元测试的时候，我们不但需要保证类的静态约束符合我们的设计
意图，而且需要保证对象在特定的条件下的运行状态符合我们的预先设定。还是拿
数据库缓冲池的例子说明，一个缓冲池暴露给其他对象的是一组使用接口，其中包
括对池的参数设定、池的初始化、池的销毁、从这个池里获得一个数据连接以及释
放连接到池中，对其他对象而言随着各种条件的触发而引起池的内部状态的变化是
不需要知道的，这一点也是符合封装原理的。但是池对象的状态变化，譬如：缓存
的连接
4000
数在某些条件下会增长，一个连接在足够长的运行后需要被彻底释放从而使
池的连接被更新等等，虽然外部对象不需要明确，但是却是程序运行正确的保证，
所以我们的单元测试必须保证这些内部逻辑被正确的运行。

编译语言的测试和调试是很难对运行的逻辑过程进行跟踪的，但是我们知道，无论
逻辑怎么运行，如果状态的转换符合我们的行为设定，那验证结果显然是正确的，
因此在对一个对象进行单元测试的时候，我们需要对多数的状态转换进行分析和对
照，从而验证对象的行为。状态是通过一系列的状态数据来描述的，因此编写单元
测试首先分析出状态的变化过程（状态转换图对这个过程的描述非常清晰），然后
根据状态的定义确定分析的状态数据，最后是提供这些内部的状态数据的访问。在
数据库连接池的例子中，我们对池实现的对象DefaultConnectionProxy的状态变换
进行分析后，我们决定把表征状态的OracleConnectionCacheImpl对象公开给测试

类。参见示例一

示例一
/**
* 这个类简单的包装了oracle对数据连接缓冲池的实现。
*
*/
public class DefaultConnectionProxy extends ConnectionProxy {

private static final String name = "Default Connection Proxy";
private static final String description = "这个类简单的包装了oracle对数
据连接缓冲池的实现。";
private static final String author = "Ion-Global.com";
private static final int major_version = 0;
private static final int minor_version = 9;
private static final boolean pooled = true;

private ConnectionBroker connectionBroker = null;
private Properties props;
private Properties propDescriptions;

private Object initLock = new Object();

// Test Code Begin...
/* 为了能够了解对象的状态变化，因此需要把表征对象内部状态变化的部分私有
变量提供公共的访问接口
（或者提供让同一个类包的访问接口），以便使测试单元可以有效地判断对象
的状态转变，
在本示例中对包装的OracleConnectionCacheImpl对象提供访问接口。
*/
OracleConnectionCacheImpl getConnectionCache() {
if (connectionBroker == null) {
throw new IllegalStateException("You need start the s
erver first.");
}

return connectionBroker.getConnectionCache();
}

// Test Code End...

在公开内部状态数据後，我们就可以编写我们的测试单元了，单元测试的选择方法
和选择尺度已经在本文前面章节进行了说明，

但是仍然需要注意的是，由于assert方法会抛出一个error，你应该在测试方法的
最后集中用assert相关方法进行判断，
这样可以确保资源得到释放。

对数据库连接池的例子，我们可以建立测试类DefaultConnectionProxyTest，同时
建立数个test case，如下

示例二
/**
* 这个类对示例一中的类进行简单的测试。
*
*/
public class DefaultConnectionProxyTest extends TestCase {
private DefaultConnectionProxy conProxy = null;
private OracleConnectionCacheImpl cacheImpl = null;
private Connection con = null;

/** 设置测试的fixture，建立必要的测试起始环境。
*/
protected void setUp() {
conProxy = new DefaultConnectionProxy();
conProxy.start();

cacheImpl = conProxy.getConnectionCache();
}

/** 对示例一中的对象进行服务启动后的状态测试，检查是否在服务启动后，
连接池的参数设置是否正确。
*/
public void testConnectionProxyStart() {
int minConnections = 0;
int maxConnections = 0;

assertNotNull(cacheImpl);

try {
minConnections = Integer.parseInt(PropertyManager.get
Property
("DefaultConnectionProxy.minConnections"));
maxConnections = Integer.parseInt(PropertyManager.get
Property
("DefaultConnectionProxy.maxConnections"));
} catch (Exception e) {
// ignore the exception
}

assertEquals(cacheImpl.getMinLimit(), minConnections);
assertEquals(cacheImpl.getMaxLimit(), maxConnections);
assertEquals(cacheImpl.getCacheSize(), minConnections);
}

/** 对示例一中的对象进行获取数据库连接的测试，看看是否可以获取有效的数
据库连接，
并且看看获取连接后，连接池的状态是否按照既定的策略进行变化。由于assert方
法抛出的是
error对象，因此尽可能把assert方法放置到方法的最后集体进行测试，这样在方
法内打开的
资源，才能有效的被正确关闭。
*/
public void testGetConnection() {
int cacheSize = cacheImpl.getCacheSize();
int activeSize = cacheImpl.getActiveSize();
int cacheSizeAfter = 0;
int activeSizeAfter = 0;

con = conProxy.getConnection();

if (con != null) {
activeSizeAfter = cacheImpl.getActiveSize();
cacheSizeAfter = cacheImpl.getCacheSize();

try {
con.close();
} catch (SQLException e) {
}
} else {
assertNotNull(con);
}

/*如果连接池中的实际使用连接数小于缓存连接数，检查获取的新的数
据连接是
否
从缓存中获取，反之连接池是否建立新的连接
*/
if (cacheSize > activeSize) {
assertEquals(activeSize + 1, activeSizeAfter);
assertEquals(cacheSize, cacheSizeAfter);
} else {
assertEquals(activeSize + 1, cacheSizeAfter);

}
}

/** 对示例一中的对象进行数据库连接释放的测试，看看连接释放后，连接池的
状态是否按照既定的策略进行变化。由于assert方法抛出的是error对象，因此尽
可
能把assert方法放置到方法的最后集体进行测试，这样在方法内打开的
资源，才能有效的被正确关闭。
*/
public void testConnectionClose() {
int minConnections = cacheImpl.getMinLimit();
int cacheSize = 0;
int activeSize = 0;
int cacheSizeAfter = 0;
int activeSizeAfter = 0;

con = conProxy.getConnection();

if (con != null) {
cacheSize = cacheImpl.getCacheSize();
activeSize = cacheImpl.getActiveSize();

try {
con.close();
} catch (SQLException e) {
}

activeSizeAfter = cacheImpl.getActiveSize();
cacheSizeAfter = cacheImpl.getCacheSize();
} else {
assertNotNull(con);
}

assertEquals(activeSize, activeSizeAfter + 1);

/*如果连接池中的缓存连接数大于最少缓存连接数，检查释放数据连接
后是否
缓存连接数比之前减少了一个，反之缓存连接数是否保持为最少缓存连接数
*/
if (cacheSize > minConnections) {
assertEquals(cacheSize, cacheSizeAfter + 1);
} else {
assertEquals(cacheSize, minConnections);
}

}

/** 释放建立测试起始环境时的资源。
*/
protected void tearDown() {
cacheImpl = null;
conProxy.destroy();
}

public DefaultConnectionProxyTest(String name) {
super(name);
}

/** 你可以简单的运行这个类从而对类中所包含的测试单元进行测试。
*/
public static void main(String args[]) {
junit.textui.TestRunner.run(DefaultConnectionProxyTest.class);
}
}

当单元测试完成后，我们可以用Junit提供的TestSuite对象对测试单元进行组织，
你可以决定测试的顺序，然后运行你的测试。

4. 如何维护单元测试

通过上面的描述，我们对如何确定和编写测试有了基本的了解，但是需求总是变化
的，因此我们的单元测试也会根据需求的变化不断的演变。如果我们决定修改类的
行为规则，可以明确的是，我们当然会对针对这个类的测试单元进行修改，以适应
变化。但是如果对这个类仅有调用关系的类的行为定义没有变化则相应的单元测试
仍然是可靠和充分的，同时如果包含行为变化的类的对象的状态定义与其没有直接
的关系，测试单元仍然起效。这种结果也是封装原则的优势体现。

关于作者

申文波： 1973年出生，现于艾昂科技上海公司任资深技术顾问。在关系数据库对
象建模方面有较长的工作经验，熟悉Java语言，目前从事的工作领域主要包括OOA
、OOD和企业应用。您可以通过邮件alair_china@yahoo.com.cn与他联系。