Junit学习笔记

转载于http://hedong.3322.org/archives/000224.html，原作者竹笋炒肉。

 

     JUnit是由 Erich Gamma 和 Kent Beck 编写的一个回归测试框架（regression testing framework）,供Java开发人员编写单元测试之用。

  

1、概述
　　Junit测试是程序员测试，即所谓白盒测试，因为程序员知道被测试的软件如何（How）完成功能和完成什么样（What）的功能。
　　Junit本质上是一套框架，即开发者制定了一套条条框框，遵循这此条条框框要求编写测试代码，如继承某个类，实现某个接口，就可以用Junit进行自动测试了。
　　由于Junit相对独立于所编写的代码，可以测试代码的编写可以先于实现代码的编写，XP 中推崇的 test first design的实现有了现成的手段：用Junit写测试代码，写实现代码，运行测试，测试失败，修改实现代码，再运行测试，直到测试成功。以后对代码的修改和优化，运行测试成功，则修改成功。
　　Java 下的 team 开发，采用 cvs(版本控制) + ant(项目管理) + junit(集成测试) 的模式时，通过对ant的配置，可以很简单地实现测试自动化。

 

　　对不同性质的被测对象，如Class，Jsp，Servlet，Ejb等，Junit有不同的使用技巧，以后慢慢地分别讲叙。以下以Class测试为例讲解，除非特殊说明。

 

3、Junit架构
　 下面以Money这个类为例进行说明。

 

Java代码

1. package com.nikee.junit;   
2.   
3. public class Money {   
4.       private int fAmount;//余额   
5.     private String fCurrency;//货币类型   
6.   
7.     public Money(int amount, String currency) {   
8.         fAmount= amount;   
9.         fCurrency= currency;   
10.     }   
11.   
12.     public int amount() {   
13.         return fAmount;   
14.     }   
15.   
16.     public String currency() {   
17.         return fCurrency;   
18.     }   
19.        
20.     public Money add(Money m) {//加钱   
21.         return new Money(amount()+m.amount(), currency());   
22.     }   
23.        
24.     public boolean equals(Object anObject) {//判断钱数是否相等   
25.         if (anObject instanceof Money) {   
26.             Money aMoney= (Money)anObject;   
27.             return aMoney.currency().equals(currency()) && amount() == aMoney.amount();   
28.         }   
29.         return false;   
30.     }       
31. }  

package com.nikee.junit;

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方法，可以如下:
  
  Java代码

  1. package com.nikee.junit;   
  2.   
  3. import junit.framework.Assert;   
  4. import junit.framework.TestCase;   
  5.   
  6. //TestCase的子类   
  7. public class MoneyTest extends TestCase {    
  8.        // 把测试代码放在testAdd中   
  9.     public void testAdd() {    
  10.         // 本行和下一行进行一些初始化   
  11.      Money m12CHF= new Money(12, "CHF");     
  12.         Money m14CHF= new Money(14, "CHF");     
  13.         // 预期的结果   
  14.         Money expected= new Money(26, "CHF");   
  15.         // 运行被测试的方法   
  16.         Money result= m12CHF.add(m14CHF);       
  17.         // 判断运行结果是否与预期的相同   
  18.         Assert.assertTrue(expected.equals(result));        
  19.     }   
  20. }  

  package com.nikee.junit;
  
  import junit.framework.Assert;
  import junit.framework.TestCase;
  
  //TestCase的子类
  public class MoneyTest extends TestCase { 
         // 把测试代码放在testAdd中
      public void 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方法，用类似的代码，如下：
  
  Java代码

  1. package com.nikee.junit;   
  2.   
  3. import junit.framework.Assert;   
  4. import junit.framework.TestCase;   
  5.   
  6. //TestCase的子类   
  7. public class MoneyTest extends TestCase {    
  8.     //  把测试代码放在testEquals中   
  9.     public void testEquals() {    
  10.         // 本行和下一行进行一些初始化   
  11.         Money m12CHF= new Money(12, "CHF");    
  12.         Money m14CHF= new Money(14, "CHF");   
  13.         // 进行不同情况的测试   
  14.         Assert.assertTrue(!m12CHF.equals(null));   
  15.         Assert.assertEquals(m12CHF, m12CHF);   
  16.         Assert.assertEquals(m12CHF, new Money(12, "CHF"));   
  17.         Assert.assertTrue(!m12CHF.equals(m14CHF));   
  18.     }   
  19. }  

  package com.nikee.junit;
  
  import junit.framework.Assert;
  import junit.framework.TestCase;
  
  //TestCase的子类
  public class MoneyTest extends TestCase { 
  	//	把测试代码放在testEquals中
  	public void 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"));
          Assert.assertTrue(!m12CHF.equals(m14CHF));
      }
  }

   

      当要同时进行测试Add和equals方法时，可以将它们的各自的初始化工作，合并到一起进行，形成测试基础,用setUp初始化，用tearDown清除。如下：

