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 webbapplikation, vilket gör testprocessen snabb.

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 Tester som Test, Assert, After, Before, etc.

Vad är 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 underhållbar. 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 som gör dessa objekt/resurser tillgängliga.
Dessa aktiviteter är
1. tilldelning (inställning)
2. avfördelning (riva ner).

Setup och Teardown

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 ger anteckningar som hjälper till vid installation och rivning. 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. dvs den körs före varje testkörning.

Nedbrytning (oavsett domen)

@Efter anteckning används på en metod som innehåller java-kod för att köras efter varje testfall. Dessa metoder kommer att köras även om några undantag görs i testfallet eller i fallet med påståendemisslyckanden.

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 metoder från en superklass, Execution är som följer: Det är en standardexekveringsprocess i JUnit.

Kör JUnit @Before-metoder i superklassen
Kör @Before-metoderna i den här klassen
Kör en @Test-metod i den här klassen
Kör @After-metoderna i den här klassen
Kör @After-metoderna i superklassen

Exempel: Skapa en klass med fil 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 utförandekedjan att vara följande-

createOutputFile()
testfil1()
deleteOutputFile()
createOutputFile()
testfil2()
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).
"Once only setup" är användbara för att starta servrar, öppna kommunikation, etc. Det är tidskrävande att stänga och återöppna resurser 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	
 }

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, stängning av kommunikationslänkar etc.
Detta kan göras med hjälp av @Efter lektionen anteckning

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

JUnit Testsviter

Om vi vill utföra flera tester i en angiven ordning kan det göras genom att kombinera alla tester på ett ställe. Denna plats kallas som testsviterna. Mer information om hur man kör testsviter och hur det används i JUnit kommer att omfattas av detta handledning.

Junit Test Runner

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 få tillgång till information om testerna. Se följande kodexempel för mer klarhet.

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 ovanstående kod bearbetas "resultat"-objektet för att få misslyckanden och framgångsrika resultat av testfall vi kör.

Förnamn JUnit program

God kunskap om SDLC, java-programmering och grunderna i mjukvarutestning processen hjälper till att förstå JUnit programmet.

Låt oss förstå enhetstestning med hjälp av ett levande exempel. Vi måste 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 utföra vår testmetod (ovan) måste vi skapa en testlöpare. I testlöparen måste vi lägga till testklass som en parameter i JUnitCores runclasses()-metod . Det kommer att returnera testresultatet, baserat på om testet är godkänt eller underkänt.

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 exekverar våra testmetoder får vi utdata som misslyckade eller godkända. Vänligen se utdataförklaringen nedan:

I det här exemplet, efter exekvering MyFirstClassTest.java , testet är godkänt och resultatet är grönt.
Om det skulle ha misslyckats borde det ha visat resultatet som rött och ett fel kan observeras vid fel. trace. Se nedan JUnit gui:

Sammanfattning

JUnit är ett ramverk som stöder flera kommentarer för att identifiera en metod som innehåller ett test.
JUnit ger en anteckning som kallas @Testa, som berättar för JUnit att den offentliga void-metoden som den används i kan köras som ett testfall.
En testfixtur är ett sammanhang där ett testfall körs
För att utföra flera tester i en angiven ordning kan det göras genom att kombinera alla tester på ett ställe. Denna plats kallas som testsviterna.
JUnit tillhandahåller ett verktyg för exekvering av testerna där vi kan köra våra testfall som kallas Test Runner.