JUnit 4 @BeforeClass & Suites @AfterClass lors de l'utilisation
Question
Lorsque vous utilisez cette approche ci-dessous, en mettant en place JUnit avec suites. Nous avons eu le problème lorsque tous les @BeforeClass dans tous les TestClass seront exécutées avant que des tests commence à exécuter. (Pour chaque fichier n TestClass le @BeforeClass court, puis après leur exécution, il a commencé à exécuter les premiers fichiers MyTest.class @test)
Cela entraînera que nous allouons des ressources beaucoup et la mémoire. Mes pensées était qu'il doit se tromper, ne devrait pas chaque @BeforeClass exécuter uniquement avant la testclass réelle est exécutée, pas quand la suite est commencé?
@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
...
La solution
Ecrire une méthode @BeforeClass dans AllTests classe qui sera exécutée lorsque la suite est démarré.
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
Autres conseils
Je ne suis pas trop familier avec @RunWith
dans JUnit, afin que je puisse avoir fait quelque chose de mal, mais je ne peux pas sembler 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 (JUnit par défaut dans Eclipse 3.5.1) sur Sun JDK 1.6.0_12. Pouvez-vous trouver une différence dans mon exemple de la vôtre? Peut-être un autre JDK / JVM? Je ne sais pas assez sur les entrailles de JUnit savoir si ceux-ci peuvent être un facteur.
Je pense que, @BeforeClass
exécute à instanciation.