När du skriver en enhetstestsvit kan det finnas vissa icke-testrelaterade aktiviteter som du behöver utföra. Dessa aktiviteter kan ha vilken form som helst. Du kan behöva ansluta till en databas eller samla resurser innan du utför ett test. Efter att varje testfall har körts kan du behöva frigöra några resurser.
Att utföra någon av dessa icke-testrelaterade aktiviteter utanför omfattningen av en enhetstestklass kan vara tråkigt om inte omöjligt. Det framgångsrika utförandet av din testklass kan bero på dessa aktiviteter, så JUnit tillhandahåller två par kommentarer för att lösa detta problem.
@BeforeAll-kommentaren
En JUnit-testklass kan ha en eller flera testmetoder. @BeforeAll-anteckningen signalerar att en specifik metod ska köras före alla testmetoder i en testklass. Metoden som är associerad med denna annotering körs bara en gång (i början av testet) oavsett antalet testmetoder i testklassen.
Alla metoder som använder @BeforeAll-kommentaren måste följa några bestämmelser. Dessa metoder måste ha en ogiltig returtyp, måste vara offentliga och får inte vara privata. @BeforeAll-kommentaren är idealisk för att upprätta en
anslutning till en databas eller skapa en ny fil. Den här artikeln använder en kalkylatortestklass för att visa hur du kan använda @BeforeAll-kommentaren.Kalkylatorklassen
paket com.app;
offentligklassKalkylator{
offentligstatiskintLägg till(int nummer1, int num2){
lämna tillbaka num1 + num2;
}
offentligstatiskintsubtrahera(int nummer1, int num2){
lämna tillbaka num1 - num2;
}
offentligstatiskintmultiplicera(int nummer1, int num2){
lämna tillbaka num1 * num2;
}
offentligstatiskintdela upp(int nummer1, int num2){
lämna tillbaka num1 / num2;
}
}Klassen CalculatorTest
importerastatiskorg.junit.Jupiter.api.Påståenden.*;
importeraorg.junit.Jupiter.api.InnanAlla;
importeraorg.junit.Jupiter.api.Testa;
importeraorg.junit.Jupiter.api.Visningsnamn;@DisplayName("Testklass som visar hur man använda sig av de innanochefter anteckningar.")
klassKalkylatorTest{
@BeforeAll
offentligstatisktomhetpowerOnCalculator(){
System.out.println("Kalkylatorn är på");
}@Testa
@DisplayName("Testmetod som lägger till två heltalsvärden.")
offentligtomhettestLägg till(){
assertEquals(7, Kalkylator.Lägg till(3, 4));
}@Testa
@DisplayName("Testmetod som subtraherar ett heltalsvärde från ett annat.")
offentligtomhettest Subtrahera(){
assertEquals(6, Kalkylator.subtrahera(9, 3));
}@Testa
@DisplayName("Testmetod som multiplicerar två heltalsvärden")
offentligtomhettestMultiplicera(){
assertEquals(10, Kalkylator.multiplicera(5, 2));
}
@Testa
@DisplayName("Testmetod som delar ett heltalsvärde med ett annat")
offentligtomhettestDela(){
assertEquals(2, Kalkylator.dela upp(4, 2));
}
}
I den här klassen fungerar @BeforeAll-kommentaren med metoden powerOnCalculator() som skriver ut "Kalkylatorn är på" innan någon testkörning. Den framgångsrika testkörningen skriver ut följande testrapport:
Som du kan se visas inte metoden förknippad med @BeforeAll-kommentaren i testrapporten. Men om det finns ett fel i @BeforeAll-anteckningsmetoden kommer testrapportresultaten att indikera detta med ett misslyckande.
@BeforeEach-anteckningen
Liksom @BeforeAll-kommentarmetoden kommer @BeforeEach-kommentarmetoden inte att visas i testrapporten. Den annoterade @BeforeEach-metoden körs före varje testmetod i en testklass. Så, om en testklass innehåller två testmetoder, kommer @BeforeEach-kommentaren att köras två gånger.
importerastatiskorg.junit.Jupiter.api.Påståenden.*;
importeraorg.junit.Jupiter.api.InnanAlla;
importeraorg.junit.Jupiter.api.Innan varje;
importeraorg.junit.Jupiter.api.Testa;
@DisplayName("Testklass som visar hur man använda sig av de innanochefter anteckningar.")
klassKalkylatorTest{
@BeforeAll
offentligstatisktomhetpowerOnCalculator(){
System.out.println("Kalkylatorn är på");
}
@BeforeEach
offentligtomhetclearCalculator(){
System.out.println("Kalkylatorn är klar");
}
@Testa
@DisplayName("Testmetod som lägger till två heltalsvärden.")
offentligtomhettestLägg till(){
assertEquals(7, Kalkylator.Lägg till(3, 4));
}
@Testa
@DisplayName("Testmetod som subtraherar ett heltalsvärde från ett annat.")
offentligtomhettest Subtrahera(){
assertEquals(6, Kalkylator.subtrahera(9, 3));
}
@Testa
@DisplayName("Testmetod som multiplicerar två heltalsvärden")
offentligtomhettestMultiplicera(){
assertEquals(10, Kalkylator.multiplicera(5, 2));
}
@Testa
@DisplayName("Testmetod som delar ett heltalsvärde med ett annat")
offentligtomhettestDela(){
assertEquals(2, Kalkylator.dela upp(4, 2));
}
}
Om du lägger till @BeforeEach-anteckningen i klassen CalculatorTest får du följande utdata:
Metoden som är kopplad till @BeforeEach-kommentaren körs fyra gånger, en gång före varje testmetod. Du bör notera att @BeforeEach-metoden inte är statisk, har en ogiltig returtyp och inte är privat, eftersom dessa är obligatoriska bestämmelser. Det är också viktigt att notera att metoden som är kopplad till @BeforeEach-kommentaren körs efter @BeforeAll-metoden.
@AfterAll-kommentaren
En metod med @AfterAll-anteckningen kommer att köras efter att alla testmetoder i testklassen slutfört sin exekvering. @AfterAll-kommentaren är idealisk för grundläggande filoperationer, som att stänga en fil eller koppla från en databas. @AfterAll-kommentaren är motsvarigheten till @BeforeAll-kommentaren. Liksom @BeforeAll-kommentaren måste @AfterAll-kommentaren vara statisk, måste returnera ogiltig och mycket inte vara privat.
@Trots allt
offentligstatisktomhetpowerOffCalculator(){
System.out.println("Kalkylatorn är avstängd");
}Genom att lägga till den kommenterade @AfterAll-metoden i den befintliga CalculatorTest-klassen skrivs följande ut till konsolen:
Observera att metoden powerOffCalculator(), som använder @AfterAll-kommentaren, skrivs ut i slutet av testklassen, efter att alla testmetoder har körts.
@AfterEach-kommentaren
@AfterEach-kommentaren är motsvarigheten till @BeforeEach-kommentaren. De har samma obligatoriska bestämmelser, som skiljer sig något från annoteringarna @BeforeAll och @AfterAll. Det som skiljer @AfterEach-kommentaren från @BeforeEach-kommentaren (annat än deras namn) är att @AfterEach-metoden körs efter varje testmetod.
@AfterEach
offentligtomhetreturnResults(){
System.out.println("Resultaten är klara");
}Genom att köra klassen CalculatorTest skrivs följande ut till konsolen:
Utdata visar att metoden som är associerad med @AfterEach-kommentaren (returnResults) skrivs ut fyra gånger. Varje körning av metoden returnResults() sker endast efter körningen av varje enhetstest. Detta framgår av det faktum att returnResults()-metodens utdata visas efter varje utdata från metoden som är associerad med @BeforeEach-kommentaren.
Polera dina testsviter med anteckningar
JUnit låter dig hantera icke-testrelaterade processer med hjälp av annoteringarna före och efter paret. Dessa fyra anteckningar tillhör en lista med flera andra annoteringar som tillför värde till dina tester. En annan av JUnits kommentarer är @DisplayName.
De två kodexemplen som visar hela CalculatorTest-klassen använder @DisplayName-kommentaren. @DisplayName-kommentaren hjälper dig att skapa mer meningsfulla namn för dina testklasser och testmetoder.
