Junit单元测试覆盖率分析-技术开发专区

Junit单元测试覆盖率分析

作者：ITPUB BLOG 编辑：晓熊 2009-09-14 10:41 来源：IT168�

　　【IT168 评论】本人最近在研究java单元测试技术，有点心得，这里分享给测试同行朋友!那么，今天我们研究的主题是使用cenqua公司的clover框架来分析java程序的单元测试覆盖率!关于clover的更多信息呢，请大家去http://www.cenqua.com/clover去查询。我们这里，将会通过一个实例来演示如何使用junit和clover一起，来分析java代码的覆盖率。我们将会使用ant来编译一个junit单元测试实例项目，然后修改build.xml文件，加上clover的覆盖率分析任务target;而且我们还要通过三部分来学习clover超级无敌的地方：current报告、历史报告以及高级特征!

　　那么最开始呢，我们要做的就是从http://www.cenqua.com/clover下载clover程序包clover.jar(它是clover的主要包)、clover.license(clover的试用license，需要到官方网站下载一个月的试用注册文件，否则不能使用clover!)、velocity.jar(用来创建html报告的扩展包)，将它们拷贝到ant(ant你已经安装好了，并且设置了junit.jar以及ANT_HOME之类的初始化工作;我们这里不讲ant的基本使用，它都流行这么多年了，这里假设你都懂啦!)的lib目录下，这样下来，我们在ant的build.xml文件里才可以使用clover任务!

　　当然，现在很多朋友不喜欢配置一些环境变量，想把这些jar文件放在任意的地方，例如直接放在项目文件里，那么可以通过在build.xml文件里指定这些扩展包的位置也是可以的;如果在build文件里加入扩展包的路径，需要在build文件里这样写：

　　1) 我们把下载来的clover.jar和cenquatasks.jar拷贝到你的项目目录的lib路径下

　　2) 在build.xml下添加如下代码：　

之后你就可以在ant任务里构建clover的任务啦!

　　其实最简单的办法呢，就是把clover.jar、clover.license、velocity.jar、cenquatasks.jar、junit.jar这些包都拷贝到ant的lib目录里，省得麻烦，不然将来你加入什么新功能，就会提示你找不到相应的包，你还得去网上搜，特不爽!

　　我们的学习过程是：

　　先使用junit创建完java代码的测试代码，之后编译运行，完成junit对java代码的单元测试;

　　之后，我们在ant里构建测试任务，自动完成企业集的单元测试工作

　　然后，我们修改build文件，加入clover任务，来完整对单元测试过程的覆盖率分析工作

　　最后开始重构代码，提高代码的单元测试覆盖率

　　一、构建java源代码与junit单元测试代码

　　先在你的电脑里的某个比较顺眼的盘下建立一个目录，例如叫sincky，这个就是我们的学习项目目录，再在sincky里创建一个src文件夹，用来放置所有的代码;之后在src里新建一个java类的源文件，名字叫做IMoney.java，代码内容如下：

　public interface IMoney {

　　/**

　　* Adds a money to this money.

　　*/

　　public abstract IMoney add(IMoney m);

　　/**

　　* Adds a simple Money to this money. This is a helper method for

　　* implementing double dispatch

　　*/

　　public abstract IMoney addMoney(Money m);

　　/**

　　* Adds a MoneyBag to this money. This is a helper method for

　　* implementing double dispatch

　　*/

　　public abstract IMoney addMoneyBag(MoneyBag s);

　　/**

　　* Tests whether this money is zero

　　*/

　　public abstract boolean isZero();

　　/**

　　* Multiplies a money by the given factor.

　　*/

　　public abstract IMoney multiply(int factor);

　　/**

　　* Negates this money.

　　*/

　　public abstract IMoney negate();

　　/**

　　* Subtracts a money from this money.

　　*/

　　public abstract IMoney subtract(IMoney m);

　　/**

　　* Append this to a MoneyBag m.

　　*/

　　public abstract void appendTo(MoneyBag m);

　　}

