JUnit 4 @BeforeClass & @AfterClass khi sử dụng Suites

Question

Khi sử dụng phương pháp này bên dưới, bằng cách thiết lập jUnit with Suites. Chúng tôi đã gặp sự cố khi tất cả @BeforeClass trong mọi Lớp kiểm tra sẽ được thực thi trước khi bất kỳ thử nghiệm nào bắt đầu thực thi. (Đối với mỗi tệp TestClass của @BeforeClass chạy, sau khi chúng đã thực thi, nó bắt đầu thực thi tệp MyTest.class đầu tiên @Test)

Điều này sẽ khiến chúng tôi phân bổ nhiều tài nguyên và bộ nhớ. Suy nghĩ của tôi là nó phải sai, không phải mỗi @BeforeClass chỉ chạy trước khi lớp thi thực tế được thực hiện, không phải khi Suite được bắt đầu?

@RunWith(Suite.class) 
@Suite.SuiteClasses({ MyTests.class, Mytests2.class, n1, n2, n }) 
public class AllTests { 
    // empty 
} 


public class MyTests { // no extends here 
    @BeforeClass 
    public static void setUpOnce() throws InterruptedException { 
     ... 
    @Test 
     ... 

public class MyTests2 { // no extends here 
    @BeforeClass 
    public static void setUpOnce() throws InterruptedException { 
     ... 
    @Test 
     ... 

Answer 1

Viết phương thức @BeforeClass trong lớp AllTests sẽ được thực hiện khi bộ phần mềm được bắt đầu.

public class MyTests1 { 
    @BeforeClass 
    public static void beforeClass() { 
     System.out.println("MyTests1.beforeClass"); 
    } 

    @Before 
    public void before() { 
     System.out.println("MyTests1.before"); 
    } 

    @AfterClass 
    public static void afterClass() { 
     System.out.println("MyTests1.AfterClass"); 
    } 

    @After 
    public void after() { 
     System.out.println("MyTests1.after"); 
    } 

    @Test 
    public void test1() { 
     System.out.println("MyTests1.test1"); 
    } 

    @Test 
    public void test2() { 
     System.out.println("MyTests1.test2"); 
    } 
} 



public class MyTests2 { 
    @BeforeClass 
    public static void beforeClass() { 
     System.out.println("MyTests2.beforeClass"); 
    } 

    @Before 
    public void before() { 
     System.out.println("MyTests2.before"); 
    } 

    @AfterClass 
    public static void afterClass() { 
     System.out.println("MyTests2.AfterClass"); 
    } 

    @After 
    public void after() { 
     System.out.println("MyTests2.after"); 
    } 

    @Test 
    public void test1() { 
     System.out.println("MyTests2.test1"); 
    } 

    @Test 
    public void test2() { 
     System.out.println("MyTests2.test2"); 
    } 
} 




@RunWith(Suite.class) 
@Suite.SuiteClasses({ MyTests1.class, MyTests2.class }) 
public class AllTests { 

    @BeforeClass 
    public static void beforeClass() { 
     System.out.println("AllTests.beforeClass"); 
    } 

    @Before 
    public void before() { 
     System.out.println("AllTests.before"); 
    } 

    @AfterClass 
    public static void afterClass() { 
     System.out.println("AllTests.AfterClass"); 
    } 

    @After 
    public void after() { 
     System.out.println("AllTests.after"); 
    } 

    @Test 
    public void test1() { 
     System.out.println("AllTests.test1"); 
    } 

    @Test 
    public void test2() { 
     System.out.println("AllTests.test2"); 
    } 

} 

OUTPUT

AllTests.beforeClass 
MyTests1.beforeClass 
MyTests1.before 
MyTests1.test1 
MyTests1.after 
MyTests1.before 
MyTests1.test2 
MyTests1.after 
MyTests1.AfterClass 
MyTests2.beforeClass 
MyTests2.before 
MyTests2.test1 
MyTests2.after 
MyTests2.before 
MyTests2.test2 
MyTests2.after 
MyTests2.AfterClass 
AllTests.AfterClass 

hth

Answer 2

Tôi nghĩ, @BeforeClass thực hiện tại instanciation.

Answer 3

Tôi không quá quen thuộc với @RunWith trong JUnit, vì vậy tôi có thể đã làm điều gì đó sai, nhưng tôi dường như không thể tái tạo hành vi mà bạn mô tả. Với lớp:

@RunWith(Suite.class) 
@Suite.SuiteClasses({ FirstTest.class, SecondTest.class, ThirdTest.class }) 
public class AllTests { 
    // empty 
} 

Và FirstTest.java tìm kiếm như thế này:

public class FirstTest { 
    @BeforeClass 
    public static void doBeforeClass() { 
     System.out.println("Running @BeforeClass for FirstTest"); 
    } 

    @Test 
    public void doTest() { 
     System.out.println("Running @Test in " + getClass().getName()); 
    } 
} 

... với SecondTest.java và ThirdTest.java khá nhiều giống nhau. Tôi nhận được kết quả thử nghiệm:

Running @BeforeClass for FirstTest 
Running @Test in FirstTest 
Running @BeforeClass for SecondTest 
Running @Test in SecondTest 
Running @BeforeClass for ThirdTest 
Running @Test in ThirdTest 

Đây là với JUnit 4.5.0 (mặc định JUnit trong Eclipse 3.5.1) trên JDK 1.6.0_12 của Sun. Bạn có thể nhận ra bất kỳ sự khác biệt nào trong ví dụ của tôi từ bạn không? Có lẽ một JDK/JVM khác nhau? Tôi không biết đủ về nội bộ của JUnit để biết liệu đây có phải là một yếu tố hay không.