JUnit 4 @BeforeClass & @AfterClass lors de l'utilisation des suites

Question

Lorsque vous utilisez cette méthode ci-dessous, configurez jUnit avec Suites. Nous avons eu le problème quand tout @BeforeClass dans chaque Testclass sera exécuté avant que les tests commencent à s'exécuter. (Pour chaque n fichier TestClass, @BeforeClass s'exécute, puis après exécution, il commence à exécuter les premiers fichiers MyTest.class @Test)

Cela entraîne l'allocation de beaucoup de ressources et de mémoire. Je pensais que cela devait être faux, chaque @BeforeClass ne devrait-elle pas être exécutée avant l'exécution de la classe de test, et non lors du démarrage de 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

Ecrivez une méthode @BeforeClass dans la classe AllTests qui sera exécutée au démarrage de la 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"); 
    } 

} 

SORTIE

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

Je pense que @BeforeClass s'exécute à l'instanciation.

Answer 3

Je ne suis pas trop familier avec @RunWith dans JUnit, donc j'ai peut-être fait quelque chose de mal, mais je n'arrive pas à reproduire le comportement que vous décrivez. Avec la classe:

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

Et FirstTest.java qui ressemble à ceci:

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

... avec SecondTest.java et ThirdTest.java à peu près la même chose. Je reçois la sortie de 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 

est avec JUnit 4.5.0 (par défaut JUnit dans Eclipse 3.5.1) sur Sun JDK 1.6.0_12. Pouvez-vous repérer une différence dans mon exemple par rapport à la vôtre? Peut-être un JDK/JVM différent? Je ne connais pas assez les internes de JUnit pour savoir si cela peut être un facteur.