　　这里我们定义一个java接口，表示了“金钱”这个神奇东西的一些美妙的抽象方法!早年有首迟志强的歌叫《钞票》：是谁制造的钞票，你在世上逞霸道，有人为你愁眉苦脸啊有人为你哈哈笑;姑娘为你走错了路，小伙子为你受改造!东奔又西跑，点头又哈腰，钞票!人人为你离不了钱哪!你这杀人不见血的刀…形象无比，不扯了，跑题啦!I am back!

　　之后我们实现这个接口，在src文件夹下定义一个叫做Money.java的类：

public class Money implements IMoney {

　　private int fAmount;

　　private String fCurrency;

　　/**

　　* Constructs a money from the given amount and currency.

　　*/

　　public Money(int amount, String currency) {

　　fAmount= amount;

　　fCurrency= currency;

　　}

　　/**

　　* Adds a money to this money. Forwards the request to the addMoney helper.

　　*/

　　public IMoney add(IMoney m) {

　　return m.addMoney(this);

　　}

　　public IMoney addMoney(Money m) {

　　if (m.currency().equals(currency()) )

　　return new Money(amount()+m.amount(), currency());

　　return MoneyBag.create(this, m);

　　}

　　public IMoney addMoneyBag(MoneyBag s) {

　　return s.addMoney(this);

　　}

　　public int amount() {

　　return fAmount;

　　}

　　public String currency() {

　　return fCurrency;

　　}

　　public boolean equals(Object anObject) {

　　if (isZero())

　　if (anObject instanceof IMoney)

　　return ((IMoney)anObject).isZero();

　　if (anObject instanceof Money) {

　　Money aMoney= (Money)anObject;

　　return aMoney.currency().equals(currency())

　　&& amount() == aMoney.amount();

　　}

　　return false;

　　}

　　public int hashCode() {

　　return fCurrency.hashCode()+fAmount;

　　}

　　public boolean isZero() {

　　return amount() == 0;

　　}

　　public IMoney multiply(int factor) {

　　return new Money(amount()*factor, currency());

　　}

　　public IMoney negate() {

　　return new Money(-amount(), currency());

　　}

　　public IMoney subtract(IMoney m) {

　　return add(m.negate());

　　}

　　public String toString() {

　　StringBuffer buffer = new StringBuffer();

　　buffer.append("["+amount()+" "+currency()+"]");

　　return buffer.toString();

　　}

　　public /*this makes no sense*/ void appendTo(MoneyBag m) {

　　m.appendMoney(this);

　　}

　　}

　　这个接口实现了IMoney接口的方法，具体语法就不讲了，很简单!之后，我们又用另一个类实现IMoney接口，为什么呢?你可以认为我贪心，但你不可以这么说，因为喜欢编程的人绝对不是为了贪婪代码!我们在src下建立另一个类MoneyBag.java：

import java.util.*;

