web-dev-qa-db-fra.com

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

Lorsque vous utilisez cette approche ci-dessous, en configurant jUnit with Suites. Nous avons eu le problème lorsque tous les @BeforeClass dans chaque Testclass seront exécutés avant que les tests ne commencent à s'exécuter. (Pour chaque fichier n TestClass, la @BeforeClass s'exécute, puis après leur exécution, elle a commencé à exécuter les premiers fichiers MyTest.class @Test)

Cela entraînera que nous allouons beaucoup de ressources et de mémoire. Je pensais que cela devait être faux, chaque @BeforeClass ne devrait-il pas s'exécuter uniquement avant l'exécution de la classe de test proprement dite, pas au 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
        ...
javajunitjunit4
29
Andreas Mattisson

Écrivez 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

50
nayakam

Je ne connais pas trop @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 ressemblant à 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 les mêmes. J'obtiens 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

C'est avec JUnit 4.5.0 (JUnit par défaut dans Eclipse 3.5.1) sur le JDK 1.6.0_12 de Sun. Pouvez-vous repérer une différence dans mon exemple du vôtre? Peut-être un autre JDK/JVM? Je ne connais pas suffisamment les éléments internes de JUnit pour savoir si ceux-ci peuvent être un facteur.

1
Grundlefleck