I ett normalt scenario, när du identifierar ett fel under testkörningen, skulle du stoppa testet, fixa felet och köra testet igen.
Men JUnit har en något annan inställning. Med JUnit-felsamlare kan du fortfarande fortsätta med testkörningen även efter att ett problem har hittats eller testet misslyckats. Felsamlare samlar alla felobjekt och rapporterar det bara en gång efter att testkörningen är över.
I den här handledningen lär du dig-
- Vad är felsamlare i JUnit?
- Vad är @Rule i jUnit?
- Exempel på att använda ErrorCollector
- Fördelar med JUnit ErrorCollector
Varför använda Error Collector?
När du skriver ett testskript vill du utföra alla tester även om någon kodrad misslyckas på grund av nätverksfel, påståendefel eller av någon annan anledning. I den situationen kan du fortfarande fortsätta att köra testskript med hjälp av en speciell funktion som tillhandahålls av JUnit som kallas "felsamlare".
För detta använder JUnit @Rule-kommentar som används för att skapa ett objekt med felsamlare. När objektet för felsamlare har skapats kan du enkelt lägga till alla fel i objektet med metoden addError (Throwable error). Som du vet är Throwable superklassen Exception och Error- klassen i Java. När du lägger till fel på detta sätt loggas dessa fel i JUnit-testresultatet.
Fördelen med att lägga till alla fel i en felsamlare är att du kan verifiera alla fel på en gång. Om skriptet misslyckas i mitten kan det fortfarande fortsätta att köra det
Obs! Om du använder enkel påstå eller försök / fånga block är det inte möjligt att använda felsamlarmetoden.
Exempelkod
För att förstå mer om Error Collector, se nedan kodexempel som visar hur man skapar ett Error Collector-objekt och lägger till alla fel i det objektet för att spåra problemet:
paket guru99.junit;importera org.junit.Rule;importera org.junit.Test;importera org.junit.rules.ErrorCollector;public class ErrorCollectorExample {@Regelpublic ErrorCollector collector = new ErrorCollector ();@Testaoffentligt ogiltigt exempel () {collector.addError (ny Throwable ("Det finns ett fel i första raden"));collector.addError (ny Throwable ("Det finns ett fel i andra raden"));collector.checkThat (getResults (),inte (containString ("här är ett fel")));// alla kodrader kommer att köras och i slutet kommer ett kombinerat felvara inloggad.}}
Vad är @Rule i jUnit?
JUnit tillhandahåller speciell typ av hantering av tester, testfall eller testpaket med hjälp av @rule-kommentar . Med @rule kan du enkelt lägga till eller omdefiniera testets beteende.
Det finns flera inbyggda regler som tillhandahålls av JUnit API som en testare kan använda, eller till och med kan du skriva vår egen regel.
Se nedan rad med kod, som visar hur du använder @rule-kommentar tillsammans med Error Collector:
@Regelpublic ErrorCollector collector = new ErrorCollector ();
Exempel på att använda ErrorCollector
För att förstå felsamlare, låt oss skapa en klass och en regel för att samla alla fel. Du kommer att lägga till alla fel med addError (kastbar) här.
Se nedan kod som helt enkelt skapar en regel som bara är att skapa "Error Collector-objekt." Vilket används vidare för att lägga till alla fel för att rapportera problemet i slutet:
ErrorCollectorExample.java
paket guru99.junit;importera org.junit.Assert;importera org.junit.Rule;importera org.junit.Test;importera org.junit.rules.ErrorCollector;public class ErrorCollectorExample {@Regelpublic ErrorCollector collector = new ErrorCollector ();@Testaoffentligt ogiltigt exempel () {collector.addError (ny Throwable ("Det finns ett fel i första raden"));collector.addError (ny Throwable ("Det finns ett fel i andra raden"));System.out.println ("Hej");Prova {Assert.assertTrue ("A" == "B");} fångst (kastbar t) {collector.addError (t);}System.out.println ("Världen !!!!");}}
TestRunner.java
Låt oss lägga till ovanstående testklass i en testlöpare och utföra den för att samla alla fel. Se nedan kod:
paket guru99.junit;importera org.junit.runner.JUnitCore;importera org.junit.runner.Result;importera org.junit.runner.notification.Failure;offentlig klass TestRunner {public static void main (String [] args) {Resultatresultat = JUnitCore.runClasses (ErrorCollectorExample.class);för (Failure failure: result.getFailures ()) {System.out.println (failure.toString ());}System.out.println ("Resultat ==" + result.wasSuccessful ());}}
Produktion:
Se felspårningen som spårar alla fel på ett ställe:
Fördelar med JUnit ErrorCollector
Du kan använda JUnit-påståendet för funktionell eller GUI-validering, t.ex.
- assertEquals (Strängmeddelande, Objekt förväntat, Objekt aktuellt) som jämför att två objekt är lika.
- På samma sätt hävdar assertTrue (booleskt tillstånd) att ett villkor är sant.
Med påståendet blir valideringstest enkelt. Men en stor fråga är att testkörningen kommer att sluta även om en enda påstående misslyckas.
Testkontinuitet och hantering av återhämtning är avgörande för att testa automatiseringsframgång. Error Collector är det bästa sättet att hantera sådana slags scenarier.
Sammanfattning :
- Junit-felsamlare tillåter att ett test fortsätter även efter att den första utgåvan hittats och testet misslyckas i slutet
- Felsamlare samlar alla felobjekt och rapporterar bara, trots allt, testkörningen är över
- Fördelen med att lägga till alla fel i en felsamlare är att du kan verifiera alla fel på en gång
- Felsamlare lägger helt enkelt till fel med metoden addError (kastbar fel) som tillhandahålls av ErrorCollector.java.