Différence entre @Before, @BeforeClass, @BeforeEach et @BeforeAll

Question

Quelle est la principale différence entre

• @Before et @BeforeClass
  • et dans JUnit 5 @BeforeEach et @BeforeAll
• @After et @AfterClass

Selon le JUnit Api@Before est utilisé dans le cas suivant:

Lors de l'écriture de tests, il est courant de constater que plusieurs tests nécessitent la création d'objets similaires avant leur exécution.

Alors que @BeforeClass peut être utilisé pour établir une connexion à une base de données. Mais @Before ne pourrait-il pas en faire autant?

Answer 1

Le code marqué @Before est exécuté avant chaque test, tandis que @BeforeClass est exécuté une fois avant le montage de test complet. Si votre classe de test comporte dix tests, le code @Before sera exécuté dix fois, mais @BeforeClass ne sera exécuté qu'une seule fois.

En général, vous utilisez @BeforeClass lorsque plusieurs tests doivent partager le même code d'installation coûteux en calculs. L'établissement d'une connexion à une base de données entre dans cette catégorie. Vous pouvez déplacer le code de @BeforeClass dans @Before, mais la durée de votre test peut être plus longue. Notez que le code marqué @BeforeClass est exécuté en tant qu'initialiseur statique. Il sera donc exécuté avant la création de l'instance de classe de votre appareil de test.

Dans JUnit 5 , les balises @BeforeEach et @BeforeAll sont les équivalents de @Before et @BeforeClass dans JUnit 4. Leurs noms sont un peu plus indicatifs quand ils fonctionnent, interprétés vaguement: "avant chaque test" et "une fois avant tous les tests".

Answer 2

Les différences entre chaque annotation sont les suivantes:

+-------------------------------------------------------------------------------------------------------+
¦                                       Feature                            ¦   Junit 4    ¦   Junit 5   ¦
¦--------------------------------------------------------------------------+--------------+-------------¦
¦ Execute before all test methods of the class are executed.               ¦ @BeforeClass ¦ @BeforeAll  ¦
¦ Used with static method.                                                 ¦              ¦             ¦
¦ For example, This method could contain some initialization code          ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Execute after all test methods in the current class.                     ¦ @AfterClass  ¦ @AfterAll   ¦
¦ Used with static method.                                                 ¦              ¦             ¦
¦ For example, This method could contain some cleanup code.                ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Execute before each test method.                                         ¦ @Before      ¦ @BeforeEach ¦
¦ Used with non-static method.                                             ¦              ¦             ¦
¦ For example, to reinitialize some class attributes used by the methods.  ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Execute after each test method.                                          ¦ @After       ¦ @AfterEach  ¦
¦ Used with non-static method.                                             ¦              ¦             ¦
¦ For example, to roll back database modifications.                        ¦              ¦             ¦
+-------------------------------------------------------------------------------------------------------+

La plupart des annotations dans les deux versions sont identiques, mais peu diffèrent.

référence

Ordre d'exécution.

Zone pointillée -> annotation facultative.

Answer 3

Before et BeforeClass dans JUnit

L'annotation de fonction @Before sera exécutée avant chacune des fonctions de test de la classe portant l'annotation @Test, mais la fonction avec @BeforeClass ne sera exécutée qu'une fois avant toutes les fonctions de test de la classe.

Une fonction similaire avec l'annotation @After sera exécutée après chacune des fonctions de test de la classe portant l'annotation @Test, mais la fonction avec @AfterClass ne sera exécutée qu'une fois après toutes les fonctions de test de la classe. .

SampleClass

public class SampleClass {
    public String initializeData(){
        return "Initialize";
    }

    public String processDate(){
        return "Process";
    }
 }

SampleTest

public class SampleTest {

    private SampleClass sampleClass;

    @BeforeClass
    public static void beforeClassFunction(){
        System.out.println("Before Class");
    }

    @Before
    public void beforeFunction(){
        sampleClass=new SampleClass();
        System.out.println("Before Function");
    }

    @After
    public void afterFunction(){
        System.out.println("After Function");
    }

    @AfterClass
    public static void afterClassFunction(){
        System.out.println("After Class");
    }

    @Test
    public void initializeTest(){
        Assert.assertEquals("Initailization check", "Initialize", sampleClass.initializeData() );
    }

    @Test
    public void processTest(){
        Assert.assertEquals("Process check", "Process", sampleClass.processDate() );
    }

}

sortie

Before Class
Before Function
After Function
Before Function
After Function
After Class

In Junit 5

@Before = @BeforeEach
@BeforeClass = @BeforeAll
@After = @AfterEach
@AfterClass = @AfterAll

Answer 4

import org.junit.Assert
import org.junit.Before
import org.junit.BeforeClass
import org.junit.Test

class FeatureTest {
    companion object {
        private lateinit var heavyFeature: HeavyFeature
        @BeforeClass
        @JvmStatic
        fun beforeHeavy() {
            heavyFeature = HeavyFeature()
        }
    }

    private lateinit var feature: Feature

    @Before
    fun before() {
        feature = Feature()
    }

    @Test
    fun testCool() {
        Assert.assertTrue(heavyFeature.cool())
        Assert.assertTrue(feature.cool())
    }

    @Test
    fun testWow() {
        Assert.assertTrue(heavyFeature.wow())
        Assert.assertTrue(feature.wow())
    }
}

Pareil que

import org.junit.Assert
import org.junit.Test

 class FeatureTest {
    companion object {
        private val heavyFeature = HeavyFeature()
    }

    private val feature = Feature()

    @Test
    fun testCool() {
        Assert.assertTrue(heavyFeature.cool())
        Assert.assertTrue(feature.cool())
    }

    @Test
    fun testWow() {
        Assert.assertTrue(heavyFeature.wow())
        Assert.assertTrue(feature.wow())
    }
}