Hur man använder @Före- och @Efter-anteckningarna i JUnit

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.

hur man laddar ner video från en webbplats

MAKEUSE AV DAGENS VIDEO

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 anteckning körs endast 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

package com.app; 
public class Calculator { 
      public static int add(int num1, int num2) { 
             return num1 + num2; 
      } 
      public static int subtract(int num1, int num2) { 
             return num1 - num2; 
      } 
      public static int multiply(int num1, int num2) { 
             return num1 * num2; 
      } 
      public static int divide(int num1, int num2) { 
             return num1 / num2; 
      } 
}

Klassen CalculatorTest

import static org.junit.jupiter.api.Assertions.*; 
import org.junit.jupiter.api.BeforeAll; 
import org.junit.jupiter.api.Test; 
import org.junit.jupiter.api.DisplayName; 
  
@DisplayName("Test class demonstrating how to use the before and after annotations.") 
class CalculatorTest { 
      @BeforeAll 
      public static void powerOnCalculator() { 
             System.out.println("The calculator is on"); 
      } 
  
      @Test 
      @DisplayName("Testing method that adds two integer values.") 
      public void testAdd() { 
             assertEquals(7, Calculator.add(3, 4)); 
      }      
  
      @Test 
      @DisplayName("Testing method that subtracts one integer value from another.") 
      public void testSubtract() { 
             assertEquals(6, Calculator.subtract(9, 3)); 
      } 
  
      @Test 
      @DisplayName("Testing method that multiplies two integer values") 
      public void testMultiply() { 
             assertEquals(10, Calculator.multiply(5, 2)); 
      } 
  
      @Test 
      @DisplayName("Testing method that divides one integer value by another") 
      public void testDivide() { 
             assertEquals(2, Calculator.divide(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.

import static org.junit.jupiter.api.Assertions.*; 
import org.junit.jupiter.api.BeforeAll; 
import org.junit.jupiter.api.BeforeEach; 
import org.junit.jupiter.api.Test; 
@DisplayName("Test class demonstrating how to use the before and after annotations.") 
class CalculatorTest { 
      @BeforeAll 
      public static void powerOnCalculator() { 
             System.out.println("The calculator is on"); 
      } 
      @BeforeEach 
      public void clearCalculator() { 
             System.out.println("The calculator is ready"); 
      } 
      @Test 
      @DisplayName("Testing method that adds two integer values.") 
      public void testAdd() { 
             assertEquals(7, Calculator.add(3, 4)); 
      }      
      @Test 
      @DisplayName("Testing method that subtracts one integer value from another.") 
      public void testSubtract() { 
             assertEquals(6, Calculator.subtract(9, 3)); 
      } 
      @Test 
      @DisplayName("Testing method that multiplies two integer values") 
      public void testMultiply() { 
             assertEquals(10, Calculator.multiply(5, 2)); 
      } 
      @Test 
      @DisplayName("Testing method that divides one integer value by another") 
      public void testDivide() { 
             assertEquals(2, Calculator.divide(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.

@AfterAll 
public static void powerOffCalculator() { 
    System.out.println("The calculator is off"); 
}

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.

hur man tar bort en tiktok -video

@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 
public void returnResults() { 
    System.out.println("The results are ready"); 
}

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.