JUnit4 中@AfterClass @BeforeClass @after @before的區別對比

逸卿發表於2014-10-22
JUnit4使用Java5中的註解（annotation），以下是JUnit4常用的幾個annotation： 
@Before：初始化方法   對於每一個測試方法都要執行一次（注意與BeforeClass區別，後者是對於所有方法執行一次）
@After：釋放資源  對於每一個測試方法都要執行一次（注意與AfterClass區別，後者是對於所有方法執行一次）
@Test：測試方法，在這裡可以測試期望異常和超時時間 
@Test(expected=ArithmeticException.class)檢查被測方法是否丟擲ArithmeticException異常 
@Ignore：忽略的測試方法 
@BeforeClass：針對所有測試，只執行一次，且必須為static void 
@AfterClass：針對所有測試，只執行一次，且必須為static void 
一個JUnit4的單元測試用例執行順序為： 
@BeforeClass -> @Before -> @Test -> @After -> @AfterClass; 
每一個測試方法的呼叫順序為： 

@Before -> @Test -> @After; 

[java] view plaincopy
  1. public class JUnit4Test {     
  2.     @Before    
  3.     public void before() {     
  4.         System.out.println("@Before");     
  5.     }     
  6.       
  7.     @Test    
  8.          /**   
  9.           *Mark your test cases with @Test annotations.    
  10.           *You don’t need to prefix your test cases with “test”.   
  11.           *tested class does not need to extend from “TestCase” class.   
  12.           */    
  13.     public void test() {     
  14.         System.out.println("@Test");     
  15.         assertEquals(5 + 5, 10);     
  16.     }     
  17.       
  18.     @Ignore    
  19.     @Test    
  20.     public void testIgnore() {     
  21.         System.out.println("@Ignore");     
  22.     }     
  23.       
  24.     @Test(timeout = 50)     
  25.     public void testTimeout() {     
  26.         System.out.println("@Test(timeout = 50)");     
  27.         assertEquals(5 + 5, 10);     
  28.     }     
  29.       
  30.     @Test(expected = ArithmeticException.class)     
  31.     public void testExpected() {     
  32.         System.out.println("@Test(expected = Exception.class)");     
  33.         throw new ArithmeticException();     
  34.     }     
  35.       
  36.     @After    
  37.     public void after() {     
  38.         System.out.println("@After");     
  39.     }     
  40.       
  41.     @BeforeClass    
  42.     public static void beforeClass() {     
  43.         System.out.println("@BeforeClass");     
  44.     };     
  45.       
  46.     @AfterClass    
  47.     public static void afterClass() {     
  48.         System.out.println("@AfterClass");     
  49.     };     
  50. };    

輸出結果： 
@BeforeClass 
@Before 
@Test(timeout = 50) 
@After 
@Before 
@Test(expected = Exception.class) 
@After 
@Before 
@Test 
@After 
@AfterClass 


@BeforeClass and @AfterClass @Before and @After
在一個類中只可以出現一次

在一個類中可以出現多次，即可以在多個方法的宣告前加上這兩個Annotaion標籤，執行順序不確定
方法名不做限制 方法名不做限制
在類中只執行一次 在每個測試方法之前或者之後都會執行一次

@BeforeClass父類中標識了該Annotation的方法將會先於當前類中標識了該Annotation的方法執行。
@AfterClass 父類中標識了該Annotation的方法將會在當前類中標識了該Annotation的方法之後執行

 @Before父類中標識了該Annotation的方法將會先於當前類中標識了該Annotation的方法執行。
 @After父類中標識了該Annotation的方法將會在當前類中標識了該Annotation的方法之後執行
必須宣告為public static 必須宣告為public 並且非static
所有標識為@AfterClass的方法都一定會被執行，即使在標識為@BeforeClass的方法丟擲異常的的情況下也一樣會。 所有標識為@After 的方法都一定會被執行，即使在標識為 @Before 或者 @Test 的方法丟擲異常的的情況下也一樣會。

 

@BeforeClass 和 @AfterClass 對於那些比較“昂貴”的資源的分配或者釋放來說是很有效的，因為他們只會在類中被執行一次。相比之下對於那些需要在每次執行之前都要初始化或者在執行之後 都需要被清理的資源來說使用@Before和@After同樣是一個比較明智的選擇。

相關文章