Java代码

1. package com.nikee.junit;   
2.   
3. import junit.framework.Assert;   
4. import junit.framework.TestCase;   
5.   
6. public class MoneyTest extends TestCase {//TestCase的子类   
7.     private Money f12CHF;//提取公用的对象   
8.     private Money f14CHF;      
9.   
10.     protected void setUp() {//初始化公用对象   
11.         f12CHF= new Money(12, "CHF");   
12.         f14CHF= new Money(14, "CHF");   
13.     }   
14.        
15.     public void testEquals() {//测试equals方法的正确性   
16.         Assert.assertTrue(!f12CHF.equals(null));   
17.         Assert.assertEquals(f12CHF, f12CHF);   
18.         Assert.assertEquals(f12CHF, new Money(12, "CHF"));   
19.         Assert.assertTrue(!f12CHF.equals(f14CHF));   
20.     }   
21.        
22.     public void testSimpleAdd() {//测试add方法的正确性   
23.         Money expected= new Money(26, "CHF");   
24.         Money result= f12CHF.add(f14CHF);   
25.         Assert.assertTrue(expected.equals(result));   
26.     }   
27. }  

package com.nikee.junit;

import junit.framework.Assert;
import junit.framework.TestCase;

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***()方法，它自己也可以嵌套。这种体系架构，非常类似于现实中程序一步步开发一步步集成的现况。
  　　对上面的例子，有代码如下：
  Java代码

  1. public class MoneyTest extends TestCase {//TestCase的子类   
  2.     ....   
  3.     public static Test suite() {//静态Test   
  4.         TestSuite suite= new TestSuite();//生成一个TestSuite   
  5.         suite.addTest(new MoneyTest("testEquals")); //加入测试方法   
  6.         suite.addTest(new MoneyTest("testSimpleAdd"));   
  7.         return suite;   
  8.     }   
  9. }  

  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开始，有列简捷的方法:

  Java代码

  1. public class MoneyTest extends TestCase {//TestCase的子类   
  2.     ....   
  3.     public static Test suite() {静态Test   
  4.         return new TestSuite(MoneyTest.class); //以类为参数   
  5.     }   
  6. }  

  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代码

  1. java junit.textui.TestRunner junit.samples.AllTests   
  2. java junit.awtui.TestRunner junit.samples.AllTests   
  3. java junit.swingui.TestRunner junit.samples.AllTests   
  4. java junit.samples.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.
  　　
  　　对于命令模式的运行，有两种方法。

  • 静态方法
  Java代码

  1. TestCase test= new MoneyTest("simple add") {   
  2.   public void runTest() {   
  3.     testSimpleAdd();   
  4.   }   
  5. };  

  TestCase test= new MoneyTest("simple add") {
    public void runTest() {
      testSimpleAdd();
    }
  };
  

   

