首页 > java > JUnit4的深入探索

JUnit4的深入探索

2007年7月20日 发表评论 阅读评论
一、"@Test"有两个非常有用的参数
A.        异常检测
"@Test"的"expected"参数用来说明希望抛出的异常，如果运行时没有抛出这个异常，测试用例就被标识为失败。
    @Test(expected=ArithmeticException.class)
    publicvoid test2() {
       int z = x / 0;
       Assert.assertEquals(2, z);
    }
B.        超时测试
"@Test"有一个timeout的参数用来说明这个测试用例运行的时间最长应该为多少，如果时间超出，则标识为失败。
    @Test(timeout=500)    
    publicvoid test3(){
       for (int i=0;i<100;i++){
         try {
           Thread.sleep(10);
        } catch (InterruptedException e) {
           // TODO Auto-generated catch block
           e.printStackTrace();
        }
       }
    }
二、忽略测试
@Ignore的注释，它迫使该框架忽略掉一个特别的测试方法。也可以传入一条消息来向恰巧进行这项忽略测试的可信的开发人员传达您的决定。
    @Ignore("暂时忽略")
    @Test
    publicvoid test4(){
        Assert.assertEquals(2, 1);
    }
三、参数测试
偶尔，应用程序的业务逻辑要求您编写许多不定量的测试来保证其健壮。在 JUnit 之前的版本中，这种场景很不方便，主要是因为一个测试中方法的参数组各不相同，意味着要为每一个单独的组编写一个测试用例。
JUnit 4 引入了一项卓越的新功能，即能够创建由参数值供给的通用测试。结果是，您可以创建一个单个的测试用例并多次运行 —— 为您创建的每个参数运行一次。
在 JUnit 4 中创建参数测试只需要五个步骤：
  1. 创建一个不含参数的通用测试。
  2. 创建一个返回 Collection 类型的 static方法，并用 @Parameter 注释加以修饰。
  3. 为在步骤 1 中定义的通用方法所要求的参数类型创建类成员。
  4. 创建一个持有这些参数类型的构造函数，并把这些参数类型和步骤 3 中定义的类成员相应地联系起来。
  5. 通过 @RunWith 注释，指定测试用例和 Parameterized 类一起运行。
