JUnit ErrorCollector @Rule mit Beispiel

In einem normalen Szenario würden Sie jedes Mal, wenn Sie während der Testausführung einen Fehler feststellen, den Test stoppen, den Fehler beheben und den Test erneut ausführen.

Doch JUnit hat einen etwas anderen Ansatz. Mit JUnit Mit dem Fehlerkollektor können Sie die Testausführung auch dann fortsetzen, wenn ein Problem festgestellt wurde oder der Test fehlschlägt. Der Fehlerkollektor sammelt alle Fehlerobjekte und meldet sie nur einmal, nachdem die Testausführung abgeschlossen ist.

Warum Error Collector verwenden?

Beim Schreiben eines Testskripts möchten Sie alle Tests ausführen, auch wenn eine Codezeile aufgrund eines Netzwerkfehlers, eines Assertionsfehlers oder aus einem anderen Grund fehlschlägt. In dieser Situation können Sie das Testskript weiterhin mit einer speziellen Funktion von ausführen JUnit bekannt als „Fehlersammler“.

Dafür, JUnit verwendet @Rule-Anmerkung Dies wird zum Erstellen eines Objekts des Fehlersammlers verwendet. Sobald das Objekt für den Fehlerkollektor erstellt wurde, können Sie mithilfe der Methode ganz einfach alle Fehler zum Objekt hinzufügen addError (auslösbarer Fehler). Wie Sie wissen, das Werfen ist die Superklasse von Exception und Fehler Klasse in Java. Wenn Sie auf diese Weise Fehler hinzufügen, werden diese Fehler protokolliert JUnit Testergebnis .

Der Vorteil des Hinzufügens aller Fehler in einem Fehlerkollektor besteht darin, dass Sie alle Fehler auf einmal überprüfen können. Auch wenn das Skript mittendrin fehlschlägt, kann es trotzdem mit der Ausführung fortfahren

Note: Bei Verwendung eines einfachen Assert- oder Try/Catch-Blocks ist die Verwendung der Fehlerkollektormethode nicht möglich.

Beispielcode

Um mehr über Error Collector zu erfahren, sehen Sie sich das folgende Codebeispiel an, das zeigt, wie man ein Error Collector-Objekt erstellt und alle Fehler in diesem Objekt hinzufügt, um das Problem zu verfolgen:

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

Was ist @Rule in jUnit?

JUnit bietet eine besondere Art der Testabwicklung, Testfall oder Testsuite mit @rule-Anmerkung. Mit @rule können Sie das Verhalten des Tests einfach hinzufügen oder neu definieren.

Es gibt mehrere integrierte Regeln, die von bereitgestellt werden JUnit API, die ein Tester verwenden kann, oder Sie können sogar unsere eigene Regel schreiben.

Sehen Sie sich die folgende Codezeile an, die zeigt, wie die @rule-Annotation zusammen mit dem Error Collector verwendet wird:

@Rule				
public ErrorCollector collector= new ErrorCollector();

Beispiel mit ErrorCollector

Um den Fehlerkollektor zu verstehen, erstellen wir eine Klasse und eine Regel zum Sammeln aller Fehler. Hier fügen Sie alle Fehler mit addError(throwable) hinzu.

Sehen Sie sich den folgenden Code an, der einfach eine Regel erstellt, die nichts anderes ist als das Erstellen eines „Error Collector-Objekts“. Dies wird weiterhin verwendet, um alle Fehler hinzuzufügen, um das Problem am Ende zu melden:

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

Fügen wir die obige Testklasse einem Testläufer hinzu und führen sie aus, um alle Fehler zu erfassen. Siehe folgenden Code:

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

Ausgang:

Sehen Sie sich die Fehlerverfolgung an, die alle Fehler an einem Ort verfolgt:

Vorteile der JUnit ErrorCollector

Sie können verwenden JUnit Behauptung für funktionale oder GUI-Validierung, z

1. AssertEquals(String-Nachricht, erwartetes Objekt, tatsächliches Objekt), die vergleichen, ob zwei Objekte gleich sind.
2. In ähnlicher Weise stellt „asserTrue(Boolesche Bedingung)“ fest, dass eine Bedingung wahr ist.

Mit der Behauptung wird der Validierungstest einfacher. Ein großes Problem besteht jedoch darin, dass die Testausführung auch dann gestoppt wird, wenn eine einzelne Behauptung fehlschlägt.

Die Testkontinuität und die Handhabung der Wiederherstellung sind für den Erfolg der Testautomatisierung von entscheidender Bedeutung. Error Collector ist der beste Weg, solche Szenarien zu bewältigen.

Zusammenfassung

• Der Junit-Fehlersammler ermöglicht die Fortsetzung eines Tests, selbst wenn das erste Problem gefunden wurde und der Test am Ende fehlschlägt.
• Der Fehlerkollektor sammelt alle Fehlerobjekte und meldet sie erst, wenn die Testausführung beendet ist
• Der Vorteil des Hinzufügens aller Fehler in einem Fehlerkollektor besteht darin, dass Sie alle Fehler auf einmal überprüfen können
• Der Fehlerkollektor fügt einfach Fehler mithilfe der von ErrorCollector.java bereitgestellten Methode addError(throwable err) hinzu.