JUnit Testfall @Before @BeforeClass Annotation

JUnit är den mest populära enheten Testning ram i Java. Det rekommenderas uttryckligen för Enhetstestning. JUnit kräver ingen server för att testa en webbapplikation, vilket gör testprocessen snabb.

Ocuco-landskapet JUnit ramverket tillåter också snabb och enkel generering av testfall och testdata. De org.junit paketet består av många gränssnitt och klasser för JUnit testning, såsom Testa, Säkerställa, Efter och Före. Den bredare JUnit familjen bygger på samma byggstenar.

Vad är en testfixtur?

Innan vi förstår vad en testfixtur är, låt oss studera koden nedan.

Denna kod är utformad för att exekvera två testfall på en enkel fil.

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

Lite frågor här

• Koden är inte läsbar.
• Koden är inte lätt att underhålla.
• När testsviten är komplex kan koden innehålla logiska problem.

Jämför samma kod med 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
    }
}

Koden är mycket mer läsbar och lättare att underhålla. Ovanstående kodstruktur är en testfixtur.

En testfixtur är ett sammanhang där en JUnit Testfall springer. Typiskt inkluderar testfixturer:

• Objekt eller resurser som är tillgängliga för alla testfall.
• Aktiviteter som krävs för att göra dessa objekt och resurser tillgängliga.
• Dessa aktiviteter är
  1. tilldelning (inställning)
  2. avfördelning (riva ner).

Setup och Teardown

Fixturer spelar roll eftersom JUnit kör dessa krokar runt varje test.

• Vanligtvis finns det några upprepade uppgifter som måste göras före varje testfall. Exempel: skapa en databasanslutning.
• På samma sätt kan det finnas några upprepade uppgifter i slutet av varje testfall. Exempel: att städa upp när testkörningen är över.
• JUnit tillhandahåller anteckningar som hjälper till vid installation och nedmontering. Det säkerställer att resurser frigörs och att testsystemet är redo för nästa testfall.

Dessa JUnit anteckningar diskuteras nedan.

Inställning

@Innan anteckning i JUnit används på en metod som innehåller Java kod som ska köras före varje testfall, det vill säga den körs före varje testkörning.

Nedbrytning (oavsett domen)

@Efter annotering används på en metod som innehåller Java kod som ska köras efter varje testfall. Dessa metoder kommer att köras även om några undantag utlöses i testfallet eller vid felaktiga påståenden.

Obs:

• Det är tillåtet att ha valfritt antal anteckningar listade ovan.
• Alla metoder kommenterade med @Innan in JUnit kommer att köras före varje testfall, men de kan köras i valfri ordning.
• Du kan ärva @Before- och @After-metoderna från en superklass. Exekveringen sker enligt följande, och det är en standardexekveringsprocess i JUnit.

1. Kör JUnit @Before-metoder i superklassen
2. Kör @Before-metoderna i den här klassen
3. Kör en @Test-metod i den här klassen
4. Kör @After-metoderna i den här klassen
5. Kör @After-metoderna i superklassen

JUnit 5-notering: dessa anteckningar är JUnit 4 (org.junit). JUnit 5 döpte om dem i org.junit.jupiter.api, Och den JUnit 4-koden nedan körs fortfarande med den gamla motorn.

Exempel: Skapa en klass med file som testfixtur

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

I exemplet ovan kommer exekveringskedjan att se ut som följer. Diagrammet tracen skapa-test-borttagningscykel per testmetod.

1. createOutputFile()
2. testfil1()
3. deleteOutputFile()
4. createOutputFile()
5. testfil2()
6. deleteOutputFile()

Antagande:

testFile1() körs före testFile2(), vilket inte är garanterat.

Inställning endast en gång

• Det är möjligt att köra en metod endast en gång för hela testklassen innan något av testerna exekveras, och före ev. @Innan metod(er).
• ”Engångsinstallation” är användbar för att starta servrar, öppna kommunikation och liknande arbete. Det är tidskrävande att stänga och öppna resurser igen för varje test.
• Detta kan göras med hjälp av anteckningen @Innan lektionen in JUnit.

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

Metoden måste vara offentligt statiskt tomrum, därför att JUnit anropar det innan någon testinstans finns.

Riv bara en gång

• I likhet med engångsinstallation finns även en engångsrensningsmetod tillgänglig. Den körs efter alla testfallsmetoder och @Efter anteckningar har utförts.
• Det är användbart för att stoppaping servrar och stänger kommunikationslänkar.
• Detta kan göras med hjälp av @Efter lektionen anteckning.

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

JUnit Testsviter

Med fixturer på plats grupperas och lanseras vanligtvis relaterade testklasser tillsammans.

Om vi ​​vill köra flera tester i en specifik ordning kan det göras genom att kombinera alla tester på ett ställe. Denna plats kallas en testsvit. Mer information om hur man kör testsviter och hur de används i JUnit är täckta i detta handledning.

JUnit Testlöpare

JUnit tillhandahåller ett verktyg för att utföra dina testfall.

• JUnitKärna klass används för att utföra dessa tester.
• En metod som kallas körklasser tillhandahålls av org.junit.runner.JUnitKärna används för att köra en eller flera testklasser.
• Returtyp för denna metod är Resultat objekt (org.junit.runner.Result), som används för att komma åt information om testerna. Se följande kodexempel för mer förtydligande.

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

I koden ovan bearbetas "result"-objektet för att hämta fel och lyckade resultat från de testfall vi kör. Hjälpfunktioner som assertEquals lyfta fram dessa misslyckanden, medan @Strunta i hoppar över ett prov.

JUnit 5-notering: JUnitKärna är JUnit 4 löpare. JUnit 5 ersätter det med JUnit plattform Launcher API, normalt startat av IDE:n, Gradle eller Maven Surefire.

Förnamn JUnit Prográmma

Goda kunskaper om SDLC, Java programmering och grunderna i mjukvarutestning processen hjälper till att förstå en JUnit program, liksom att veta hur enhetstester skiljer sig från integrationstester.

Låt oss förstå enhetstestning med hjälp av ett verkligt exempel. Vi behöver skapa en testklass med en testmetod kommenterad med @Testa enligt nedan:

MyFirstClassTest.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

För att köra vår testmetod (ovan) behöver vi skapa en testkörare. I testköraren måste vi lägga till testklassen som en parameter i JUnitCores runClasses()-metod. Den returnerar testresultatet, baserat på om testet är godkänt eller misslyckat.

För mer information om detta, se koden nedan:

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

Produktion

När TestRunner.java kör våra testmetoder får vi utdata som misslyckad eller godkänd. Nedan följer förklaringen av utdata:

1. I det här exemplet, efter exekvering MyFirstClassTest.java, testet är godkänt och resultatet visas i grönt.
2. Om det hade misslyckats skulle resultatet ha visat rött, och felet kan observeras i felet. trace. Se JUnit GUI nedan:

Vanliga frågor