　　class MoneyBag implements IMoney {

　　private Vector fMonies= new Vector(5);

　　static IMoney create(IMoney m1, IMoney m2) {

　　MoneyBag result= new MoneyBag();

　　m1.appendTo(result);

　　m2.appendTo(result);

　　return result.simplify();

　　}

　　public IMoney add(IMoney m) {

　　return m.addMoneyBag(this);

　　}

　　public IMoney addMoney(Money m) {

　　return MoneyBag.create(m, this);

　　}

　　public IMoney addMoneyBag(MoneyBag s) {

　　return MoneyBag.create(s, this);

　　}

　　void appendBag(MoneyBag aBag) {

　　for (Enumeration e= aBag.fMonies.elements(); e.hasMoreElements(); )

　　appendMoney((Money)e.nextElement());

　　}

　　void appendMoney(Money aMoney) {

　　if (aMoney.isZero()) return;

　　IMoney old= findMoney(aMoney.currency());

　　if (old == null) {

　　fMonies.addElement(aMoney);

　　return;

　　}

　　fMonies.removeElement(old);

　　IMoney sum= old.add(aMoney);

　　if (sum.isZero())

　　return;

　　fMonies.addElement(sum);

　　}

　　public boolean equals(Object anObject) {

　　if (isZero())

　　if (anObject instanceof IMoney)

　　return ((IMoney)anObject).isZero();

　　if (anObject instanceof MoneyBag) {

　　MoneyBag aMoneyBag= (MoneyBag)anObject;

　　if (aMoneyBag.fMonies.size() != fMonies.size())

　　return false;

　　for (Enumeration e= fMonies.elements(); e.hasMoreElements(); ) {

　　Money m= (Money) e.nextElement();

　　if (!aMoneyBag.contains(m))

　　return false;

　　}

　　return true;

　　}

　　return false;

　　}

　　private Money findMoney(String currency) {

　　for (Enumeration e= fMonies.elements(); e.hasMoreElements(); ) {

　　Money m= (Money) e.nextElement();

　　if (m.currency().equals(currency))

　　return m;

　　}

　　return null;

　　}

　　private boolean contains(Money m) {

　　Money found= findMoney(m.currency());

　　if (found == null) return false;

　　return found.amount() == m.amount();

　　}

　　public int hashCode() {

　　int hash= 0;

　　for (Enumeration e= fMonies.elements(); e.hasMoreElements(); ) {

　　Object m= e.nextElement();

　　hash^= m.hashCode();

　　}

　　return hash;

　　}

　　public boolean isZero() {

　　return fMonies.size() == 0;

　　}

　　public IMoney multiply(int factor) {

　　MoneyBag result= new MoneyBag();

　　if (factor != 0) {

　　for (Enumeration e= fMonies.elements(); e.hasMoreElements(); ) {

　　Money m= (Money) e.nextElement();

　　result.appendMoney((Money)m.multiply(factor));

　　}

　　}

　　return result;

　　}

　　public IMoney negate() {

　　MoneyBag result= new MoneyBag();

　　for (Enumeration e= fMonies.elements(); e.hasMoreElements(); ) {

　　Money m= (Money) e.nextElement();

　　result.appendMoney((Money)m.negate());

　　}

　　return result;

　　}

　　private IMoney simplify() {

　　if (fMonies.size() == 1)

　　return (IMoney)fMonies.elements().nextElement();

　　return this;

　　}

　　public IMoney subtract(IMoney m) {

　　return add(m.negate());

　　}

　　public String toString() {

　　StringBuffer buffer = new StringBuffer();

　　buffer.append("{");

　　for (Enumeration e= fMonies.elements(); e.hasMoreElements(); )

　　buffer.append(e.nextElement());

　　buffer.append("}");

　　return buffer.toString();

　　}

　　public void appendTo(MoneyBag m) {

　　m.appendBag(this);

　　}

　　}

　　之后，我们创建一个junit测试代码MoneyTest.java，来测试Money.java和MoneyBag.java类，这里我也把它放在src目录下;如果企业应用，你就要把目录分析的详细些，例如src子目录下放所有的java源代码，test子目录下放所有的junit测试代码：

　import junit.framework.*;

