JUnit ErrorCollector @Regel med eksempel

I et normalt scenarie, når du identificerer en fejl under testudførelse, ville du stoppe testen, rette fejlen og køre testen igen.

Men JUnit har en lidt anden tilgang. Med JUnit fejlindsamler, kan du stadig fortsætte med testudførelsen, selv efter at der er fundet et problem eller test mislykkes. Error collector samler alle fejlobjekter og rapporterer det kun én gang, efter at testen er overstået.

Hvorfor bruge Error Collector?

Mens du skriver et testscript, ønsker du at udføre alle testene, selvom en kodelinje fejler på grund af netværksfejl, påstandsfejl eller en anden årsag. I den situation kan du stadig fortsætte med at udføre testscript ved hjælp af en speciel funktion leveret af JUnit kendt som "fejlsamler".

For det, JUnit bruger @Regelanmærkning som bruges til at skabe et objekt med fejlopsamler. Når objektet til fejlsamler er oprettet, kan du nemt tilføje alle fejlene til objektet ved hjælp af metode addError (Throwable error). Som du ved, det Kan kastes er superklassen af undtagelse og Fejl klasse i Java. Når du tilføjer fejl på denne måde, vil disse fejl blive logget ind JUnit test resultat.

Fordelen ved at tilføje alle fejl i en Error Collector er, at du kan verificere alle fejlene på én gang. Hvis scriptet fejler i midten, kan det stadig fortsætte med at udføre det

Bemærk: I tilfælde af brug af simple assert eller try/catch-blok, vil det ikke være muligt at bruge fejlopsamlermetoden.

Prøvekode

For at forstå mere om Error Collector, se nedenstående kodeeksempel, som viser, hvordan man opretter et Error Collector-objekt og tilføjer alle fejlene i det pågældende objekt for at 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.		
    }		
}	

Hvad er @Rule i jUnit?

JUnit giver en særlig form for håndtering af tests, Test sag eller test suite ved at bruge @regelanmærkning. Ved hjælp af @rule kan du nemt tilføje eller omdefinere testens adfærd.

Der er flere indbyggede regler leveret af JUnit API, som en tester kan bruge, eller endda du kan skrive vores egen regel.

Se nedenstående kodelinje, som viser, hvordan du bruger @rule annotation sammen med Error Collector:

@Rule				
public ErrorCollector collector= new ErrorCollector();

Eksempel ved hjælp af ErrorCollector

For at forstå fejlsamleren, lad os oprette en klasse og en regel til at indsamle alle fejlene. Du tilføjer alle fejlene ved hjælp af addError(throwable) her.

Se nedenstående kode, som simpelthen opretter en regel, som ikke er andet end at skabe "Error Collector-objekt." Som yderligere bruges til at tilføje alle fejlene for at rapportere problemet til sidst:

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

Lad os tilføje ovenstående testklasse i en testløber og udføre den for at indsamle alle fejl. Se nedenstående kode:

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

Output:

Se fejlsporet, der sporer alle fejlene ét sted:

Fordele ved JUnit ErrorCollector

Du kan bruge JUnit påstand til funktionel eller GUI-validering, f.eks

1. assertEquals(String message, Object forventet, Objekt faktisk), som sammenligner, at to objekter er lige store.
2. På samme måde hævder assertTrue (Boolesk betingelse) at en betingelse er sand.

Ved at bruge påstand bliver valideringstest let. Men et stort problem er, at testudførelse stopper, selvom en enkelt påstand mislykkes.

Testkontinuitet og gendannelseshåndtering er afgørende for at teste automatiseringssucces. Error Collector er den bedste måde at håndtere sådanne scenarier på.

Resumé

• Junit-fejlsamleren tillader en test at fortsætte, selv efter at det første problem er fundet, og testen mislykkes i slutningen
• Error collector samler alle fejlobjekter og rapporterer det kun, når alt kommer til alt, testudførelsen over
• Fordelen ved at tilføje alle fejl i en Error Collector er, at du kan verificere alle fejlene på én gang
• Error collector tilføjer simpelthen fejl ved hjælp af metoden addError(throwable err) leveret af ErrorCollector.java.