Wanneer u een unit-testsuite schrijft, kunnen er enkele niet-testgerelateerde activiteiten zijn die u moet uitvoeren. Deze activiteiten kunnen elke vorm aannemen. Mogelijk moet u verbinding maken met een database of bronnen verzamelen voordat u een test uitvoert. Nadat elke testcase is uitgevoerd, moet u mogelijk enkele bronnen vrijgeven.
Het uitvoeren van een van deze niet-testgerelateerde activiteiten buiten het bereik van een unit-testklasse kan vervelend, zo niet onmogelijk zijn. De succesvolle uitvoering van uw testklasse kan afhankelijk zijn van deze activiteiten, dus JUnit biedt twee paar annotaties om dit probleem aan te pakken.
De @BeforeAll-annotatie
Een JUnit-testklasse kan een of meer testmethoden hebben. De @BeforeAll-annotatie geeft aan dat een specifieke methode moet worden uitgevoerd vóór alle testmethoden in een testklasse. De methode die aan deze annotatie is gekoppeld, wordt slechts één keer uitgevoerd (aan het begin van de test), ongeacht het aantal testmethoden in de testklasse.
Elke methode die de @BeforeAll-annotatie gebruikt, moet aan enkele voorwaarden voldoen. Deze methoden moeten een ongeldig retourtype hebben, moeten openbaar zijn en mogen niet privé zijn. De @BeforeAll-annotatie is ideaal om een verbinding met een database of het maken van een nieuw bestand. In dit artikel wordt een rekenmachinetestklasse gebruikt om te laten zien hoe u de @BeforeAll-annotatie kunt gebruiken.
De rekenklas
pakket com.app;
openbaarklasRekenmachine{
openbaarstatischinttoevoegen(int nummer1, int aantal2){
opbrengst aantal1 + aantal2;
}
openbaarstatischintaftrekken(int nummer1, int aantal2){
opbrengst num1 - num2;
}
openbaarstatischintvermenigvuldigen(int nummer1, int aantal2){
opbrengst aantal1 * aantal2;
}
openbaarstatischintverdeling(int nummer1, int aantal2){
opbrengst aantal1 / aantal2;
}
}De CalculatorTestklasse
importerenstatischorg.junit.Jupiter.api.Beweringen.*;
importerenorg.junit.Jupiter.api.Voor alles;
importerenorg.junit.Jupiter.api.Testen;
importerenorg.junit.Jupiter.api.Weergavenaam;@DisplayName("Testles die laat zien hoe je dat doet gebruiken de voordatenna annotaties.")
klasRekenmachineTest{
@Voor alles
openbaarstatischleegtepowerOnCalculator(){
Systeem.uit.println("De rekenmachine staat aan");
}@Testen
@Weergavenaam("Testmethode die twee gehele getallen optelt.")
openbaarleegtetestToevoegen(){
assertIs gelijk aan(7, Rekenmachine.toevoegen(3, 4));
}@Testen
@Weergavenaam("Testmethode die een geheel getal van een andere aftrekt.")
openbaarleegtetestAftrekken(){
assertIs gelijk aan(6, Rekenmachine.aftrekken(9, 3));
}@Testen
@Weergavenaam("Testmethode die twee gehele getallen vermenigvuldigt")
openbaarleegtetestVermenigvuldigen(){
assertIs gelijk aan(10, Rekenmachine.vermenigvuldigen(5, 2));
}
@Testen
@Weergavenaam("Testmethode die een geheel getal deelt door een andere")
openbaarleegtetestVerdelen(){
assertIs gelijk aan(2, Rekenmachine.verdeling(4, 2));
}
}
In deze klasse werkt de @BeforeAll-annotatie met de powerOnCalculator()-methode, die "De rekenmachine is ingeschakeld" vóór elke testrun afdrukt. De succesvolle testuitvoering drukt het volgende testrapport af:
Zoals u kunt zien, verschijnt de methode die is gekoppeld aan de @BeforeAll-annotatie niet in het testrapport. Als er echter een fout is in de @BeforeAll-annotatiemethode, zullen de testrapportresultaten dit aangeven met een fout.
De @BeforeEach-annotatie
Net als de @BeforeAll-geannoteerde methode, wordt de @BeforeEach-geannoteerde methode niet weergegeven in het testrapport. De geannoteerde methode @BeforeEach wordt uitgevoerd vóór elke testmethode in een testklasse. Dus als een testklasse twee testmethoden bevat, wordt de @BeforeEach-annotatie twee keer uitgevoerd.
importerenstatischorg.junit.Jupiter.api.Beweringen.*;
importerenorg.junit.Jupiter.api.Voor alles;
importerenorg.junit.Jupiter.api.Voor elke;
importerenorg.junit.Jupiter.api.Testen;
@DisplayName("Testles die laat zien hoe je dat doet gebruiken de voordatenna annotaties.")
klasRekenmachineTest{
@Voor alles
openbaarstatischleegtepowerOnCalculator(){
Systeem.uit.println("De rekenmachine staat aan");
}
@BeforeEach
openbaarleegteclearCalculator(){
Systeem.uit.println("De rekenmachine is klaar");
}
@Testen
@Weergavenaam("Testmethode die twee gehele getallen optelt.")
openbaarleegtetestToevoegen(){
assertIs gelijk aan(7, Rekenmachine.toevoegen(3, 4));
}
@Testen
@Weergavenaam("Testmethode die een geheel getal van een andere aftrekt.")
openbaarleegtetestAftrekken(){
assertIs gelijk aan(6, Rekenmachine.aftrekken(9, 3));
}
@Testen
@Weergavenaam("Testmethode die twee gehele getallen vermenigvuldigt")
openbaarleegtetestVermenigvuldigen(){
assertIs gelijk aan(10, Rekenmachine.vermenigvuldigen(5, 2));
}
@Testen
@Weergavenaam("Testmethode die een geheel getal deelt door een andere")
openbaarleegtetestVerdelen(){
assertIs gelijk aan(2, Rekenmachine.verdeling(4, 2));
}
}
Het toevoegen van de @BeforeEach-annotatie aan de CalculatorTest-klasse levert de volgende uitvoer op:
De methode die is gekoppeld aan de @BeforeEach-annotatie wordt vier keer uitgevoerd, één keer vóór elke testmethode. Houd er rekening mee dat de @BeforeEach-methode niet statisch is, een ongeldig retourtype heeft en niet privé is, omdat dit verplichte bepalingen zijn. Het is ook belangrijk op te merken dat de methode die is gekoppeld aan de @BeforeEach-annotatie na de @BeforeAll-methode wordt uitgevoerd.
De @AfterAll-annotatie
Een methode met de @AfterAll-annotatie wordt uitgevoerd nadat alle testmethoden in de testklasse hun uitvoering hebben voltooid. De @AfterAll-annotatie is ideaal voor basisbestandsbewerkingen, zoals het sluiten van een bestand of het loskoppelen van een database. De @AfterAll-annotatie is de tegenhanger van de @BeforeAll-annotatie. Net als de @BeforeAll-annotatie, moet de @AfterAll-annotatie statisch zijn, ongeldig worden geretourneerd en veel niet privé zijn.
@Ten slotte
openbaarstatischleegtepowerOffCalculator(){
Systeem.uit.println("De rekenmachine staat uit");
}Door de @AfterAll-geannoteerde methode toe te voegen aan de bestaande klasse CalculatorTest wordt de volgende uitvoer naar de console afgedrukt:
Merk op dat de powerOffCalculator()-methode, die de @AfterAll-annotatie gebruikt, wordt afgedrukt aan het einde van de testklasse, nadat alle testmethoden zijn uitgevoerd.
De @AfterEach-annotatie
De @AfterEach-annotatie is de tegenhanger van de @BeforeEach-annotatie. Ze hebben dezelfde verplichte bepalingen, die enigszins verschillen van die van de annotaties @BeforeAll en @AfterAll. Wat de @AfterEach-annotatie onderscheidt van de @BeforeEach-annotatie (behalve hun namen) is dat de @AfterEach-methode na elke testmethode wordt uitgevoerd.
@Na elke
openbaarleegtereturnResultaten(){
Systeem.uit.println("De resultaten zijn klaar");
}Als u de klasse CalculatorTest uitvoert, wordt de volgende uitvoer naar de console afgedrukt:
De uitvoer laat zien dat de methode die is gekoppeld aan de @AfterEach-annotatie (returnResults) vier keer wordt afgedrukt. Elke uitvoering van de methode returnResults() vindt pas plaats na de uitvoering van elke eenheidstest. Dit blijkt uit het feit dat de uitvoer van de methode returnResults() wordt weergegeven na elke uitvoer van de methode die is gekoppeld aan de @BeforeEach-annotatie.
Poets uw testsuites met annotaties
Met JUnit kunt u niet-testgerelateerde processen afhandelen met behulp van de aantekeningen voor en na het paar. Deze vier annotaties behoren tot een lijst van verschillende andere annotaties die waarde toevoegen aan uw tests. Een andere annotatie van JUnit is @DisplayName.
De twee codevoorbeelden die de volledige CalculatorTest-klasse weergeven, gebruiken de annotatie @DisplayName. Met de annotatie @DisplayName kunt u betekenisvollere namen maken voor uw testklassen en testmethoden.