　　public class MoneyTest extends TestCase {

　　private Money f12CHF;

　　private Money f14CHF;

　　private Money f7USD;

　　private Money f21USD;

　　private IMoney fMB1;

　　private IMoney fMB2;

　　public static void main(String args[]) {

　　junit.textui.TestRunner.run(MoneyTest.class);

　　}

　　protected void setUp() {

　　f12CHF= new Money(12, "CHF");

　　f14CHF= new Money(14, "CHF");

　　f7USD= new Money( 7, "USD");

　　f21USD= new Money(21, "USD");

　　fMB1= MoneyBag.create(f12CHF, f7USD);

　　fMB2= MoneyBag.create(f14CHF, f21USD);

　　}

　　public void testBagMultiply() {

　　// {[12 CHF][7 USD]} *2 == {[24 CHF][14 USD]}

　　IMoney expected= MoneyBag.create(new Money(24, "CHF"), new Money(14, "USD"));

　　assertEquals(expected, fMB1.multiply(2));

　　assertEquals(fMB1, fMB1.multiply(1));

　　assertTrue(fMB1.multiply(0).isZero());

　　}

　　public void testBagNegate() {

　　// {[12 CHF][7 USD]} negate == {[-12 CHF][-7 USD]}

　　IMoney expected= MoneyBag.create(new Money(-12, "CHF"), new Money(-7, "USD"));

　　assertEquals(expected, fMB1.negate());

　　}

　　public void testBagSimpleAdd() {

　　// {[12 CHF][7 USD]} + [14 CHF] == {[26 CHF][7 USD]}

　　IMoney expected= MoneyBag.create(new Money(26, "CHF"), new Money(7, "USD"));

　　assertEquals(expected, fMB1.add(f14CHF));

　　}

　　public void testBagSubtract() {

　　// {[12 CHF][7 USD]} - {[14 CHF][21 USD] == {[-2 CHF][-14 USD]}

　　IMoney expected= MoneyBag.create(new Money(-2, "CHF"), new Money(-14, "USD"));

　　assertEquals(expected, fMB1.subtract(fMB2));

　　}

　　public void testBagSumAdd() {

　　// {[12 CHF][7 USD]} + {[14 CHF][21 USD]} == {[26 CHF][28 USD]}

　　IMoney expected= MoneyBag.create(new Money(26, "CHF"), new Money(28, "USD"));

　　assertEquals(expected, fMB1.add(fMB2));

　　}

　　public void testIsZero() {

　　assertTrue(fMB1.subtract(fMB1).isZero());

　　assertTrue(MoneyBag.create(new Money (0, "CHF"), new Money (0, "USD")).isZero());

　　}

　　public void testMixedSimpleAdd() {

　　// [12 CHF] + [7 USD] == {[12 CHF][7 USD]}

　　IMoney expected= MoneyBag.create(f12CHF, f7USD);

　　assertEquals(expected, f12CHF.add(f7USD));

　　}

　　public void testBagNotEquals() {

　　IMoney bag= MoneyBag.create(f12CHF, f7USD);

　　assertFalse(bag.equals(new Money(12, "DEM").add(f7USD)));

　　}

　　public void testMoneyBagEquals() {

　　assertTrue(!fMB1.equals(null));

　　assertEquals(fMB1, fMB1);

　　IMoney equal= MoneyBag.create(new Money(12, "CHF"), new Money(7, "USD"));

　　assertTrue(fMB1.equals(equal));

　　assertTrue(!fMB1.equals(f12CHF));

　　assertTrue(!f12CHF.equals(fMB1));

　　assertTrue(!fMB1.equals(fMB2));

　　}

　　public void testMoneyBagHash() {

　　IMoney equal= MoneyBag.create(new Money(12, "CHF"), new Money(7, "USD"));

　　assertEquals(fMB1.hashCode(), equal.hashCode());

　　}

　　public void testMoneyEquals() {

　　assertTrue(!f12CHF.equals(null));

　　Money equalMoney= new Money(12, "CHF");

　　assertEquals(f12CHF, f12CHF);

　　assertEquals(f12CHF, equalMoney);

　　assertEquals(f12CHF.hashCode(), equalMoney.hashCode());

　　assertTrue(!f12CHF.equals(f14CHF));

　　}

　　public void testMoneyHash() {

　　assertTrue(!f12CHF.equals(null));

　　Money equal= new Money(12, "CHF");

　　assertEquals(f12CHF.hashCode(), equal.hashCode());

　　}

　　public void testSimplify() {

　　IMoney money= MoneyBag.create(new Money(26, "CHF"), new Money(28, "CHF"));

　　assertEquals(new Money(54, "CHF"), money);

　　}

　　public void testNormalize2() {

　　// {[12 CHF][7 USD]} - [12 CHF] == [7 USD]

　　Money expected= new Money(7, "USD");

　　assertEquals(expected, fMB1.subtract(f12CHF));

　　}

　　public void testNormalize3() {

　　// {[12 CHF][7 USD]} - {[12 CHF][3 USD]} == [4 USD]

　　IMoney ms1= MoneyBag.create(new Money(12, "CHF"), new Money(3, "USD"));

　　Money expected= new Money(4, "USD");

　　assertEquals(expected, fMB1.subtract(ms1));

　　}

　　public void testNormalize4() {

　　// [12 CHF] - {[12 CHF][3 USD]} == [-3 USD]

　　IMoney ms1= MoneyBag.create(new Money(12, "CHF"), new Money(3, "USD"));

　　Money expected= new Money(-3, "USD");

　　assertEquals(expected, f12CHF.subtract(ms1));

　　}

　　public void testPrint() {

　　assertEquals("[12 CHF]", f12CHF.toString());

　　}

　　public void testSimpleAdd() {

　　// [12 CHF] + [14 CHF] == [26 CHF]

　　Money expected= new Money(26, "CHF");

　　assertEquals(expected, f12CHF.add(f14CHF));

　　}

　　public void testSimpleBagAdd() {

　　// [14 CHF] + {[12 CHF][7 USD]} == {[26 CHF][7 USD]}

　　IMoney expected= MoneyBag.create(new Money(26, "CHF"), new Money(7, "USD"));

　　assertEquals(expected, f14CHF.add(fMB1));

　　}

　　public void testSimpleMultiply() {

　　// [14 CHF] *2 == [28 CHF]

　　Money expected= new Money(28, "CHF");

　　assertEquals(expected, f14CHF.multiply(2));

　　}

　　public void testSimpleNegate() {

　　// [14 CHF] negate == [-14 CHF]

　　Money expected= new Money(-14, "CHF");

　　assertEquals(expected, f14CHF.negate());

　　}

　　public void testSimpleSubtract() {

　　// [14 CHF] - [12 CHF] == [2 CHF]

　　Money expected= new Money(2, "CHF");

　　assertEquals(expected, f14CHF.subtract(f12CHF));

　　}

　　}

