JUnit 4 @BeforeClass e @AfterClass quando si utilizza Suites

Question

Quando si utilizza questo approccio di seguito, configurando jUnit con Suites. Abbiamo il problema quando tutti i @BeforeClass in ogni TestClass verranno eseguiti prima che inizino a essere eseguiti i test. (Per ogni n file TestClass viene eseguito @BeforeClass, dopo aver eseguito, ha iniziato a eseguire i primi file MyTest.class @Test)

Ciò causerà l'allocazione di molte risorse e memoria. La mia opinione è che deve essere sbagliato, non dovrebbe ogni @BeforeClass eseguire solo prima dell'esecuzione effettiva del testclass, non quando viene avviata la Suite?

@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

Scrivere un metodo @BeforeClass nella classe AllTests che verrà eseguito all'avvio della suite.

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

credo, @BeforeClass esegue a instanciation.

Answer 3

Non ho molta familiarità con @RunWith in JUnit, quindi potrei aver fatto qualcosa di sbagliato, ma non riesco a replicare il comportamento che descrivi. Con la classe:

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

E FirstTest.java simile a questo:

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

... con SecondTest.java e ThirdTest.java praticamente la stessa. Ottengo l'uscita di test:

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

Questo è con JUnit (JUnit predefinita in Eclipse 3.5.1) 4.5.0 su Sun JDK 1.6.0_12. Puoi notare qualche differenza nel mio esempio dal tuo? Forse un JDK/JVM diverso? Non ne so abbastanza degli interni di JUnit per sapere se questi possono essere un fattore.