JUnit Annotaties Tutorial met voorbeeld: Wat is @Test en @After

Wat is JUnit annotaties?

JUnit annotaties zijn een speciale vorm van syntactische metadata die kan worden toegevoegd aan Java Broncode voor betere leesbaarheid en structuur. Variabelen, parameters, pakketten, methoden en klassen kunnen worden geannoteerd. Annotaties werden geïntroduceerd in JUnit 4, wat maakt Java De code is leesbaarder en eenvoudiger. Dat is het grote verschil tussen JUnit 3 en JUnit 4: JUnit 4 is gebaseerd op annotaties.

Met een goede kennis van deze annotaties kan men gemakkelijk een leerproces starten en implementeren. JUnit test. Hieronder vindt u de belangrijkste en meest gebruikte JUnit annotatielijst, met de JUnit 5 (Jupiter) equivalent naast elk ervan:

JUnit Annotaties Voorbeeld

Laten we een klasse maken die belangrijk omvat JUnit annotaties met eenvoudige printinstructies en voer deze uit met een testrunner-klasse:

Stap 1) Overweeg het volgende: Java klasse met diverse methoden die zijn gekoppeld aan de hierboven vermelde annotaties:

JunitAnnotationsExample.java

package guru99.junit;		

import static org.junit.Assert.assertEquals;				
import static org.junit.Assert.assertFalse;				

import java.util.ArrayList;		

import org.junit.After;		
import org.junit.AfterClass;		
import org.junit.Before;		
import org.junit.BeforeClass;		
import org.junit.Ignore;		
import org.junit.Test;		

public class JunitAnnotationsExample {				

    private ArrayList<String> list;					

    @BeforeClass		
    public static void m1() {							
        System.out.println("Using @BeforeClass , executed before all test cases ");					
    }		

    @Before		
    public void m2() {					
        list = new ArrayList<String>();					
        System.out.println("Using @Before annotations ,executed before each test cases ");					
    }		

    @AfterClass		
    public static void m3() {							
        System.out.println("Using @AfterClass ,executed after all test cases");					
    }		

    @After		
    public void m4() {					
        list.clear();			
        System.out.println("Using @After ,executed after each test cases");					
    }		

    @Test		
    public void m5() {					
        list.add("test");					
        assertFalse(list.isEmpty());			
        assertEquals(1, list.size());			
    }		

    @Ignore		
    public void m6() {					
        System.out.println("Using @Ignore , this execution is ignored");					
    }		

    @Test(timeout = 10)			
    public void m7() {					
        System.out.println("Using @Test(timeout),it can be used to enforce timeout in JUnit4 test case");					
    }		

    @Test(expected = NoSuchMethodException.class)					
    public void m8() {					
        System.out.println("Using @Test(expected) ,it will check for specified exception during its execution");					

    }		

}		

Stap 2) Laten we een testrunnerklasse maken om de bovenstaande test uit te voeren:

TestRunner.java

package guru99.junit;		

import org.junit.runner.JUnitCore;		
import org.junit.runner.Result;		
import org.junit.runner.notification.Failure;		

public class TestRunner {				
			public static void main(String[] args) {									
      Result result = JUnitCore.runClasses(JunitAnnotationsExample.class);					
			for (Failure failure : result.getFailures()) {							
         System.out.println(failure.toString());					
      }		
      System.out.println("Result=="+result.wasSuccessful());							
   }		
}      	

verwacht resultaat

• Alle testgevallen worden één voor één uitgevoerd en alle printopdrachten zijn zichtbaar in de console.
• Zoals besproken in de bovenstaande tabel, @Before en @BeforeClass in JUnit [methoden m2() en m1()] worden respectievelijk vóór elk testgeval en vóór alle testgevallen uitgevoerd.
• Op dezelfde manier als @After en @AfterClass in JUnit De methoden m4() en m3() worden respectievelijk na elk testgeval en na alle testgevallen uitgevoerd. @Ignore (methode m6()) wordt beschouwd als het negeren van de test.

Laten we de testgevallen analyseren die hierboven zijn gebruikt. Java De les in detail:

1. Beschouw de methode m5() zoals hieronder weergegeven:

	@Test		
    public void m5() {					
        list.add("test");					
        assertFalse(list.isEmpty());			
        assertEquals(1, list.size());			
    }		

Bij de bovenstaande methode voeg je een tekenreeks toe aan de variabele "lijst":

• lijst.isEmpty() zal vals retourneren.
• assertFalse(lijst.isEmpty()) moet waar terugkeren.
• Als gevolg hiervan zal de testcase dat wel doen passeren.

Omdat je slechts één tekenreeks aan de lijst hebt toegevoegd, is de grootte één.

