JUnit ErrorCollector @Regel med eksempel

I et normalt scenario, når du identifiserer en feil under testkjøring, stopper du testen, fikser feilen og kjører testen på nytt.

Men JUnit har en litt annen tilnærming. Med JUnit feilsamler, kan du fortsatt fortsette med testkjøringen selv etter at et problem er funnet eller testen mislykkes. Error collector samler alle feilobjekter og rapporterer det bare én gang etter at testkjøringen er over.

Hvorfor bruke Error Collector?

Mens du skriver et testskript, ønsker du å utføre alle testene selv om en kodelinje mislykkes på grunn av nettverksfeil, påstandsfeil eller annen grunn. I den situasjonen kan du fortsatt kjøre testskript ved å bruke en spesialfunksjon levert av JUnit kjent som "feilsamler".

For dette, JUnit bruker @Regelmerknad som brukes til å lage et objekt med feilsamler. Når objektet for feilsamler er opprettet, kan du enkelt legge til alle feilene i objektet ved hjelp av metoden addError (kastbar feil). Som du vet, det Kastbar er superklassen til Unntak og Feil klasse i Java. Når du legger til feil på denne måten, vil disse feilene logges inn JUnit testresultat.

Fordelen med å legge til alle feil i en Error Collector er at du kan verifisere alle feilene samtidig. Dessuten, hvis skriptet mislykkes i midten, kan det fortsatt fortsette å kjøre det

Merknader: Ved bruk av enkel påstand eller prøv/fang-blokk vil det ikke være mulig å bruke feilsamlermetoden.

Eksempelkode

For å forstå mer om Error Collector, se kodeeksempelet nedenfor som viser hvordan du oppretter et Error Collector-objekt og legger til alle feilene i det objektet for å spore problemet:

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

Hva er @Rule i jUnit?

JUnit gir spesiell type håndtering av tester, Testsak eller testsuite ved å bruke @regelkommentar. Ved å bruke @rule kan du enkelt legge til eller omdefinere oppførselen til testen.

Det er flere innebygde regler gitt av JUnit API som en tester kan bruke, eller til og med du kan skrive vår egen regel.

Se kodelinjen nedenfor, som viser hvordan du bruker @rule-annotering sammen med Error Collector:

@Rule				
public ErrorCollector collector= new ErrorCollector();

Eksempel ved bruk av ErrorCollector

For å forstå feilsamleren, la oss lage en klasse og en regel for å samle alle feilene. Du vil legge til alle feilene ved å bruke addError (kastbar) her.

Se koden nedenfor som ganske enkelt oppretter en regel som ikke er annet enn å lage "Error Collector-objekt." Som videre brukes til å legge til alle feilene for å rapportere problemet på slutten:

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

La oss legge til testklassen ovenfor i en testløper og kjøre den for å samle alle feil. Se koden nedenfor:

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

Utgang:

Se feilsporet som sporer alle feilene på ett sted:

Fordeler med JUnit ErrorCollector

Du kan bruke JUnit påstand for funksjonell eller GUI-validering, f.eks

1. assertEquals(Strengmelding, Objekt forventet, Objekt faktisk) som sammenligner at to objekter er like.
2. På samme måte hevder assertTrue (boolsk tilstand) at en betingelse er sann.

Ved å bruke påstand blir valideringstesten enkel. Men et stort problem er at testkjøring vil stoppe selv om en enkelt påstand mislykkes.

Testkontinuitet og gjenopprettingshåndtering er avgjørende for å teste automatiseringssuksess. Error Collector er den beste måten å håndtere slike scenarier på.

Sammendrag

• Junit error collector lar en test fortsette selv etter at det første problemet er funnet og testen mislykkes på slutten
• Error collector samler alle feilobjekter og rapporterer det bare, tross alt, testkjøringen over
• Fordelen med å legge til alle feil i en Error Collector er at du kan verifisere alle feilene samtidig
• Error collector legger ganske enkelt til feil ved å bruke metoden addError (kastbar feil) levert av ErrorCollector.java.