JUnit Testcases @Before @BeforeClass Annotatie

JUnit is de meest populaire eenheid Testen raamwerk erin Java. Het wordt uitdrukkelijk aanbevolen voor Testen van een eenheid. JUnit Het testen van een webapplicatie vereist geen server, waardoor het testproces snel verloopt.

De JUnit Het framework maakt ook het snel en eenvoudig genereren van testgevallen en testgegevens mogelijk. De org.junit Het pakket bestaat uit vele interfaces en klassen voor JUnit testen, zoals Test, Assert, After en Before. Het bredere JUnit Het gezin bouwt voort op dezelfde bouwstenen.

Wat is een testopstelling?

Voordat we begrijpen wat een testfixture is, laten we eerst de onderstaande code bekijken.

Deze code is ontworpen om twee testgevallen uit te voeren op een eenvoudig bestand.

public class OutputFileTest {
    private File output; 
    output = new File(...);
    output.delete(); 
public void testFile1(){
        //Code to verify Test Case 1
}
    output.delete();
    output = new File(...);
public void testFile2(){
        //Code to verify Test Case 2
}
 output.delete(); 
}

Weinig problemen hier

• De code is onleesbaar.
• De code is niet eenvoudig te onderhouden.
• Als de testsuite complex is, kan de code logische problemen bevatten.

Vergelijk dezelfde code met behulp van JUnit.

public class OutputFileTest		
{
    private File output; 
    @Before public void createOutputFile() 
    { 
       output = new File(...);
    }
  
	@After public void deleteOutputFile() 
    {
        output.delete(); 
    } 
     
    @Test public void testFile1() 
    {
       // code for test case objective
    } 
	@Test public void testFile2() 
    {
       // code for test case objective
    }
}

De code is veel beter leesbaar en onderhoudbaar. De bovenstaande codestructuur is een testopstelling.

Een testopstelling is een context waarin a JUnit Testgeval loopt. Typisch omvatten testarmaturen:

• Objecten of bronnen die beschikbaar zijn voor elke testcase.
• Er zijn activiteiten nodig om deze objecten en middelen beschikbaar te maken.
• Deze werkzaamheden zijn
  1. toewijzing (setup)
  2. de-toewijzing (scheuren).

Opstelling en afbraak

Wedstrijdschema's zijn belangrijk omdat JUnit Deze haken worden bij elke test uitgevoerd.

• Meestal zijn er enkele herhaalde taken die voorafgaand aan elke testcase moeten worden uitgevoerd. Voorbeeld: maak een databaseverbinding.
• Op dezelfde manier kunnen er aan het einde van elke testcase enkele herhaalde taken zijn. Voorbeeld: om op te ruimen zodra de testuitvoering voorbij is.
• JUnit Het biedt annotaties die helpen bij het opzetten en afbreken van de testomgeving. Het zorgt ervoor dat resources worden vrijgegeven en dat het testsysteem gereed is voor de volgende testcase.

Deze JUnit De annotaties worden hieronder besproken.

Setup

@Voor annotatie in JUnit wordt gebruikt op een methode die bevat Java Code die vóór elke testcase wordt uitgevoerd, oftewel vóór elke testuitvoering.

Teardown (ongeacht het vonnis)

@Na annotatie wordt gebruikt op een methode die het volgende bevat: Java Code die na elk testgeval wordt uitgevoerd. Deze methoden worden uitgevoerd, zelfs als er uitzonderingen optreden in het testgeval of als beweringen niet kloppen.

Let op:

• Het is toegestaan ​​om een ​​willekeurig aantal hierboven genoemde annotaties te hebben.
• Alle methoden geannoteerd met @Voor in JUnit worden vóór elke testcase uitgevoerd, maar ze kunnen in willekeurige volgorde worden uitgevoerd.
• Je kunt de methoden `@Before` en `@After` overerven van een superklasse. De uitvoering verloopt als volgt en is een standaard uitvoeringsproces. JUnit.

1. Voer de JUnit @Before-methoden in de superklasse
2. Voer de @Before-methoden in deze klasse uit
3. Voer een @Test-methode uit in deze klasse
4. Voer de @After-methoden in deze klasse uit
5. Voer de @After-methoden uit in de superklasse

JUnit Opmerking voor 5: deze annotaties zijn JUnit 4 (org.junit). JUnit 5 hebben ze hernoemd in org.junit.jupiter.apien JUnit De onderstaande code (4) werkt nog steeds met de vintage engine.

Voorbeeld: Een klasse maken met een bestand als testfixture

public class OutputFileTest		
{
    private File output; 
    @Before	public void createOutputFile() 
    { 
       output = new File(...);
    }
  
	@After public void deleteOutputFile() 
    {
        output.delete(); 
    } 
     
    @Test public void testFile1() 
    {
       // code for test case objective
    } 
	@Test public void testFile2() 
    {
       // code for test case objective
    }
}

In het bovenstaande voorbeeld zal de uitvoeringsketen als volgt verlopen. Het diagram tracDat betekent één aanmaak-test-verwijdercyclus per testmethode.