• lijst.grootte() moet de integerwaarde "1" retourneren.
• So assertEquals(1, lijst.grootte()) moet waar terugkeren.
• Als gevolg hiervan zal de testcase dat wel doen passeren.

2. Beschouw de methode m7() zoals hieronder weergegeven:

@Test(timeout = 10)		
    public void m7() {					
        System.out.println("Using @Test(timeout),it can be used to enforce timeout in JUnit4 test case");					
    }		

Zoals hierboven besproken, @Test(time-out = 10) wordt gebruikt om een ​​time-out af te dwingen in de testcase. De waarde is in milliseconden, dus m7() moet binnen 10 ms klaar zijn.

3. Beschouw de methode m8() zoals hieronder weergegeven:

@Test(expected = NoSuchMethodException.class)				
    public void m8() {					
        System.out.println("Using @Test(expected) ,it will check for specified exception during its execution");					
    
    }		

Zoals hierboven besproken, @Test(verwacht) De methode m8() controleert tijdens de uitvoering op de opgegeven uitzondering, waardoor de methode "No Such Method Exception" zal genereren. Hierdoor zal de test met een uitzondering worden uitgevoerd.

Nauwkeurigheidsopmerking: m8() print slechts één regel, dus de gedeclareerde uitzondering wordt nooit daadwerkelijk gegenereerd. JUnit 4 meldt dat de test is mislukt. Stem het verwachte type af op wat de methode daadwerkelijk retourneert. JUnit 5 schrijft dit met assertThrows.

Doordat alle testgevallen zijn doorstaan, resulteert dit in een succesvolle testuitvoering.

Werkelijke resultaat

Aangezien er in het bovenstaande voorbeeld drie testgevallen zijn, worden alle testgevallen één voor één uitgevoerd. Zie de onderstaande schermafbeelding van de console:

Zie onderstaande printverklaringen die op de console te zien zijn:

Met behulp van @BeforeClass , uitgevoerd vóór alle testgevallen

Met behulp van @Before-annotaties, uitgevoerd vóór elke testcase

Met behulp van @After, uitgevoerd na elke testcase

Met behulp van @Before-annotaties, uitgevoerd vóór elke testcase

Met behulp van @Test(timeout) kan dit worden gebruikt om een ​​time-out af te dwingen JUnitTestcase uit 4

Met behulp van @After, uitgevoerd na elke testcase

Met behulp van @Before-annotaties, uitgevoerd vóór elke testcase

Met behulp van @Test(expected) wordt tijdens de uitvoering gecontroleerd op gespecificeerde uitzonderingen

Met behulp van @After, uitgevoerd na elke testcase

Met behulp van @AfterClass, uitgevoerd na alle testgevallen

JUnit Beweer klasse

De annotaties bepalen wanneer een methode wordt uitgevoerd; de assert-methoden bepalen of deze slaagt.

Deze klasse biedt een aantal assertiemethoden die nuttig zijn bij het schrijven van testcases. Als alle assert-statements slagen, zijn de testresultaten succesvol. Als een van de assert-statements mislukt, zijn de testresultaten mislukt. De specifieke JUnit beweren Deze handleiding behandelt elke methode uitgebreid.

Zoals u eerder hebt gezien, beschrijft de onderstaande tabel belangrijke Assert-methoden en hun omschrijving:

JUnit Testgevallenklasse

Om meerdere tests uit te voeren, is de klasse TestCase beschikbaar in de junit.framework pakket. De @Test-annotatie geeft aan JUnit dat deze openbare void-methode (hier een testgeval) waaraan deze is gekoppeld, als testgeval kan worden uitgevoerd.

Versie-opmerking: Testcase, Testresultaat en Test pak behoren tot de erfenis junit.framework pakket van JUnit 3. Ze worden nog steeds meegeleverd in het JUnit 4.x-artefact, maar op annotaties gebaseerde tests breiden TestCase niet uit.

De onderstaande tabel toont enkele belangrijke methoden die beschikbaar zijn in de junit.framework.TestCase klasse:

JUnit TestResultaat-klasse

Wanneer je een test uitvoert, retourneert deze een resultaat (in de vorm van een Testresultaat object). Dit TestResult-object kan worden gebruikt om het resulterende object te analyseren. Dit testresultaat kan een mislukking of een succes zijn.

Zie onderstaande tabel voor belangrijke methoden die worden gebruikt in de klasse junit.framework.TestResult:

JUnit Suiteklasse testen

Als je meerdere tests in een specifieke volgorde wilt uitvoeren, kun je dat doen door alle tests op één plek te combineren. Deze plek noemen we een testsuite. JUnit testsuite De tutorial doorloopt een volledig voorbeeld.

Zie onderstaande tabel voor belangrijke methoden die worden gebruikt in de junit.framework.TestSuite klasse:

Veelgestelde vragen