　二、编写ant文件自动运行java单元测试

　　之后，我们在sincky目录下，创建一个build.xml文件，完成它的编译和测试任务，这里我为build.xml文件加了注释，供大家参考：　

<!—build的项目名称叫money_demo，默认执行的任务是compile，根目录指当前目录，也就是sincky文件夹 -->

<project name="money_demo" default=" compile " basedir=".">

<description>

moneytest build file

</description>

<!—定义一个属性src，指向src目录-->

<property name="src" location="src"/>

<!—定义一个属性build，指向build目录，这个目录放置所有的编译后class文件，该目录目前没有创建-->

<property name="build" location="build"/>

<!—定义一个build的classpath，里边放置后边任务里需要的依赖库和依赖路径-->

<path id="build.classpath">

<pathelement path="${ant.home}/lib/junit.jar"/>

<pathelement path="${build}"/>

</path>



<target name="compile" >

<mkdir dir="${build}"/>

<javac srcdir="${src}" destdir="${build}"/>

</target>



<target name="test">

<java classname="MoneyTest" fork="yes">

<classpath refid="build.classpath"/>

</java>

</target>



<target name="clean">

<delete dir="${build}"/>

</target>

</project>

　　之后，我们开始运行build文件，开始编译任务：打开cmd命令行，进入sincky文件夹下，执行ant命令，会看见类似下列内容的效果：　　

C:cloversincky>ant

　　Buildfile: build.xml

　　compile:

　　[mkdir] Created dir: C:cloversinckybuild

　　[javac] Compiling 4 source files to C:cloversinckybuild

　　BUILD SUCCESSFUL

　　Total time: 4 seconds

　　现在你会在sincky目录下发现多了一个build目录，进入build目录，看见里边编译好的4个class文件，恭喜你，这个任务胜利完成!

