JUnit ErrorCollector @Regel med exempel

I ett normalt scenario, när du identifierar något fel under testkörningen, skulle du stoppa testet, åtgärda felet och köra testet igen.

Men JUnit har ett lite annorlunda tillvägagångssätt. Med JUnit felsamlare kan du fortfarande fortsätta med testkörningen även efter att ett problem har hittats eller testet misslyckats. Error collector samlar in alla felobjekt och rapporterar det endast en gång efter att testkörningen är över.

Varför använda Error Collector?

När du skriver ett testskript vill du köra alla tester även om någon kodrad misslyckas på grund av nätverksfel, påståendefel eller någon annan anledning. I den situationen kan du fortfarande fortsätta att köra testskript med en speciell funktion som tillhandahålls av JUnit känd som "felsamlare".

För detta, JUnit användningar @Regelanteckning 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 ni vet, det Kastbar är superklassen av undantag och Fel klass i Java. När du lägger till fel på detta sätt kommer dessa fel att loggas in JUnit testresultat .

Fördelen med att lägga till alla fel i en Error Collector är att du kan verifiera alla fel på en gång. Dessutom, om skriptet misslyckas i mitten, kan det fortfarande fortsätta att köra det

Anmärkningar: Vid användning av enkel påstående eller försök/fånga block, kommer det inte att vara möjligt att använda felinsamlarmetoden.

Exempelkod

För att förstå mer om Error Collector, se kodexemplet nedan som visar hur man skapar ett Error Collector-objekt och lägger till alla fel i det objektet till tracproblemet:

package guru99.junit;		

import org.junit.Rule;		
import org.junit.Test;		
import org.junit.rules.ErrorCollector;		

public class ErrorCollectorExample {				
    @Rule		
    public ErrorCollector collector = new ErrorCollector();							

    @Test		
    public void example() {					
    collector.addError(new Throwable("There is an error in first line"));							
    collector.addError(new Throwable("There is an error in second line"));							
    collector.checkThat(getResults(),			
                not(containsString("here is an error")));			
    // all lines of code will execute and at the end a combined failure will		
    be logged in.		
    }		
}	

Vad är @Rule i jUnit?

JUnit ger speciell typ av hantering av tester, Testfall eller testsvit genom att använda @regelkommentar. 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 du kan skriva vår egen regel.

Se nedanstående kodrad, som visar hur du använder @rule annotation tillsammans med Error Collector:

@Rule				
public ErrorCollector collector= new ErrorCollector();

Exempel med ErrorCollector

För att förstå felsamlaren, låt oss skapa en klass och en regel för att samla in alla fel. Du kommer att lägga till alla fel genom att använda addError(throwable) här.

Se nedan kod som helt enkelt skapar en regel som inte är något annat än att skapa "Error Collector-objekt." Som vidare används för att lägga till alla fel för att rapportera problemet i slutet:

ErrorCollectorExample.java

package guru99.junit;		

import org.junit.Assert;		
import org.junit.Rule;		
import org.junit.Test;		
import org.junit.rules.ErrorCollector;		

public class ErrorCollectorExample {				
    @Rule		
    public ErrorCollector collector = new ErrorCollector();							

    @Test		
    public void example() {					
    collector.addError(new Throwable("There is an error in first line"));							
    collector.addError(new Throwable("There is an error in second line"));							

        System.out.println("Hello");					
        try {			
            Assert.assertTrue("A " == "B");					
        } catch (Throwable t) {					
            collector.addError(t);					
        }		
        System.out.println("World!!!!");					
    }		
}		

TestRunner.java

Låt oss lägga till ovanstående testklass i en testlöpare och köra den för att samla in alla fel. Se nedanstående kod:

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

Produktion:

Se misslyckandet tracvilket tracalla fel på ett ställe:

Fördelar med JUnit ErrorCollector

Du kan använda JUnit påstående för funktionell eller GUI-validering, t.ex

1. assertEquals(Strängmeddelande, Objekt förväntat, Objekt faktiskt) som jämför att två objekt är lika.
2. På liknande sätt hävdar assertTrue(Booleskt villkor) att ett villkor är sant.

Genom att använda påstående blir valideringstest enkelt. Men en stor fråga är att testkörningen kommer att stoppa även om ett enskilt påstående misslyckas.

Testkontinuitet och återställningshantering är avgörande för att testa automatiseringsframgång. Error Collector är det bästa sättet att hantera sådana scenarier.

Sammanfattning

• Junit error collector tillåter ett test att fortsätta även efter att det första problemet har hittats och testet misslyckas i slutet
• Error collector samlar alla felobjekt och rapporterar det bara, trots allt, testkörningen över
• Fördelen med att lägga till alla fel i en Error Collector är att du kan verifiera alla fel på en gång
• Error collector lägger helt enkelt till fel med metoden addError(throwable err) från ErrorCollector.java.