junit vs testng what are differences
Ein umfassender Vergleich zwischen JUnit und TestNG-Frameworks. Beinhaltet einen Vergleich von Anmerkungen und einen merkwürdigen Vergleich mit Beispielen:
Im vorherigen Lernprogramm haben wir die Annotation von DisplayName und die Ausführung bedingter Tests anhand verschiedener Kriterien wie JRE-Version, Umgebungsvariablen usw. gelernt. Wir haben auch einige wichtige Fragen rund um das Thema behandelt.
Da wir in früheren Tutorials kontinuierlich etwas über JUnit gelernt haben, wird dieses als Verschnaufpause für unser Publikum dienen, da wir unseren Fokus für eine Weile von JUnit als alleiniger Agenda auf den Vergleich zwischen JUnit und TestNG verlagern werden.
=> Lesen Sie hier den Perfect JUnit Training Guide.
Was du lernen wirst:
- JUnit Vs TestNG: Ein Vergleich
- Fazit
JUnit Vs TestNG: Ein Vergleich
| Eigenschaften | JUnit | TestNG |
|---|---|---|
| Zeitüberschreitung für Tests | Ja | Ja |
| OpenSource-Framework | Ja JUnit ist ein OpenSource-Framework | Ja TestNG ist ein OpenSource-Framework |
| Benutzerfreundlich | JUnit ist auf verschiedene Module verteilt, Beispiel: ? Für die Parametrierung benötigen Sie möglicherweise JUnit Jupiter. ? Dies macht die Verwendung von JUnit im Vergleich zu TestNG etwas umständlich | Alle TestNG-Funktionen sind in einem Modul enthalten. Dies macht TestNG benutzerfreundlicher. |
| Wichtige IDE-Unterstützung (( Beispiel: Eclipse, IntelliJ) | Ja Beide unterstützen den größten Teil der IDE gleichermaßen | Ja Beide unterstützen den größten Teil der IDE gleichermaßen |
| Implementierung von Anmerkungen | Ja JUnit bearbeitet Anmerkungen mit geringfügigen Abweichungen für verschiedene Funktionen | Ja TestNG bearbeitet Anmerkungen mit geringfügigen Abweichungen für verschiedene Funktionen |
| Umsetzung von Behauptungen | Ja JUnit bietet genügend Zusicherungen, um erwartete und tatsächliche Ergebnisse mit einigen Abweichungen von Zusicherungen in TestNG zu validieren | Ja TestNG unterstützt auch eine große Liste von Aussagen zum Vergleich von erwarteten und tatsächlichen Ergebnissen. Zusätzlich bietet TestNG zwei Mechanismen für Assertions - Soft Assertion und Hard Assertion |
| Ausnahmen | Ja JUnit bietet die Funktion für den Ausnahmetest mit einer geringfügigen Abweichung von TestNG | Ja TestNG bietet auch die Funktion für den Ausnahmetest |
| Parametrisierte Tests | Ja JUnit unterstützt parametrisierte Tests | Ja TestNG unterstützt auch parametrisierte Tests |
| Testsuite | Ja JUnit unterstützt die Verwendung von Testsuiten | Ja TestNG unterstützt auch Test Suite. |
| Abhängigkeitstest | Unterlassen Sie JUnit unterstützt die Funktion für den Abhängigkeitstest nicht | Ja Dies ist eine erweiterte Funktion in TestNG über JUnit. Mit dieser Funktion kann eine Methode als von einer anderen abhängig gemacht werden, sodass die Methode erst ausgeführt wird, nachdem die abhängige Methode ausgeführt wurde und bestanden wurde, andernfalls wird der abhängige Test nicht ausgeführt. |
| Parallele Testausführung | Unterlassen Sie Die parallele Ausführung ist in JUnit nicht verfügbar | Ja TestNG unterstützt die parallele Ausführung von Tests, JUnit jedoch nicht. Es gibt eine TestNG-XML, in der die parallele Ausführung festgelegt werden kann |
| Maven Integration | Ja Beide Tools unterstützen die Maven-Integration | Ja Beide Tools unterstützen die Maven-Integration |
| Umsetzung von Annahmen | Ja Annahmen werden verwendet, um Tests zu überspringen, die auf bestimmten Annahmen oder Bedingungen basieren und dies gilt nur in JUnit. | Unterlassen Sie TestNG unterstützt keine Annahmen |
| Reihenfolge der Testausführung | Ja Junit unterstützt die Reihenfolge der Testausführung. | Ja TestNG unterstützt die Reihenfolge der Testausführung |
| Implementierung von Listenern | Ja JUnit unterstützt Listener nicht über Anmerkungen, sondern über die Listener-API. | Ja TestNG unterstützt Listener durch Anmerkungen. |
| Tests ignorieren | Ja Beide unterstützen das Deaktivieren von Tests, aber JUnit unterstützt das Deaktivieren von Tests für die Ausführung basierend auf unterschiedlichen Bedingungen | Ja Beide unterstützen das Deaktivieren von Tests |
| Berichterstattung | Ja JUnit muss in maven integriert werden, um HTML-Berichte zu erstellen | Ja TestNG verfügt über integrierte HTML-Berichte. Es kann auch in Maven oder externe Berichtsbibliotheken wie ATU-Berichte oder Extent-Berichte integriert werden |
Vergleich von Anmerkungen
TestNG und JUnit sind Unit-Testing-Frameworks aus der Welt von Java. Beide implementieren sehr engere und ähnliche Funktionen. In diesem Abschnitt werden wir einige Ähnlichkeiten bei der Implementierung einiger Funktionen untersuchen, während wir auch einige andere Funktionen sehen werden, die in JUnit und TestNG unterschiedlich implementiert sind.
# 1) Annotation der Testmethode
Es gibt keinen Unterschied in der Art und Weise, wie wir eine Methode als Testmethode sowohl in JUnit als auch in TestNG angeben.
| Einheit 5 | TestNG |
|---|---|
| @Prüfung | @Prüfung |
# 2) Suite-bezogene Anmerkung
- Eine Methode mit der Annotation @BeforeSuite wird einmal ausgeführt, bevor die aktuelle Testsuite ausgeführt wird.
- Diese Anmerkung gilt nur in TestNG.
| Einheit 5 | TestNG |
|---|---|
| Unzutreffend | @BeforeSuite |
# 3) Anmerkung für eine Methode vor der Klasse
Dies ist die Anmerkung für die Methode, die einmal ausgeführt werden soll, bevor die erste Testmethode in der Klasse ausgeführt wird.
| Einheit 5 | TestNG |
|---|---|
| @Vor allen | @Vor dem Unterricht |
# 4) Anmerkung zu einer Methode vor dem Test
- Diese Annotation wird einmal ausgeführt, bevor die Methoden im Tag von testng.xml deklariert wurden.
- Diese Anmerkung ist nur für TestNG verfügbar.
| Einheit 5 | TestNG |
|---|---|
| Unzutreffend | @BeforeTest |
# 5) Anmerkung für die Methode, die ausgeführt werden soll, bevor jede Methode mit @Test aufgerufen wird
| Einheit 5 | TestNG |
|---|---|
| @BeforeEach | @BeforeMethod |
# 6) Anmerkung für die Methode, die nach jeder Methode mit @ Test-Aufrufen ausgeführt werden soll
| Einheit 5 | TestNG |
|---|---|
| @Nach jedem | @ AfterMethod |
# 7) Anmerkung zur Methode nach dem Test
- Diese Annotation wird einmal ausgeführt, nachdem die Methoden im Tag von testng.xml deklariert wurden.
- Diese Anmerkung ist nur für TestNG verfügbar.
| Einheit 5 | TestNG |
|---|---|
| Unzutreffend | @ AfterTest |
# 8) Anmerkung zur Methode nach dem Unterricht
Dies ist die Anmerkung für die Methode, die einmal ausgeführt werden soll, nachdem die letzte Testmethode in der Klasse ausgeführt wurde.
| Einheit 5 | TestNG |
|---|---|
| @Schließlich | @Nach dem Unterricht |
# 9) Anmerkung zum Deaktivieren der Ausführung der Testmethode.
- JUnit 5 enthält eine Anmerkung zum Deaktivieren einer bestimmten Testausführung.
- TestNG stellt ein Attribut für @Test bereit, d. H. 'Aktiviert' mit dem booleschen Wert, der entscheidet, ob die Ausführung der Methode deaktiviert oder aktiviert wird
| Einheit 5 | TestNG |
|---|---|
| @ignorieren | @Test (aktiviert = falsch) |
Beziehen auf Tutorial 7 Überspringen der Ausführung um zu verstehen, wie Tests in JUnit4 vs JUnit 5 deaktiviert werden
# 10) Timeout-Annotation
Die Anmerkung ist für JUnit 5 und TestNG identisch
| Einheit 5 | TestNG |
|---|---|
| @ Test (Timeout = 2000) | @ Test (Timeout = 2000) |
# 11) Attribut 'Erwartete Ausnahme'
- Die Ausnahmeklasse gibt an, dass bei Ausführung des Tests die Ausnahme der angegebenen Klasse ausgelöst wird.
- Dies wird sowohl in JUnit als auch in TestNG unterstützt, wobei die Art und Weise, wie beide deklariert werden, unterschiedlich ist.
| Einheit 5 | TestNG | |
|---|---|---|
| @Test (erwartet = NullPointerException.class) | @Test (expectedException = NullPointerException.class) |
# 12) Suite-bezogene Anmerkung
- Eine Methode mit der Annotation @AfterSuite wird einmal ausgeführt, nachdem die aktuelle Testsuite ausgeführt wurde.
- Diese Anmerkung gilt nur in TestNG.
| Einheit 5 | TestNG |
|---|---|
| Unzutreffend | @ AfterSuite |
# 13) Gruppenbezogene Anmerkung
- Die Anmerkung ist nur in TestNG verfügbar.
- Die Methode mit der Annotation @BeforeGroups wird ausgeführt, bevor die zu einer bestimmten Gruppe gehörenden Testmethoden ausgeführt werden.
| Einheit 5 | TestNG | |
|---|---|---|
| Unzutreffend | @BeforeGroups |
- Die Anmerkung ist nur in TestNG verfügbar.
- Die Methode mit der Annotation @BeforeGroups wird ausgeführt, nachdem die zu einer bestimmten Gruppe gehörenden Testmethoden ausgeführt wurden.
| Einheit 5 | TestNG |
|---|---|
| Unzutreffend | @ AfterGroups |
# 14) Anmerkungen zur Ausführungsreihenfolge
Sowohl JUnit als auch TestNG unterstützen das explizite Festlegen der Reihenfolge der auszuführenden Tests. Mit anderen Worten: Festlegen der Priorität für Testfälle.
- JUnit 5 verfügt über die Annotation @TestMethodOrder () mit der integrierten Klasse des MethodOrderer-Pakets - Alphanumeric.class oder OrderAnnotation.class oder Random.class als Eingabeparameter für die Annotation.
Beziehen auf Tutorial 9 - Junit Test Execution Order Weitere Informationen zum Festlegen der Testausführungsreihenfolge in JUnit.
- TestNG enthält das Attribut 'Priorität' für die @ Test-Annotation, das einen numerischen Wert akzeptiert.
| Einheit 5 | TestNG |
|---|---|
| @TestMethodOrder (Alphanumeric.class) | @ Test (Priorität = 1) |
Grundprogramm für TestNG und JUnit 4
# 1) TestNG-Code
package newtest.com; import org.testng.annotations.Test; import org.testng.annotations.BeforeMethod; import org.testng.annotations.AfterMethod; import org.testng.annotations.DataProvider; import org.testng.annotations.BeforeClass; import org.testng.annotations.AfterClass; import org.testng.annotations.BeforeTest; import org.testng.annotations.AfterTest; import org.testng.annotations.BeforeSuite; import org.testng.annotations.AfterSuite; public class NewTestng { @Test(dataProvider = 'dp') public void f(Integer n, String s) { System.out.println(' * * * * * * *Parameterized method * * * * * * * * * '); System.out.println('Integer '+n+' String '+s); System.out.println(' * * * * * * * * * * * * * * * * '); } @BeforeMethod public void beforeMethod() { System.out.println('Before Method'); } @AfterMethod public void afterMethod() { System.out.println('After Method'); } @DataProvider public Object()() dp() { return new Object()() { new Object() { 1, 'a' }, new Object() { 2, 'b'}, }; } @BeforeClass public void beforeClass() { System.out.println('Before Class'); } @AfterClass public void afterClass() { System.out.println('After Class'); } @BeforeTest public void beforeTest() { System.out.println('Before Test'); } @AfterTest public void afterTest() { System.out.println('After Test'); } @BeforeSuite public void beforeSuite() { System.out.println('Before Suite'); } @AfterSuite public void afterSuite() { System.out.println('After Suite'); } } Erwartete Ausgabe:
# 2) JUnit 4 Code
package demo.tests; import static org.junit.Assert.*; import org.junit.After; import org.junit.Before; import org.junit.Test; import org.junit.BeforeClass; import org.junit.AfterClass; public class JunitTest { @Parameterized.Parameters public static Object()() data() { return new Object(3)(0); } @BeforeClass public static void beforeClass() { System.out.println('Before Class'; } @Before public void beforeMethod() { System.out.println('Before Method'); } @Test public void f() { System.out.println(' * * * * * * *test * * * * * * * * * '); int n=10; System.out.println('Integer '+n); System.out.println(' * * * * * * * * * * * * * * * * '); } @After public void afterMethod() { System.out.println('After Method'); } @AfterClass public static void afterClass() { System.out.println('After Class'); } } Erwartete Ausgabe:
JUnit 5 vs TestNG: Funktionsunterschied mit Beispielen
# 1) Testsuite
- Die Testsuite ist eine Sammlung von Tests, was bedeutet, dass wir mehrere Testfälle aus mehreren Klassen zusammenfassen.
- Der Ansatz, den TestNG Suite verwendet, ist anders und leistungsfähiger als der von JUnit.
Testsuite in JUnit 5
Lassen Sie uns kurz sehen, wie JUnit 5 die Testsuite anwendet.
Beziehen auf Tutorial 8 -JUnit Test Suites & Filtering Testfälle für ein besseres Verständnis der Implementierung der Testsuite in JUnit 4 und in JUnit 5.
@RunWith(JUnitPlatform.class) @SelectClasses({JUnit5TestCase1.class, JUnit5TestCase2.class }) public class JUnitTestSuite { } Testsuite in TestNG
TestNG verwendet das XML als folgende Vorlage, um alle logisch verbindenden Testklassen zu verpacken
# 2) Parametrisierter Test
Sowohl TestNG als auch JUnit ermöglichen die Parametrisierung von Tests, bei der dieselben Tests mit Datenvariationen ausgeführt werden.
Parametrisierter Test in JUnit 4
@RunWith(value=Parameterized.class) public class JUnitclass{ int n; public JUnitclass (int num){ this.n=num; } @Parameters public static Iterable data(){ Object()() objectArray =new Object()() {{1},{2},{3}}; returnArrays.asList(objectArray); } @Test public void Junittst(){ System.out.println(“Multiples of 2 are :”+ 2*n); } } Parametrisierter Test in TestNG
Es gibt zwei Möglichkeiten, wie Sie die Parametrisierung in TestNG verwenden können
- @Parameters und Durchlaufen von TestNG XML
- Anmerkung @DataProvider
a) @Parameters und Durchlaufen von TestNG XML
public class testins{ @Test @Parameters(value=”env_pd”) public void paramEnv(str env_pd){ If(env_pd=”QA”){ url=”definetest.com” } else if(env_pd=”accpt”){ url=”defineacc.com” }}} XML für das gleiche
b) DataProvider
Die DataProvider-Annotation gibt immer Object () () zurück, bei dem es sich um das Array von Objekten handelt.
@DataProvider(name='state') public Object()() getDataFromDataprovider(){ return new Object()() { { 'Maharashtra', 'Pune' }, { 'Karnataka', 'Bangalore' }, { 'Kerala', 'Trivandrum' } }; @Test(dataProvider=”state”) public void paramMethd(str stateName, str cityName){ System.out.println(stateName+” ”+cityName); } # 3) Zeitüberschreitung
Wenn ein bestimmter Test nicht in der festgelegten Zeit abgeschlossen wird, tritt eine Zeitüberschreitung auf. In anderen Fällen wird der Thread unterbrochen.
bestes Spionagegerät für Handys
Zeitüberschreitung in JUnit
Es gibt verschiedene Ansätze für die Timeout-Implementierung in JUnit. Diese sind:
- Verwenden Sie das übliche Zeitlimit mit bestimmten Millisekunden
- Timeout mit der Behauptung verwenden
- Globales Timeout verwenden
Wir werden ein detailliertes Tutorial haben, das sich auf das Timeout für JUnit 4 und JUnit 5 konzentriert.
Unten sehen Sie den Ausschnitt, der die Verwendung des üblichen Timeouts in JUnit 5 zeigt:
@Test(timeout = 5000) public void testTimeout() throws InterruptedException { while (true) { } } Das obige Test-Timeout nach 5 Sekunden.
Zeitüberschreitung in TestNG
Das TestNG verwendet auch die einfache Methode der Timeout-Implementierung:
@Test(timeout = 5000) public void testTimeout() throws InterruptedException { while (true) { } } # 4) Ausnahmetest
Der Ausnahmetest stellt sicher, dass diese vordefinierte Ausnahme, wenn sie ausgelöst wird, ordnungsgemäß abgefangen und in den Protokollen benachrichtigt wird.
Ausnahmetest in JUnit 4
Loadrunner Interview Fragen und Antworten für erfahrene
@Test (expected = NumberFormatException.class) public void converttoint() { Int j=Integer.parseInt(“Four”); } Es wird ein separates Tutorial geben, das Ausnahmen für JUnit 4 und 5 ausführlich behandelt.
Ausnahmetest in TestNG
Es gibt eine geringfügige Änderung in der Deklaration des Ausnahmetests in TestNG:
@Test (expectedExceptions = NumberFormatException.class) public void converttoint() { Int j=Integer.parseInt(“Four”); } # 5) Test deaktivieren
Sowohl TestNG als auch JUnit ermöglichen das Deaktivieren eines Tests zur Ausführung.
Deaktivierter Test in JUnit 5
@ Deaktivierte Annotation Bei Verwendung am Anfang der Klasse werden alle Tests innerhalb der Klasse zur Ausführung übersprungen. Die Annotation, die über einer bestimmten @ Test-Methode verwendet wird, dieser bestimmte Testfall ist für die Ausführung deaktiviert.
import org.junit.AfterClass; @Disabled('the testcase is under development') public class JUnitProgram { Test in TestNG deaktiviert
Mit TestNG kann ein Test die Ausführung für einen Test deaktivieren, wenn das Attribut 'enabled' von annotation @Test auf false gesetzt ist, und es wird aktiviert, wenn das Attribut auf true gesetzt ist. Wenn alle Tests innerhalb einer Klasse aktiviert werden müssen, markieren Sie für jede @ Test-Methode explizit enabled = true.
Unten finden Sie einen Codeausschnitt, der das Überspringen eines Tests demonstriert.
@Test(enabled=false) public void f_validate(){ // let us skip this function} # 6) Gruppentests
Es gab widersprüchliche Aussagen in mehreren Sites und Foren, in denen erwähnt wurde, dass JUnit die Gruppierung von Tests mit dem spezifischen Gruppennamen niemals unterstützt.
Anmerkungen @BeforeGroups und @AfterGroups werden nur mit TestNG geliefert. Die Gruppierung ist jedoch sowohl in JUnit 4 als auch in JUnit 5 zulässig. Hier wird die Verwendung von Gruppentests in JUnit 5 schnell demonstriert. Gruppentests werden in JUnit 4 und Tags als Kategorien bezeichnet in JUnit 5.
Sie können sich beziehen Tutorial 8 - JUnit Test Suites & Filtering Tests Einzelheiten zur Verwendung in JUnit.
Gruppentests in JUnit 5
@Tag(“Regression”) @Test public void junitMethod1(){} @Tag(“SmokeTest”) @Test public void junitMethod2(){ Code-Snippet aus JUnit5TestSuite.java:
Der folgende Code enthält die Gruppe mit dem Namen 'Regression' und schließt die Gruppe 'SmokeTest' aus, aus der hervorgeht, dass junitMethod1 () ausgeführt wird, junitMethod2 () jedoch ausgeschlossen ist.
@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludeTags(“Regression”) @ExcludeTags(“SmokeTest”) public class JUnit5TestSuite { } Gruppentests in TestNG
Wenn das obige Snippet in TestNG interpretiert werden muss, ist unten der Code für dasselbe:
@Test(groups={“Regression” }) public void junitMethod1(){} @Test(groups={“SmokeTest” }) public void junitMethod2(){} TestNG XML lautet wie folgt:
Hier sind die Regressionsgruppenmethoden im Runner enthalten, während der Rest der Gruppen einschließlich SmokeTest ausgeschlossen ist.
# 7) Parallele Tests
Dies ist die Funktion, die nur mit TestNG verfügbar ist. Normalerweise sind Testfälle Threads, die nacheinander aufgerufen werden. Wenn Sie jedoch Ausführungszeit sparen möchten, können Sie dies in TestNG steuern, indem Sie die parallel auszuführenden Tests festlegen und die Anzahl der Threads angeben, die gleichzeitig ausgeführt werden müssen.
Wir werden hier kurz demonstrieren, dass die Verwendung von Methoden abhängt und nicht von Gruppen abhängt.
Der abhängige Test von einer anderen Methode wird über das TestNG-XML wie folgt festgelegt:
# 8) Abhängige Tests
Abhängige Tests sind erweiterte Funktionen, die nur mit TestNG verfügbar sind. Die Abhängigkeiten können sich auf einen Test oder eine Gruppe beziehen.
@Test mytest1(){ System.out.println(“My test : mytest1”); } @Test (dependensOnMethods={“mytest1”}) public void mytest2(){ System.out.println(“My test : mytest2”); } Da mytest2 im obigen Programm von mytest1 abhängt, wird zuerst mytest1 und dann mytest2 ausgeführt. Wenn mytest1 fehlschlägt, wird mytest2 nicht aufgerufen. Auf diese Weise können abhängige Testfälle vordefiniert werden, um einen bestimmten Workflow zu steuern, den Sie ausführen möchten.
# 9) Zuhörer
Listener hören jedes Ereignis, das innerhalb von Tests auftritt. Listener werden sowohl in JUnit als auch in TestNG unterstützt. Wenn Sie also bestimmte Aufgaben ausführen oder eine bestimmte Meldung im Protokoll anzeigen möchten, bevor der Test beginnt, nachdem der Test beendet ist, wenn der Test übersprungen wird, wenn der Test bestanden wurde oder fehlgeschlagen ist, verfügen wir über diese Listener-Funktionen, die es uns ermöglichen mach das
JUnit verwendet die Listener-Klasse und TestNG verwendet eine Listener-Schnittstelle. TestNG schreibt eine Listener-Klasse, die die Listener-Schnittstellenmethoden definiert. Der zweite Schritt besteht darin, diesen Listener-Klassennamen mithilfe der Annotation @Listeners in der Hauptklasse aufzurufen.
JUnit erbt auch die Methoden von der übergeordneten Listener-Klasse, nach der eine Listener-Runner-Klasse definiert wird, um die Listener-Funktionen auf eine oder mehrere Hauptklassen anzuwenden.
Listener in TestNG
Es gibt eine ITestListener-Schnittstelle, über die TestNG implementiert wird.
Nachfolgend sind die Methoden aufgeführt, die bei der Implementierung von ITestListener definiert werden müssen:
- OnTestStart ()
- OnTestFailure ()
- OnTestSuccess ()
- OnTestSkipped ()
- Am Start()
- OnFinish ()
Unten finden Sie einen Codeausschnitt, der onTestStart () und onTestSuccess () demonstriert.
import org.testng.ITestListener; import org.testng.ITestResult; public class TestListener implements ITestListener { @Override public void onTestStart(ITestResult result) { System.out.println('Execution started: '+result.getName()); } @Override public void onTestSuccess(ITestResult result) { System.out.println('Test Passed '+result.getName()); } Rufen Sie diese Listener-Klasse in Ihrer Hauptklasse wie unten gezeigt mit der Annotation @Listener auf:
import org.testng.annotations.Listeners; import org.testng.annotations.Test; @Listeners(com.javatpoint.Listener.class) public class MymainClass { @Test public void sum() { Listener in JUnit 5
RunListener ist die Klasse, die von Ihrer Listener-Klasse erweitert werden muss, um die Listener-Funktionen zu definieren.
Wir haben folgende Methoden für JUnit:
- testRunStarted
- testRunFinished
- testFailure
- tesIgnored
import org.junit.runner.notification.Failure; import org.junit.runner.notification.RunListener; public class Mylistenerclass extends RunListener { public void testRunStarted(Description desc) throws java.lang.Exception { System.out.println('Execution started' + desc.getMethodName()); } public void testRunFinished(Description desc) throws java.lang.Exception { System.out.println('Execution finished' + desc.getMethodName()); } Es muss eine Listener-Ausführungsklasse erstellt werden, um die obige Listener-Klasse aufzurufen.
Sie können die Listener-Mylistener-Klasse mit Testmethoden auf mehrere Klassen anwenden.
public class ListenerRunner { public static void main(String() args) { JUnitCore runme = new JUnitCore(); runme.addListener(new ListenerRunner()); runner.run(FirstClass.class, SecondClass.class); } Fazit
In diesem Tutorial zu JUnit Vs TestNG haben wir TestNG- und JUnit-Frameworks verglichen. Wir haben die allgemeinen Funktionen kennengelernt, die sowohl in den Frameworks als auch in zusätzlichen Funktionen unterstützt werden, die nur in TestNG unterstützt werden. Anscheinend gibt es nur in TestNG einige zusätzliche Funktionen, wie parallele Ausführung und Abhängigkeitstests. Die meisten von TestNG unterstützten Funktionen sind auch in JUnit verfügbar.
Es gibt geringfügige Abweichungen in Bezug auf Syntax, Terminologien in JUnit und TestNG für die gemeinsamen Funktionen. Diejenigen, die die Stärke von JUnit gegenüber TestNG untergraben haben, hätten bis jetzt erkannt, dass JUnit auch eines der leistungsstarken Automatisierungsframeworks ist.
Wir werden mit vielen weiteren interessanten Aspekten von JUnit zurückkommen. Bleib bei den kommenden Tutorials !!!
Literatur-Empfehlungen
- JUnit Tutorial für Anfänger - Was ist JUnit Testing?
- Liste der JUnit-Anmerkungen: JUnit 4 Vs JUnit 5
- Verwendung von JUnit 5 Annotation @RepeatedTest mit Beispielen
- JUnit Ignore Test Case: JUnit 4 @Ignore Vs JUnit 5 @Disabled
- TestNG-Installation, Basisprogramm und Berichte
- TestNG Anmerkungen und Listener
- TestNG Tutorial: Einführung in TestNG Framework
- Behauptungen in Selen unter Verwendung von Junit- und TestNG-Frameworks