　　下面我们来运行单元测试任务：

　C:cloversincky>ant test

　　Buildfile: build.xml

　　test:

　　[java] ......................

　　[java] Time: 0.016

　　[java] OK (22 tests)

　　BUILD SUCCESSFUL

　　Total time: 1 second

　　可以通过结果看出，22个测试用例全部通过;junit里边测试通过是.表示，测试失败是.F表示。关于ant的命令帮助，你可以输入ant –h查看。

　　三、修改build.xml文件添加clover任务

　　现在我们开始修改build.xml文件，添加clover任务，以实现junit测试覆盖率的分析。首先，我们添加clover任务的配置任务;在build.xml文件里添加如下代码：

　　这两行定义了能够在ant文件里使用clover任务的配置工作。然后再添加一个clover任务，用来启动clover构建任务：

　　这里的initString定义了clover覆盖数据库的信息，它会在执行clover任务时自动创建，里边保存了源路径执行测试任务时候的全部信息，clover通过这个demo_coverage.db来创建覆盖率分析报告。如果这个demo_coverage.db存在，clover在每次运行时自动覆盖，如果不存在，clover自动创建它。

　　我们这里使用clover，是为了搜集junit测试时候的覆盖率信息，所以呢，junit测试过程中，我们需要使用clover.jar包，所以我们还需要把clover.jar文件作为junit运行的依赖库，因此修改build.classpath代码成如下所示：

　　这里顺便我们也把path的值说明一下，省得有人不懂哦!这里的ant.home是在计算机里创建的环境变量ANT_HOME，它的值应该是你的ant的安装路径，例如c:ant，所以前两行代码的意思，就是把c:antlibclover.jar和c:antlibjunit.jar作为依赖库。当然，事先你一定要拷贝这两个jar文件到你的lib目录。

　　好了，我们现在开始重新使用clover任务来运行junit测试!

　C:cloversincky>ant clean

　　Buildfile: build.xml

　　clean:

　　[delete] Deleting directory C:cloversinckybuild

　　BUILD SUCCESSFUL

　　Total time: 0 seconds

　　C:cloversincky>ant clover compile

　　Buildfile: build.xml

　　clover:

　　[clover-setup] Clover Version 1.3.8, built on May 18 2005

　　[clover-setup] loaded from: C:cloverlibclover.jar

　　[clover-setup] 30 day Evaluation License registered tosinckyzhang@163.com

　　[clover-setup] You have 10 day(s) before your Evaluation License expires.

　　[clover-setup] Clover is enabled with initstring 'C:cloversinckydemo_coverage.db'

　　compile:

　　[mkdir] Created dir: C:cloversinckybuild

　　[javac] Compiling 4 source files to C:cloversinckybuild

　　[clover] Clover Version 1.3.8, built on May 18 2005

　　[clover] loaded from: C:cloverlibclover.jar

　　[clover] 30 day Evaluation License registered tosinckyzhang@163.com

　　[clover] You have 10 day(s) before your Evaluation License expires.

　　[clover] No coverage database 'C:cloversinckydemo_coverage.db' fou

　　nd. Creating a fresh one.

　　[clover] Clover all over. Instrumented 4 files.

　　BUILD SUCCESSFUL

　　Total time: 2 seconds

　　我们会发现在sincky目录下多了一个demo_coverage.db文件;之后我们再执行测试任务：　　

C:cloversincky>ant test

　　Buildfile: build.xml

　　test:

　　[java] ......................

　　[java] Time: 0

　　[java] OK (22 tests)

　　BUILD SUCCESSFUL

　　Total time: 0 seconds

　　我们会看到又多了一个关于junit测试的.db文件!现在，我们已经使用clover统计完了覆盖率信息，之后创建clover报告，以直观方式来查看具体的覆盖率结果!这个任务需要在build.xml里创建任务。Clover的报告有多种方式：html、pdf、xml以及swingview的图形化报告，当然与eclipse等java的IDE集成，也会在IDE里创建报告;这里我们只演示html类型的报告!我们修改build.xml文件，添加如下任务：

