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 vereist geen server voor het testen van de webapplicatie, waardoor het testproces snel is.

JUnit Het framework maakt ook het snel en eenvoudig genereren van testgevallen en testgegevens mogelijk. De org.Juni pakket bestaat uit vele interfaces en klassen voor JUnit Testen zoals Test, Assert, After, Before, etc.

Wat is Testarmatuur

Voordat we begrijpen wat een testopstelling is, moeten we de onderstaande code bestuderen

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 niet leesbaar
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 leesbaarder en beter te onderhouden. De bovenstaande codestructuur is een Proefopstelling.

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

Objecten of bronnen die beschikbaar zijn voor elke testcase.
Benodigde activiteiten die deze objecten/bronnen beschikbaar maken.
Deze werkzaamheden zijn
1. toewijzing (setup)
2. de-toewijzing (scheuren).

Opstelling en afbraak

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 biedt annotaties die helpen bij het opzetten en afbreken. Het zorgt ervoor dat bronnen worden vrijgegeven en dat het testsysteem gereed is voor de volgende testcase.

Deze JUnit annotaties worden hieronder besproken-

Setup

@Voor annotatie in JUnit wordt gebruikt op een methode die bevat Java code die vóór elke testcase moet worden uitgevoerd. dwz het wordt vóór elke testuitvoering uitgevoerd.

Teardown (ongeacht het vonnis)

@Na annotatie wordt gebruikt voor een methode die Java-code bevat en die na elke testcase wordt uitgevoerd. Deze methoden worden zelfs uitgevoerd als er uitzonderingen optreden in de testcase of als er beweringen mislukken.

Opmerking:

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.
U kunt de methoden @Before en @After overnemen van een superklasse. De uitvoering is als volgt: Het is een standaard uitvoeringsproces in JUnit.

Voer de JUnit @Before-methoden in de superklasse
Voer de @Before-methoden in deze klasse uit
Voer een @Test-methode uit in deze klasse
Voer de @After-methoden in deze klasse uit
Voer de @After-methoden uit in de superklasse

Voorbeeld: Een klasse met bestand aanmaken als testopstelling

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 zijn:

createOutputFile()
testBestand1()
verwijderUitvoerBestand()
createOutputFile()
testBestand2()
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).
“Eenmalige configuratie” is handig voor het starten van servers, het openen van communicatie, enz. Het is tijdrovend om bronnen 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	
 }

Eenmalig afbreken

Net als bij eenmalig instellen is er ook een eenmalige opschoonmethode beschikbaar. Het draait na alle testcasemethoden en @Na annotaties zijn uitgevoerd.
Het is handig voor het stoppen van servers, het sluiten van communicatieverbindingen, enz.
Dit kan met behulp van de @Na de les aantekening

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

JUnit Testsuites

Als we meerdere tests in een bepaalde volgorde willen uitvoeren, kan dat door alle tests op één plek te combineren. Deze plek wordt de testsuites genoemd. Meer details over hoe u testsuites uitvoert en hoe het wordt gebruikt in JUnit zullen hierin behandeld worden zelfstudie.

Junit-testloper

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 bovenstaande code wordt het “resultaat” -object verwerkt om mislukkingen en succesvolle resultaten te krijgen van testgevallen die we uitvoeren.

Voornaam* JUnit programma

Redelijke kennis van SDLC, Java-programmering en de basisprincipes van software testen proces helpt bij het begrijpen JUnit programma.

Laten we Unit Testing begrijpen aan de hand van een live voorbeeld. We moeten een testklasse maken met een testmethode 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 maken. In de testrunner moeten we testklasse als parameter toevoegen JUnitCore's runclasses() methode . Het retourneert het testresultaat, afhankelijk van of de test is geslaagd of mislukt.

Voor meer details 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 onze testmethoden uitvoert, krijgen we de uitvoer als mislukt of geslaagd. Hieronder vindt u uitleg over de uitvoer:

In dit voorbeeld na het uitvoeren MijnFirstClassTest.java , de test is geslaagd en het resultaat is groen.
Als het zou zijn mislukt, had het resultaat rood moeten zijn en kan het falen worden waargenomen in het fouttracering. Zie hieronder JUnit gui:

Samenvatting

JUnit is een raamwerk dat verschillende annotaties ondersteunt om een methode te identificeren die een test bevat.
JUnit biedt een annotatie genaamd @Test, die vertelt de JUnit dat de public void-methode waarin deze wordt gebruikt als testcase kan worden uitgevoerd.
Een testopstelling is een context waarin een testcase loopt
Als u meerdere tests in een bepaalde volgorde wilt uitvoeren, kunt u alle tests op één plek combineren. Deze plaats wordt de testsuites genoemd.
JUnit biedt een hulpmiddel voor het uitvoeren van de tests waarmee we onze testgevallen kunnen uitvoeren, genaamd Test Runner.

Je houdt misschien van: