Sådan bruger du @Før og @Efter annoteringer i JUnit

Når du skriver en enhedstestpakke, kan der være nogle ikke-testrelaterede aktiviteter, du skal udføre. Disse aktiviteter kan antage enhver form. Du skal muligvis oprette forbindelse til en database eller samle ressourcer, før du udfører en test. Efter hver testcase er udført, skal du muligvis frigive nogle ressourcer.

MAKEUSE AF DAGENS VIDEO

At udføre nogen af disse ikke-testrelaterede aktiviteter uden for rammerne af en enhedstestklasse kan være kedeligt, hvis ikke umuligt. Den vellykkede udførelse af din testklasse kan afhænge af disse aktiviteter, så JUnit giver to par anmærkninger til at løse dette problem.

@BeforeAll-annotationen

En JUnit-testklasse kan have en eller flere testmetoder. @BeforeAll-annotationen signalerer, at en specifik metode skal udføres før alle testmetoderne i en testklasse. Metoden forbundet med denne annotation udføres kun én gang (ved starten af testen) uanset antallet af testmetoder i testklassen.

Enhver metode, der bruger @BeforeAll-annotationen, skal følge nogle få bestemmelser. Disse metoder skal have en ugyldig returtype, skal være offentlige og må ikke være private. @BeforeAll-annotationen er ideel til at etablere en forbindelse til en database eller oprette en ny fil. Denne artikel bruger en lommeregnertestklasse til at vise, hvordan du kan bruge @BeforeAll-annotationen.

Lommeregner-klassen

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; 
      } 
}

CalculatorTest-klassen

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 denne klasse fungerer @BeforeAll-annotationen med powerOnCalculator()-metoden, som udskriver 'Lommeregneren er tændt' før enhver testkørsel. Den vellykkede testudførelse udskriver følgende testrapport:

Som du kan se, vises metoden forbundet med @BeforeAll-annotationen ikke i testrapporten. Men hvis der er en fejl i @BeforeAll annotationsmetoden, vil testrapportens resultater angive dette med en fejl.

hvor kan jeg udskrive dokumenter fra min e -mail

@BeforeEach-annotationen

Ligesom @BeforeAll annoterede metode, vil @BeforeEach annoterede metode ikke vises i testrapporten. @BeforeEach annoterede metode udføres før hver testmetode i en testklasse. Så hvis en testklasse indeholder to testmetoder, vil @BeforeEach-annotationen udføres to gange.

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

Tilføjelse af @BeforeEach-annotationen til CalculatorTest-klassen producerer følgende output:

Metoden, der er knyttet til @BeforeEach-annotationen, udføres fire gange, én gang før hver testmetode. Du skal bemærke, at @BeforeEach-metoden ikke er statisk, har en ugyldig returtype og ikke er privat, da disse er obligatoriske betingelser. Det er også vigtigt at bemærke, at den metode, der er knyttet til @BeforeEach-annotationen, kører efter @BeforeAll-metoden.

@AfterAll-annotationen

En metode med @AfterAll-annotationen udføres, når alle testmetoderne i testklassen har fuldført deres udførelse. @AfterAll-annotationen er ideel til grundlæggende filhandlinger , som at lukke en fil eller afbryde forbindelsen til en database. @AfterAll-annotationen er modstykket til @BeforeAll-annoteringen. Ligesom @BeforeAll-annotationen skal @AfterAll-annotationen være statisk, skal returnere ugyldig og meget ikke være privat.

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

Tilføjelse af @AfterAll-annoterede metode til den eksisterende CalculatorTest-klasse udskriver følgende output til konsollen:

Bemærk, at powerOffCalculator()-metoden, som bruger @AfterAll-annotationen, udskrives i slutningen af testklassen, efter at alle testmetoderne er udført.

@AfterEach-annotationen

@AfterEach-annotationen er modstykket til @BeforeEach-annotationen. De har de samme obligatoriske bestemmelser, som er lidt forskellige fra @BeforeAll- og @AfterAll-annoteringerne. Det, der adskiller @AfterEach-annotationen fra @BeforeEach-annotationen (bortset fra deres navne) er, at @AfterEach-metoden kører efter hver testmetode.

@AfterEach 
public void returnResults() { 
    System.out.println("The results are ready"); 
}

Udførelse af CalculatorTest-klassen udskriver følgende output til konsollen:

Outputtet viser, at metoden forbundet med @AfterEach-annotationen (returnResults) udskrives fire gange. Hver udførelse af returnResults()-metoden sker kun efter udførelse af hver enhedstest. Dette fremgår af det faktum, at returnResults()-metodens output vises efter hvert output fra den metode, der er knyttet til @BeforeEach-annotationen.

Poler dine testsuiter ved hjælp af anmærkninger

JUnit giver dig mulighed for at håndtere ikke-testrelaterede processer ved at bruge før- og efterparrets annoteringer. Disse fire annoteringer hører til en liste over flere andre annoteringer, som tilføjer værdi til dine tests. En anden af JUnits annoteringer er @DisplayName.

De to kodeeksempler, der viser den komplette CalculatorTest-klasse, bruger @DisplayName-annotationen. @DisplayName-annotationen hjælper dig med at skabe mere meningsfulde navne til dine testklasser og testmetoder.