514 Stimmen

Unterschied zwischen @Before, @BeforeClass, @BeforeEach und @BeforeAll

Was ist der Hauptunterschied zwischen

  • @Before und @BeforeClass
    • und in JUnit 5 @BeforeEach und @BeforeAll
  • @After und @AfterClass

Laut der JUnit Api wird @Before in folgendem Fall verwendet:

Wenn Tests geschrieben werden, ist es üblich festzustellen, dass mehrere Tests ähnliche Objekte benötigen, die erstellt werden müssen, bevor sie ausgeführt werden können.

Während @BeforeClass zur Herstellung einer Datenbankverbindung verwendet werden kann. Aber könnte nicht auch @Before dasselbe tun?

743voto

Sergey Kalinichenko Punkte 694383

Der Code, der mit @Before markiert ist, wird vor jedem Test ausgeführt, während @BeforeClass einmal vor dem gesamten Testgehäuse ausgeführt wird. Wenn Ihre Testklasse zehn Tests hat, wird der @Before-Code zehnmal ausgeführt, während @BeforeClass nur einmal ausgeführt wird.

Im Allgemeinen verwenden Sie @BeforeClass, wenn mehrere Tests den gleichen aufwändigen Einrichtungscode teilen müssen. Das Herstellen einer Datenbankverbindung fällt in diese Kategorie. Sie können den Code von @BeforeClass in @Before verschieben, aber Ihr Testlauf kann länger dauern. Beachten Sie, dass der mit @BeforeClass markierte Code als statischer Initialisierer ausgeführt wird, daher wird er ausgeführt, bevor die Klasseninstanz Ihrer Testeinrichtung erstellt wird.

In JUnit 5 sind die Tags @BeforeEach und @BeforeAll die Äquivalente von @Before und @BeforeClass in JUnit 4. Ihre Namen sind etwas aussagekräftiger darüber, wann sie ausgeführt werden, grob interpretiert: 'vor jedem Test' und 'einmal vor allen Tests'.

171voto

Unterschiede zwischen jeder Annotation sind:

+-------------------------------------------------------------------------------------------------------+
¦                                       Funktionality                       ¦   Junit 4    ¦   Junit 5   ¦
¦--------------------------------------------------------------------------+--------------+-------------¦
¦ Führen Sie vor dem Ausführen aller Testmethoden der Klasse aus.            ¦ @BeforeClass ¦ @BeforeAll  ¦
¦ Verwendet mit statischer Methode.                                         ¦              ¦             ¦
¦ Zum Beispiel könnte diese Methode einige Initialisierungscode enthalten.  ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Führen Sie nach dem Ausführen aller Testmethoden in der aktuellen Klasse aus.¦ @AfterClass ¦ @AfterAll   ¦
¦ Verwendet mit statischer Methode.                                         ¦              ¦             ¦
¦ Zum Beispiel könnte diese Methode einige Aufräumarbeiten enthalten.      ¦              ¦             ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Führen Sie vor jedem Testverfahren aus.                                    ¦ @Before      ¦ @BeforeEach ¦
¦ Verwendet mit nicht-statischer Methode.                                   ¦              ¦             ¦
¦ Beispielsweise zur Neuinitialisierung einiger Klassenattribute, die von den Methoden verwendet werden.¦              ¦      ¦
¦-------------------------------------------------------------------------------------------------------¦
¦ Führen Sie nach jedem Testverfahren aus.                                   ¦ @After       ¦ @AfterEach  ¦
¦ Verwendet mit nicht-statischer Methode.                                   ¦              ¦             ¦
¦ Zum Beispiel zum Rollback von Datenbankänderungen.                        ¦              ¦             ¦
+-------------------------------------------------------------------------------------------------------+

Die meisten Annotationen in beiden Versionen sind gleich, aber einige unterscheiden sich.

Referenz

Ausführungsreihenfolge.

Gestrichenes Feld -> optionale Annotation.

Geben Sie hier eine Bildbeschreibung ein

18voto

Dhyan Mohandas Punkte 986

Vor und BeforeClass in JUnit

Die Funktion @Before-Annotation wird vor jeder Testfunktion in der Klasse ausgeführt, die die @Test-Annotation hat, ausgeführt, aber die Funktion mit @BeforeClass wird nur einmal vor allen Testfunktionen in der Klasse ausgeführt.

Ebenso wird die Funktion mit der @After-Annotation nach jeder Testfunktion in der Klasse ausgeführt, die die @Test-Annotation hat, aber die Funktion mit der @AfterClass-Annotation wird nur einmal nach allen Testfunktionen in der Klasse ausgeführt.

SampleClass

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

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

SampleTest

public class SampleTest {

    private SampleClass sampleClass;

    @BeforeClass
    public static void beforeClassFunction(){
        System.out.println("Vor der Klasse");
    }

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

    @After
    public void afterFunction(){
        System.out.println("Nach der Funktion");
    }

    @AfterClass
    public static void afterClassFunction(){
        System.out.println("Nach der Klasse");
    }

    @Test
    public void initializeTest(){
        Assert.assertEquals("Initialisierung überprüfen", "Initialisieren", sampleClass.initializeData() );
    }

    @Test
    public void processTest(){
        Assert.assertEquals("Verarbeitungsüberprüfung", "Verarbeiten", sampleClass.processDate() );
    }

}

Ausgabe

Vor der Klasse
Vor der Funktion
Nach der Funktion
Vor der Funktion
Nach der Funktion
Nach der Klasse

In Junit 5

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

10voto

yoAlex5 Punkte 20661

JUnit @BeforeEach, @AfterEach, @BeforeAll, @AfterAll

@Before(JUnit4) -> @BeforeEach(JUnit5) - Methode wird vor jedem Test aufgerufen

@After(JUnit4) -> @AfterEach(JUnit5) - Methode wird nach jedem Test aufgerufen

@BeforeClass(JUnit4) -> @BeforeAll(JUnit5) - statische Methode wird vor der Ausführung aller Tests in dieser Klasse aufgerufen. Es kann eine große Aufgabe sein, wie das Starten eines Servers, das Lesen einer Datei, das Herstellen einer DB-Verbindung...

@AfterClass(JUnit4) -> @AfterAll(JUnit5) - statische Methode wird nach der Ausführung aller Tests in dieser Klasse aufgerufen.

2voto

kreker Punkte 5697
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())
    }
}

Gleich wie

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())
    }
}

CodeJaeger.com

CodeJaeger ist eine Gemeinschaft für Programmierer, die täglich Hilfe erhalten..
Wir haben viele Inhalte, und Sie können auch Ihre eigenen Fragen stellen oder die Fragen anderer Leute lösen.

Powered by:

X