JUnit 4 @BeforeClass & @AfterClass quando si utilizza Suites
Domanda
Quando si utilizza questo metodo di seguito, impostando il jUnit with suite. Abbiamo ottenuto il problema quando saranno eseguiti tutti @BeforeClass in ogni TestClass prima di ogni test inizia ad eseguire. (Per n ogni file TestClass il @BeforeClass corre, poi, dopo aver eseguito, ha iniziato a eseguire i primi file MyTest.class @Test)
Questo farà sì che noi allocare fino molto le risorse e la memoria. Il mio pensiero era che deve essere sbagliato, non dovrebbe ogni @BeforeClass eseguito solo prima dell'esecuzione del testclass reale, non quando viene avviato il 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
...
Soluzione
Scrivere un metodo @BeforeClass in alltests classe che verrà eseguita quando si avvia 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");
}
}
USCITA
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
Altri suggerimenti
Io non sono troppo familiarità con @RunWith
in JUnit, così che io possa aver fatto qualcosa di sbagliato, ma io 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 cercando in questo modo:
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. Ho 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. Riuscite ad individuare alcuna differenza nel mio esempio dalla tua? Forse un diverso JDK / JVM? Non conosco abbastanza circa la struttura interna di JUnit per sapere se questi possono essere un fattore.
Credo che, @BeforeClass
esegue a instanciation.