@RunWith(Parameterized.class)
publicclass TestWordDealUtilWithParam {
   private String expected;
  
   private String target;
 
   @Parameters
   publicstatic Collection words(){
         return Arrays.asList(new Object[][]{
          {"employee_info", "employeeInfo"},     //测试一般的处理情况
          {null, null},                  //测试 null 时的处理情况
          {"", ""},                     //测试空字符串时的处理情况
          {"employee_info", "EmployeeInfo"},     //测试当首字母大写时的情况
          {"employee_info_a", "employeeInfoA"}, //测试当尾字母为大写时的情况
          {"employee_a_info", "employeeAInfo"} //测试多个相连字母大写时的情况
         });
   }
 
  /**
  *参数化测试必须的构造函数
  *@paramexpected   期望的测试结果，对应参数集中的第一个参数
  *@paramtarget 测试数据，对应参数集中的第二个参数
  */
   public TestWordDealUtilWithParam(String expected , String target){
      this.expected = expected;
      this.target = target;
   }
 
  /**
  *实际需要测试的方法
  */
   @Test
   publicvoid wordFormat4DB(){
      assertEquals(expected, WordDealUtil.wordFormat4DB(target));
   }
四、测试套件
测试运行器，JUnit 中所有的测试方法都是由它负责执行的。JUnit 为单元测试提供了默认的测试运行器，但 JUnit 并没有限制您必须使用默认的运行器。相反，您不仅可以定制自己的运行器（所有的运行器都继承自 org.junit.runner.Runner），而且还可以为每一个测试类指定使用某个具体的运行器。指定方法也很简单，使用注解 org.junit.runner.RunWith 在测试类上显式的声明要使用的运行器即可。
在实际项目中，随着项目进度的开展，单元测试类会越来越多，可是直到现在我们还只会一个一个的单独运行测试类，这在实际项目实践中肯定是不可行的。为了解决这个问题，JUnit 提供了一种批量运行测试类的方法，叫做测试套件。这样，每次需要验证系统功能正确性时，只执行一个或几个测试套件便可以了。测试套件的写法非常简单，您只需要遵循以下规则：
  1. 创建一个空类作为测试套件的入口。
  2. 使用注解 org.junit.runner.RunWith 和 org.junit.runners.Suite.SuiteClasses 修饰这个空类。
  3. 将 org.junit.runners.Suite 作为参数传入注解 RunWith，以提示 JUnit 为此类使用套件运行器执行。
  4. 将需要放入此测试套件的测试类组成数组作为注解 SuiteClasses 的参数。
  5. 保证这个空类使用 public 修饰，而且存在公开的不带有任何参数的构造函数。
@RunWith(Suite.class)
@SuiteClasses({TestOld.class,TestNew.class})
publicclass JUnit4Suite {
 
}                          
五、Fixture的强大功能
何谓 Fixture？它是指在执行一个或者多个测试方法时需要的一系列公共资源或者数据，例如测试环境，测试数据等等。在编写单元测试的过程中，您会发现在大部分的测试方法在进行真正的测试之前都需要做大量的铺垫——为设计准备 Fixture 而忙碌。这些铺垫过程占据的代码往往比真正测试的代码多得多，而且这个比率随着测试的复杂程度的增加而递增。当多个测试方法都需要做同样的铺垫时，重复代码的“坏味道”便在测试代码中弥漫开来。这股“坏味道”会弄脏您的代码，还会因为疏忽造成错误，应该使用一些手段来根除它。
"Before"修饰的函数将会在每个测试运行前运行，"After"修饰的函数将在每个测试用例运行后运行。JUnit4.0支持任意数量的 "Before"和"After" Annotation，并且支持继承。"Before"修饰函数的执行顺序为父类的在前，继承类在后，"After"则相反，继承类在前，父类在后。
公共Fixture 的设置也很简单，您只需要：
  1. 使用注解 org,junit.Before 修饰用于初始化 Fixture 的方法。
  2. 使用注解 org.junit.After 修饰用于注销 Fixture 的方法。
  3. 保证这两种方法都使用 public void 修饰，而且不能带有任何参数。
 
"BeforeClass"修饰的函数将会在所有的测试用例运行前运行一次（只运行一次）, "AfterClass"则会在所有的测试用例运行后运行一次（只运行一次）。
类级别的 Fixture 设置方法，编写规范如下：
  1. 使用注解 org,junit.BeforeClass 修饰用于初始化 Fixture 的方法。
  2. 使用注解 org.junit.AfterClass 修饰用于注销 Fixture 的方法。
  3. 保证这两种方法都使用 public static void 修饰，而且不能带有任何参数。
    @Before
    publicvoid beginM(){
       System.out.println("method Before…");
    }
    
    @After
    publicvoid afterM(){
       System.out.println("method after…");
    }
    
    @BeforeClass
    staticpublicvoid beginC(){
       System.out.println("Class Before…");
    }
    
    @AfterClass
    staticpublicvoid afterC(){
       System.out.println("Class after…");
    }
六、数组内容的新断言
添加了一个用于比较数组内容的新断言方法。这并不是什么重大举动，但它的确意味着您将不必再在数组内容间迭代，也不必再断言每个独立条目了。
@Test
public void verifyArrayContents() throws Exception{
 String[] actual = new String[] {"JUnit 3.8.x", "JUnit 4", "TestNG"};
 String[] var = new String[] {"JUnit 3.8.x", "JUnit 4.1", "TestNG 5.5"};
 assertEquals("the two arrays should not be equal", actual, var);           
}
分类: java 标签: 2,554 次阅读
原文链接:http://www.wenhq.com/article/view_94.html
欢迎转载,请注明出处:亲亲宝宝
  1. 本文目前尚无任何评论.
  1. 本文目前尚无任何 trackbacks 和 pingbacks.