Junit 4 @beForeclass & @afterClass bei Verwendung von Suiten
Frage
Wenn Sie diesen Ansatz unten verwenden, stellen Sie den Junit mit Suiten ein. Wir haben das Problem bekommen, wenn alle @beForeclass in jeder Testklasse ausgeführt werden, bevor Tests ausgeführt werden. (Für jede N -Test -Class -Datei, die @BeForeClass ausgeführt wird, wird nach ihrer Ausführung die erste myTest.class -Dateien @test ausgeführt.)
Dies führt dazu, dass wir viele Ressourcen und Erinnerungen aufbauen. Meine Gedanken waren, dass es falsch sein muss, sollte nicht jeder @Beforeclass erst vor der Ausführung der tatsächlichen Testklasse ausgeführt werden, nicht wenn die Suite gestartet wird?
@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
...
Lösung
Schreiben Sie eine @BeForeClass -Methode in der Alltests -Klasse, die beim Start der Suite ausgeführt wird.
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");
}
}
AUSGANG
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
Andere Tipps
Ich bin nicht allzu vertraut mit @RunWith
In Junit, also habe ich vielleicht etwas falsch gemacht, aber ich kann das von Ihnen beschriebene Verhalten nicht wiederholen. Mit der Klasse:
@RunWith(Suite.class)
@Suite.SuiteClasses( { FirstTest.class, SecondTest.class, ThirdTest.class })
public class AllTests {
// empty
}
Und Firsttest.java sieht so aus:
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());
}
}
... mit Secondtest.java und ThirdTest.java ziemlich gleich. Ich bekomme die Testausgabe:
Running @BeforeClass for FirstTest
Running @Test in FirstTest
Running @BeforeClass for SecondTest
Running @Test in SecondTest
Running @BeforeClass for ThirdTest
Running @Test in ThirdTest
Dies ist mit JUNIT 4.5.0 (Standard Junit in Eclipse 3.5.1) auf Suns JDK 1.6.0_12. Können Sie einen Unterschied in meinem Beispiel von Ihrem erkennen? Vielleicht ein anderer JDK/JVM? Ich weiß nicht genug über die Interna von Junit, um zu wissen, ob dies ein Faktor sein kann.
Ich finde, @BeforeClass
führt im Instanziieren aus.