unit.txt

this unit test code

Junit不错的入门实例及应用经验(转)2008-01-15 13:27Junit架构
　　下面以Money这个类为例进行说明。 public class Money {
     private int fAmount;//余额
     private String fCurrency;//货币类型 

     public Money(int amount, String currency) {
         fAmount= amount;
         fCurrency= currency;
     }

     public int amount() {
         return fAmount;
     }

     public String currency() {
         return fCurrency;
     }
    
     public Money add(Money m) {//加钱
         return new Money(amount()+m.amount(), currency());
     }
    
     public boolean equals(Object anObject) {//判断钱数是否相等
         if (anObject instanceof Money) {
             Money aMoney= (Money)anObject;
             return aMoney.currency().equals(currency())
                 && amount() == aMoney.amount();
         }
         return false;
     }    
}

　　Junit本身是围绕着两个设计模式来设计的：命令模式和集成模式.

命令模式
　　利用TestCase定义一个子类，在这个子类中生成一个被测试的对象，编写代码检测某个方法被调用后对象的状态与预期的状态是否一致，进而断言程序代码有没有bug。
　　当这个子类要测试不只一个方法的实现代码时，可以先建立测试基础，让这些测试在同一个基础上运行，一方面可以减少每个测试的初始化，而且可以测试这些不同方法之间的联系。
　　例如，我们要测试Money的Add方法，可以如下: public class MoneyTest extends TestCase { //TestCase的子类
     public void testAdd() { //把测试代码放在testAdd中
         Money m12CHF= new Money(12, "CHF");   //本行和下一行进行一些初始化
         Money m14CHF= new Money(14, "CHF");        
         Money expected= new Money(26, "CHF");//预期的结果
         Money result= m12CHF.add(m14CHF);     //运行被测试的方法
         Assert.assertTrue(expected.equals(result));      //判断运行结果是否与预期的相同
     }
}
　　如果测试一下equals方法，用类似的代码，如下： public class MoneyTest extends TestCase { //TestCase的子类
     public void testEquals() { //把测试代码放在testEquals中
         Money m12CHF= new Money(12, "CHF"); //本行和下一行进行一些初始化
         Money m14CHF= new Money(14, "CHF"); 

         Assert.assertTrue(!m12CHF.equals(null));//进行不同情况的测试
         Assert.assertEquals(m12CHF, m12CHF);
         Assert.assertEquals(m12CHF, new Money(12, "CHF")); // (1)
         Assert.assertTrue(!m12CHF.equals(m14CHF));
     }
}

　　当要同时进行测试Add和equals方法时，可以将它们的各自的初始化工作，合并到一起进行，形成测试基础,用setUp初始化，用tearDown清除。如下： public class MoneyTest extends TestCase {//TestCase的子类
     private Money f12CHF;//提取公用的对象
     private Money f14CHF;    

     protected void setUp() {//初始化公用对象
         f12CHF= new Money(12, "CHF");
         f14CHF= new Money(14, "CHF");
     }
     public void testEquals() {//测试equals方法的正确性
         Assert.assertTrue(!f12CHF.equals(null));
         Assert.assertEquals(f12CHF, f12CHF);
         Assert.assertEquals(f12CHF, new Money(12, "CHF"));
         Assert.assertTrue(!f12CHF.equals(f14CHF));
     }
    
     public void testSimpleAdd() {//测试add方法的正确性
         Money expected= new Money(26, "CHF");
         Money result= f12CHF.add(f14CHF);
         Assert.assertTrue(expected.equals(result));
     }
}

　　将以上三个中的任一个TestCase子类代码保存到名为MoneyTest.java的文件里，并在文件首行增加 import junit.framework.*;，都是可以运行的。关于Junit运行的问题很有意思，下面单独说明。
　　上面为解释概念“测试基础(fixture)”，引入了两个对两个方法的测试。命令模式与集成模式的本质区别是，前者一次只运行一个测试。 
集成模式
　　利用TestSuite可以将一个TestCase子类中所有test***()方法包含进来一起运行，还可将TestSuite子类也包含进来，从而行成了一种等级关系。可以把TestSuite视为一个容器，可以盛放TestCase中的test***()方法，它自己也可以嵌套。这种体系架构，非常类似于现实中程序一步步开发一步步集成的现况。
　　对上面的例子，有代码如下： public class MoneyTest extends TestCase {//TestCase的子类
     ....
     public static Test suite() {//静态Test
         TestSuite suite= new TestSuite();//生成一个TestSuite
         suite.addTest(new MoneyTest("testEquals")); //加入测试方法
         suite.addTest(new MoneyTest("testSimpleAdd"));
         return suite;
     }
}
　　从Junit2.0开始，有列简捷的方法: public class MoneyTest extends TestCase {//TestCase的子类
     ....
     public static Test suite() {静态Test
         return new TestSuite(MoneyTest.class); //以类为参数
     }
}
　　TestSuite见嵌套的例子，在后面应用案例中有。
　　 