• 动态方法
  
     TestCase test= new MoneyTest("testSimpleAdd");
  
  
  我试了一下， 好象有问题，哪位朋友成功了，请指点我一下。确实可以。
  
  Java代码

  1. import junit.framework.*;   
  2.   
  3. public class MoneyTest extends TestCase {//TestCase的子类   
  4.     private Money f12CHF;//提取公用的对象   
  5.     private Money f14CHF;      
  6.     public MoneyTest(String name){   
  7.         super(name);   
  8.     }   
  9.     protected void setUp() {//初始化公用对象   
  10.         f12CHF= new Money(12, "CHF");   
  11.         f14CHF= new Money(14, "CHF");   
  12.     }   
  13.     public void testEquals() {//测试equals方法的正确性   
  14.         Assert.assertTrue(!f12CHF.equals(null));   
  15.         Assert.assertEquals(f12CHF, f12CHF);   
  16.         Assert.assertEquals(f12CHF, new Money(12, "CHF"));   
  17.         Assert.assertTrue(!f12CHF.equals(f14CHF));   
  18.     }   
  19.        
  20.     public void testAdd() {//测试add方法的正确性   
  21.         Money expected= new Money(26, "CHF");   
  22.         Money result= f12CHF.add(f14CHF);   
  23.         Assert.assertTrue(expected.equals(result));   
  24.     }   
  25. //    public static void main(String[] args) {   
  26. //        TestCase test=new MoneyTest("simple add") {   
  27. //                public void runTest() {   
  28. //                    testAdd();   
  29. //                }   
  30. //            };   
  31. //        junit.textui.TestRunner.run(test);   
  32. //    }   
  33.     public static void main(String[] args) {   
  34.         TestCase test=new MoneyTest("testAdd");   
  35.         junit.textui.TestRunner.run(test);   
  36.     }   
  37. }  

  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);
      }
  }
  
  

   再给一个静态方法用集成测试的例子：
  
  Java代码

  1. public static Test suite() {   
  2.     TestSuite suite= new TestSuite();   
  3.     suite.addTest(   
  4.         new testCar("getWheels") {   
  5.             protected void runTest() { testGetWheels(); }   
  6.         }   
  7.     );   
  8.   
  9.     suite.addTest(   
  10.         new testCar("getSeats") {   
  11.             protected void runTest() { testGetSeats(); }   
  12.         }   
  13.     );   
  14.     return suite;   
  15. }  

  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;
  }
  
  

   

  5、应用案例

  1. Junit Primer例程，运行如下：
     java com.hedong.JunitLearning.Primer.ShoppingCartTest
  2. Ant+Junit+Mailto实现自动编译、调试并发送结果的build.xml
  3. JUnit实施,写得很棒，理解也深刻。例程运行如下：
     java com.hedong.JunitLearning.car.testCarNoJunit
     java junit.swingui.TestRunner com.hedong.JunitLearning.car.testCar
  4. Junit与log4j结合，阿菜的例程运行：
     cd acai
     ant junit

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

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

   

  8、未完成的任务

  1. httpunit
  2. cactus
  3. 将Junit用链接池测试
  
  主要参考文献：
  
  1. 
     
  2. JUnit入門
     http://www.dotspace.twmail.org/Test/JUnit_Primer.htm
  3. 怎样使用Junit Framework进行单元测试的编写
     http://www.chinaunix.net/bbsjh/14/546.html
  4. Ant+Junit+Log4J+CVS进行XP模式开发的建立
     http://ejb.cn/modules/tutorials/printpage.php?tid=4
  5. 用HttpUnit测试Web应用程序
     http://www.zdnet.com.cn/developer/code/story/0,2000081534,39033726,00.htm
  6. 有没有用过Cactus的，Web层的测试是Cactus还是JUnit？
     http://www.jdon.com/jive/thread.jsp?forum=16&thread=9156
  7. Ant+junit的测试自动化 biggie（原作）
     http://www.csdn.net/Develop/article/19%5C19748.shtm
  8. JUnit实施
     http://www.neweasier.com/article/2002-08-07/1028723459.html
  9. JUnitTest Infected: Programmers Love Writing Tests
     http://junit.sourceforge.net/doc/testinfected/testing.htm
  10. JUnit Cookbook
      http://junit.sourceforge.net/doc/cookbook/cookbook.htm
  11. JUnit Primer
      http://www.itu.dk/~lthorup/JUnitPrimer.html
  12. IBM DevelopWorks
      http://www-106.ibm.com/search/searchResults.jsp?query=junit&searchScope=dW&searchType=1&searchSite=dWChina&pageLang=zh&langEncoding=gb2312&Search.x=0&