　　这里的元素指产生的报告类型是当前的测试报告，还有历史报告，我们在后边讲解!这个报告是html格式，创建后的报告放在一个叫做clover_html的文件夹里，报告标题叫做Clover demo。

　　我们现在给出完整的修改后的build.xml文件：　

moneytest build file

　　fork="yes">

　　现在我们执行report这个任务：　

C:cloversincky>ant report

　　Buildfile: build.xml

　　clover:

　　[clover-setup] Clover Version 1.3.8, built on May 18 2005

　　[clover-setup] loaded from: C:cloverlibclover.jar

　　[clover-setup] 30 day Evaluation License registered to sinckyzhang@163.com

　　[clover-setup] You have 10 day(s) before your Evaluation License expires.

　　[clover-setup] Clover is enabled with initstring 'C:cloversinckydemo_coverage.db'

　　report:

　　[clover-report] Clover Version 1.3.8, built on May 18 2005

　　[clover-report] loaded from: C:cloverlibclover.jar

　　[clover-report] 30 day Evaluation License registered to sinckyzhang@163.com

　　[clover-report] You have 10 day(s) before your Evaluation License expires.

　　[clover-report] Loaded results from 1 coverage recording.

　　[clover-report] Writing report to 'C:cloversinckyclover_html'

　　[clover-report] Done. Processed 1 packages.

　　BUILD SUCCESSFUL

　　Total time: 1 second

　　现在你可以打开sincky下的clover_html文件夹下的index.html文件，如下所示：

　　报告最左边是包名，以及包下边的类;右边是主窗口，显示当前这个Money类的测试覆盖率，我们可以通过行号来查看到15、16、17行执行了156次，下边还会有两行一次也没有执行过，所以造成这个类整体的测试覆盖率不是100%。

　　重构测试代码实现百分百测试覆盖率

　　我们总是希望做单元测试的时候，让代码的测试覆盖率尽可能的达到100%，所以我们需要重构测试代码。从分析得知，第40行虽然执行了27次，但是从来没有测试if的判断条件为true的情况，所以我们要添加测试用例，测试isZero()返回为true的情况!因此，我们修改测试代码MoneyTest.java文件，在前边初始化地方加上一个Money实例，如下：　

public class MoneyTest extends TestCase {

　　private Money f12CHF;

　　private Money f14CHF;

　　private Money f7USD;

　　private Money f21USD;

　　private Money f0USD;

　　在setup方法里添加：

protected void setUp() {

　　f12CHF= new Money(12, "CHF");

　　f14CHF= new Money(14, "CHF");

　　f7USD= new Money( 7, "USD");

　　f21USD= new Money(21, "USD");

　　f0USD = new Money(0, "USD"); //sincky

　　在最后加上一个测试用例：

　public void testMoneyEqualsZero() {

　　assertTrue(!f0USD.equals(null));

　　IMoney equalMoney = new Money(0, "CHF");

　　assertTrue(f0USD.equals(equalMoney));

　　}

　　之后，我们重新编译，测试，创建报告，即执行下列命令：

　>ant clean

　　>ant clover compile

　　>ant test

　　>ant report

　　这时候再打开新的html报告，看到如下效果覆盖率已经到达100%：

　　完毕，如果能进展到这一步，相信你已经对使用junit、ant、clover做java的单元测试，已经到了一个新的飞越!如果有兴趣，你还可以把junit报告和clover报告一并输出，以更好的为企业开发中使用这种工作模式!

　　文章源码均来自clover网站，本人稍做修改。

　　写在后面的话：目前国内单元测试尚在起步阶段，由于工作量大，耗时耗成本，很多公司都省去该环节;但是使用一些先进的技术，对源代码一些关键的类进行单元测试是可行的，也是必要的;希望本文对测试与java开发界朋友有所收获。

关注我们