4、测试代码的运行
　　先说最常用的集成模式。
　　测试代码写好以后，可以相应的类中写main方法，用java命令直接运行；也可以不写main方法，用Junit提供的运行器运行。Junit提供了textui,awtui和swingui三种运行器。
　　以前面第2步中的AllTests运行为例，可有四种：

java junit.textui.TestRunner junit.samples.AllTests
java junit.awtui.TestRunner junit.samples.AllTests
java junit.swingui.TestRunner junit.samples.AllTests
java junit.samples.AllTests
　　main方法中一般也都是简单地用Runner调用suite()，当没有main时，TestRunner自己以运行的类为参数生成了一个TestSuite.
　　
　　对于命令模式的运行，有两种方法。

静态方法
TestCase test= new MoneyTest("simple add") {
public void runTest() {
testSimpleAdd();
}
};
动态方法
TestCase test= new MoneyTest("testSimpleAdd");

　　我试了一下，好象有问题，哪位朋友成功了，请指点我一下。确实可以。
import junit.framework.*; 

public class MoneyTest extends TestCase {//TestCase的子类
     private Money f12CHF;//提取公用的对象
     private Money f14CHF;   
     public MoneyTest(String name){
         super(name);
     }
     protected void setUp() {//初始化公用对象
         f12CHF= new Money(12, "CHF");
         f14CHF= new Money(14, "CHF");
     }
     public void testEquals() {//测试equals方法的正确性
         Assert.assertTrue(!f12CHF.equals(null));
         Assert.assertEquals(f12CHF, f12CHF);
         Assert.assertEquals(f12CHF, new Money(12, "CHF"));
         Assert.assertTrue(!f12CHF.equals(f14CHF));
     }
    
     public void testAdd() {//测试add方法的正确性
         Money expected= new Money(26, "CHF");
         Money result= f12CHF.add(f14CHF);
         Assert.assertTrue(expected.equals(result));
     }
//     public static void main(String[] args) {
//         TestCase test=new MoneyTest("simple add") {
//                 public void runTest() {
//                     testAdd();
//                 }
//             };
//         junit.textui.TestRunner.run(test);
//     }
     public static void main(String[] args) {
         TestCase test=new MoneyTest("testAdd");
         junit.textui.TestRunner.run(test);
     }
}

再给一个静态方法用集成测试的例子： public static Test suite() {
     TestSuite suite= new TestSuite();
     suite.addTest(
         new testCar("getWheels") {
             protected void runTest() { testGetWheels(); }
         }
     ); 

     suite.addTest(
         new testCar("getSeats") {
             protected void runTest() { testGetSeats(); }
         }
     );
     return suite;
}



一些问题
　　有人在实践基础上总结出一些非常有价值的使用技巧，我没有经过一一“测试”，暂列在此。

不要用TestCase的构造函数初始化Fixture，而要用setUp()和tearDown()方法。 
不要依赖或假定测试运行的顺序，因为JUnit利用Vector保存测试方法。所以不同的平台会按不同的顺序从Vector中取出测试方法。不知3.8中是不是还是如此，不过它提供的例子有一个是指定用VectorSuite的，如果不指定呢？ 
避免编写有副作用的TestCase。例如：如果随后的测试依赖于某些特定的交易数据，就不要提交交易数据。简单的回滚就可以了。 
当继承一个测试类时，记得调用父类的setUp()和tearDown()方法。 
将测试代码和工作代码放在一起，一边同步编译和更新。（使用Ant中有支持junit的task.） 
测试类和测试方法应该有一致的命名方案。如在工作类名前加上test从而形成测试类名。 
确保测试与时间无关，不要依赖使用过期的数据进行测试。导致在随后的维护过程中很难重现测试。 
如果你编写的软件面向国际市场，编写测试时要考虑国际化的因素。不要仅用母语的Locale进行测试。 
尽可能地利用JUnit提供地assert/fail方法以及异常处理的方法，可以使代码更为简洁。 
测试要尽可能地小，执行速度快。 
把测试程序建立在与被测对象相同的包中 
在你的原始代码目录中避免测试码出现，可在一个源码镜像目录中放测试码 
在自己的应用程序包中包含一个TestSuite测试类