JUnit4之隐藏特性"曝光"

上一篇 / 下一篇  2010-11-30 21:27:27

只要做Java开发的,99%的都用过JUnit。在JUnit4里面除了@Test, @Before, @BeforeClass这样基本的特性,JUnit4还有些很酷但是大家平时不太用的特性。我这里做一下介绍,大家可以用一下,或者至少把玩一下:) 以下特性都基于4.8版本。
  • ParallelComputer: 并行测试

当需要同时测试testcase的时候,你不需要为自己写thread来做这个事情。JUnit4已经有了这个特性,而且还提供多种同步选择。例如:

  1. /** 
  2.  * @author 卢声远<michaellufhl@yahoo.com.cn> 
  3.  */  
  4. public class ParallelComputerTest {  
  5.      
  6.    @Test  
  7.     public void test() {      
  8.       Class[] cls={ParallelTest1.class,ParallelTest2.class };  
  9.         
  10.       //Parallel among classes  
  11.       JUnitCore.runClasses(ParallelComputer.classes(), cls);  
  12.         
  13.       //Parallel among methods in a class  
  14.       JUnitCore.runClasses(ParallelComputer.methods(), cls);  
  15.         
  16.       //Parallel all methods in all classes  
  17.       JUnitCore.runClasses(new ParallelComputer(truetrue), cls);     
  18.     }  
  19.    public static class ParallelTest1{  
  20.       @Test public void a(){}  
  21.       @Test public void b(){}  
  22.    }  
  23.    public static class ParallelTest2{  
  24.       @Test public void a(){}  
  25.       @Test public void b(){}  
  26.    }  
  27. }  

你有3种同步方式:

1: ParallelComputer.classes():所有测试类同时开始执行,但是每个类里面的方法还是顺序执行。在例子里面ParallelTest1ParallelTest2同时开始,但是各自的a(),b()还是顺序执行。

2: ParallelComputer.methods():测试类顺序执行,但是每个类里面的方法是同时开始执行。在例子里面ParallelTest1a()b()同时开始,等结束之后再开始ParallelTest2

3: new ParallelComputer(true, true):所有测试类里面方法同时开始执行。在例子里面4个方法同时开始执行。

很有意思吧。


  • Category: 分类测试

当你有很多testcase,但是你不想每次都执行一遍的时候。你可以把testcase分成若干类,然后就可以分类有选择的来执行这些testcase。

例子:譬如你有2类testcase,一类是重要的用Important.class表示,还有一类不那么重要的用Secondary.class表示。

  1. /** 
  2.  * @author 卢声远<michaellufhl@yahoo.com.cn> 
  3.  */  
  4. interface Important{};  
  5. interface Secondary{};  
  6. @RunWith(Categories.class)  
  7. @IncludeCategory(Important.class)  
  8. @ExcludeCategory(Secondary.class)  
  9. @SuiteClasses( { CategoryTest.Alpha.class,   
  10.                  CategoryTest.Beta.class })  
  11. public class CategoryTest {  
  12.      
  13.    @Category(Important.class)  
  14.    public static class Alpha{//Alpha is Important except b  
  15.       @Test   
  16.       public void a(){}  
  17.         
  18.       @Test  
  19.       @Category(Secondary.class)  
  20.       public void b(){}  
  21.    }  
  22.      
  23.    public static class Beta{  
  24.       @Test   
  25.       @Category(Important.class)  
  26.       public void a(){}//a is Important  
  27.    }  
  28. }  

当你执行后会发现只有Alpha.a()Beta.a()执行到,Alpha.b()@ExcludeCategory掉了。


  • MaxCore: 失败优先

  当需要反复测试大量testcase的时候,你往往比较关注那些前一次失败的case。这个时候你就可以利用MaxCore特性在每次执行testcase的时候优先执行那些上次失败的case。

例如:

  1. /** 
  2.  * @author 卢声远<michaellufhl@yahoo.com.cn> 
  3.  */  
  4. public class MaxCoreTest {  
  5.      
  6.    private MaxCore fMax;  
  7.      
  8.    @Before  
  9.    public void createMax() {  
  10.       File fMaxFile= new File("MaxCore.ser");  
  11.       fMax= MaxCore.storedLocally(fMaxFile);  
  12.    }  
  13.      
  14.    @Test   
  15.    public void test(){  
  16.       Request request= Request.aClass(Delta.class);  
  17.       fMax.run(request);  
  18.       fMax.run(request);//b->c->a  
  19.    }  
  20.      
  21.    public static class Delta{  
  22.       @Test public void a(){}  
  23.       @Test public void b(){  
  24.          Assert.fail();  
  25.       }  
  26.       @Test public void c(){}  
  27.    }  
  28. }  

可以观察到第2次执行的时候Delta.b()由于第1次的失败而提前到了最先执行。


  • DataPoint: 参数数据

当需要测试不同输入参数的时候是不是要写一大堆testcase?不需要,因为JUnit4提供了参数化测试数据的特性。例如你想要测试2个整型数据作为输入参数的时候:

  1. /** 
  2.  * @author 卢声远<michaellufhl@yahoo.com.cn> 
  3.  */  
  4. @RunWith(Theories.class)  
  5. public class DataPointTest {  
  6.    @DataPoint  
  7.    public static int ONE= 1;  
  8.    @DataPoint  
  9.    public static int TWO= 2;  
  10.    
  11.    /* You could also use @DataPoints instead of @DataPoint 
  12.    @DataPoints 
  13.    public static int[] points= { 1, 2 };*/  
  14.    
  15.    @Theory  
  16.    public void test(int first, int second) {  
  17.    }  
  18. }  

通过观察test()被执行了4次,每次不同的组合作为参数输入。而且如果参数数目过多,你可以通过@DataPoints一下子把参数都设进去。用过@RunWith(Parameterized.class)的朋友可以和DataPoint做一下比较。


  • TestedOn

这个功能也是参数化数据,只不过它是直接在参数上配置。例如:

  1. @Theory  
  2. public void test2(@TestedOn(ints={1,2})int first) {  
  3.     System.out.println(first);  
  4. }  

结果打印出来"12"


  • PrintableResult: 打印结果

这个我认为倒是一个小功能,它只是把测试失败的结果以比较美观的格式打出来。例如:

  1. Result result = JUnitCore.runClasses(SomeTest.class);  
  2. System.out.println(new PrintableResult(result.getFailures()));  

TAG: java JAVA Java JUnit Junit JUNIT junit junit4 Testing testing

 

评分:0

我来说两句

卢声远

卢声远

Hello World

日历

« 2021-12-04  
   1234
567891011
12131415161718
19202122232425
262728293031 

我的存档

数据统计

  • 访问量: 518
  • 日志数: 1
  • 建立时间: 2010-11-28
  • 更新时间: 2010-11-30

RSS订阅

Open Toolbar