1. createOutputFile()
2. testBestand1()
3. verwijderUitvoerBestand()
4. createOutputFile()
5. testBestand2()
6. verwijderUitvoerBestand()

Veronderstelling:

testFile1() wordt uitgevoerd vóór testFile2(), wat niet gegarandeerd is.

Eenmalige opstelling

• Het is mogelijk om een ​​methode slechts één keer uit te voeren voor de hele testklasse voordat een van de tests wordt uitgevoerd, en voorafgaand aan elke test @Voor methode(n).
• Een eenmalige configuratie is handig voor het opstarten van servers, het openen van communicatieverbindingen en soortgelijke taken. Het is tijdrovend om resources voor elke test te sluiten en opnieuw te openen.
• Dit kan gedaan worden met behulp van de annotatie @Voor klas in JUnit.

@BeforeClass public static void Method_Name() {	
    // class setup code here	
 }	

De methode moet zijn openbare statische leegteomdat JUnit roept het aan voordat er een testinstantie bestaat.

Eenmalig afbreken

• Net als bij de eenmalige instelmethode is er ook een eenmalige opschoonmethode beschikbaar. Deze wordt uitgevoerd na alle testcasemethoden. @Na annotaties zijn uitgevoerd.
• Het is handig om te stoppenping servers en het verbreken van communicatieverbindingen.
• Dit kan met behulp van de @Na de les annotatie.

 @AfterClass public static void Method_Name()	
 {	
    // class cleanup code here	
 }	

JUnit Testsuites

Zodra de testopstellingen gereed zijn, worden gerelateerde testklassen doorgaans gegroepeerd en gezamenlijk gelanceerd.

Als we meerdere tests in een specifieke volgorde willen uitvoeren, kunnen we alle tests op één plek combineren. Deze plek noemen we een testsuite. Meer informatie over het uitvoeren van testsuites en hoe ze worden gebruikt, vindt u in [link]. JUnit worden in dit document behandeld zelfstudie.

JUnit Test Runner

JUnit biedt een hulpmiddel voor het uitvoeren van uw testgevallen.

• JUnitKern klasse wordt gebruikt om deze tests uit te voeren.
• Een methode genaamd runClasses door org.junit.runner.JUnitKern wordt gebruikt om een ​​of meerdere testklassen uit te voeren.
• Het retourneringstype van deze methode is de Resultaat voorwerp (org.junit.runner.Result), die wordt gebruikt om toegang te krijgen tot informatie over de tests. Zie het volgende codevoorbeeld voor meer duidelijkheid.

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

In de bovenstaande code wordt het object "result" verwerkt om de geslaagde en mislukte resultaten van de testgevallen die we uitvoeren te verkrijgen. Hulpmiddelen zoals assertIs gelijk aan die mislukkingen aan de kaak stellen, terwijl @Negeren Slaat een toets over.

JUnit Opmerking voor 5: JUnitKern is de JUnit 4 hardlopers. JUnit 5 vervangt het door de JUnit Platform Launcher API, normaal gesproken gestart door de IDE, Gradle of Maven Surefire.

Voornaam* JUnit Programma

Gedegen kennis van SDLC, Java programmeren en de basisprincipes van software testen proces helpt bij het begrijpen van een JUnit programma, net zoals weten hoe eenheidstests verschillen van integratietests.

Laten we unit testen begrijpen aan de hand van een concreet voorbeeld. We moeten een testklasse maken met een testmethode die is geannoteerd met... @Toets zoals hieronder gegeven:

MijnFirstClassTest.java

package guru99.JUnit;		

import static org.junit.Assert.*;				

import org.junit.Test;		

public class MyFirstClassTest {				

    @Test		
    public void myFirstMethod(){					
        String str= "JUnit is working fine";					
        assertEquals("JUnit is working fine",str);					
    }
}		

TestRunner.java

Om onze testmethode (hierboven) uit te voeren, moeten we een testrunner aanmaken. In de testrunner moeten we de testklasse als parameter toevoegen. JUnitDe `runClasses()`-methode van Core. Deze retourneert het testresultaat, afhankelijk van of de test geslaagd of mislukt is.

Voor meer informatie hierover, zie de onderstaande code:

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(MyFirstClassTest.class);					
			for (Failure failure : result.getFailures()) {							
              System.out.println(failure.toString());					
      }		
      System.out.println("Result=="+result.wasSuccessful());							
   }		
}      	

uitgang

Eens TestRunner.java Wanneer we onze testmethoden uitvoeren, krijgen we als resultaat 'mislukt' of 'geslaagd'. Hieronder vindt u een toelichting op de uitvoer:

1. In dit voorbeeld na het uitvoeren MijnFirstClassTest.javaDe test is geslaagd en het resultaat is groen.
2. Als het mislukt was, zou het resultaat in het rood zijn weergegeven, en de mislukking is te zien in de foutmelding. trace. Zie de JUnit Onderstaande grafische gebruikersinterface (GUI):

Veelgestelde vragen