junit vs testng what are differences
En omfattende sammenligning mellem JUnit Vs TestNG rammer. Inkluderer sammenligning af kommentarer og funktionssammenligning med eksempler:
I den forrige tutorial lærte vi DisplayName-annotering og betinget testudførelse baseret på forskellige kriterier som JRE-version, miljøvariabler osv. Vi behandlede også nogle vigtige spørgsmål omkring emnet.
Da vi løbende har lært om JUnit i tidligere tutorials, vil denne fungere som en vejrtrækning for vores publikum, da vi i et stykke tid vil skifte vores fokus fra JUnit som den eneste dagsorden til sammenligningen mellem JUnit vs TestNG.
=> Tjek den perfekte JUnit-træningsvejledning her.
Hvad du lærer:
- JUnit Vs TestNG: En sammenligning
- Konklusion
JUnit Vs TestNG: En sammenligning
| Funktioner | JUnit | TestNG |
|---|---|---|
| Timeout for test | Ja | Ja |
| Åbningskilde ramme | Ja JUnit er en opensource-ramme | Ja TestNG er en opensource-ramme |
| Brugervenlig | JUnit er fordelt på forskellige moduler, eksempel: ? Til parametrering har du muligvis brug for JUnit Jupiter. ? Dette gør JUnit lidt besværligt at bruge sammenlignet med TestNG | Alle TestNG-funktioner findes i et modul. Dette gør TestNG mere brugervenligt. |
| Større IDE support ( Eksempel: Formørkelse, IntelliJ) | Ja Begge understøtter det meste af IDE lige meget | Ja Begge understøtter det meste af IDE lige meget |
| Implementering af kommentarer | Ja JUnit arbejder på annoteringer med små variationer for forskellige funktioner | Ja TestNG arbejder på annoteringer med små variationer for forskellige funktioner |
| Implementering af påstande | Ja JUnit giver tilstrækkelige påstande til at validere forventede og faktiske resultater med nogle variationer til påstande i TestNG | Ja TestNG understøtter også en enorm liste over påstande til sammenligning af forventede og faktiske resultater. Derudover leverer TestNG to mekanismer til påstande - Soft Assertion og Hard Assertion |
| Undtagelser | Ja JUnit giver funktionen til undtagelsestest med en lille variation til TestNG | Ja TestNG leverer også funktionen til undtagelsestest |
| Parameteriserede tests | Ja JUnit understøtter parametriserede tests | Ja TestNG understøtter også parametriserede tests |
| Test Suite | Ja JUnit understøtter brug af testsuiter | Ja TestNG understøtter også Test Suite. |
| Afhængighedstest | Lade være med JUnit understøtter ikke funktionen til afhængighedstest | Ja Dette er en avanceret funktion i TestNG over JUnit. Med denne funktion kan en metode gøres afhængig af en anden, således at metoden kun kører, efter at den afhængige metode kører og består ellers, afhænger den afhængige test ikke. |
| Parallel testudførelse | Lade være med Parallel udførelse er ikke tilgængelig i JUnit | Ja TestNG understøtter parallel udførelse af tests, men JUnit gør det ikke. Der er en TestNG xml, hvor parallel udførelse kan indstilles |
| Maven Integration | Ja Begge værktøjer understøtter Maven Integration | Ja Begge værktøjer understøtter Maven Integration |
| Implementeringer af antagelser | Ja Antagelser bruges til at springe tests over baseret på visse antagelser eller betingelser og dette gælder kun i JUnit. | Lade være med TestNG understøtter ikke antagelser |
| Bestilling af testudførelse | Ja Junit understøtter rækkefølgen af testudførelse. | Ja TestNG understøtter rækkefølge for testudførelse |
| Implementering af lyttere | Ja JUnit understøtter lyttere ikke gennem annoteringer, men gennem lytterens API. | Ja TestNG understøtter lyttere gennem annoteringer. |
| Ignorer test | Ja Begge understøtter deaktivering af tests, men JUnit understøtter deaktivering af tests til udførelse baseret på forskellige forhold | Ja Begge understøtter deaktivering af test |
| Rapportering | Ja JUnit skal integreres med maven for at generere HTML-rapporter | Ja TestNG har sine indbyggede HTML-rapporter. Det kan integreres med maven såvel som eksterne rapporteringsbiblioteker som ATU-rapport eller Omfangsrapporter |
Sammenligning af kommentarer
TestNG og JUnit er begge enhedstestningsrammer fra Java-verdenen. Begge implementerer meget tættere og lignende funktioner. I dette afsnit skal vi se på nogle ligheder i implementeringen af et par funktioner, mens vi også får se et par andre funktioner, der implementeres forskelligt i JUnit og TestNG.
# 1) Annotering af testmetode
Der er ingen forskel i den måde, vi specificerer en metode som en testmetode i både JUnit og TestNG.
| JUnit 5 | TestNG |
|---|---|
| @Prøve | @Prøve |
# 2) Suite-relateret kommentar
- En metode med kommentar @BeforeSuite udføres en gang, før den aktuelle testpakke kører.
- Denne kommentar gælder kun i TestNG.
| JUnit 5 | TestNG |
|---|---|
| Ikke anvendelig | @BeforeSuite |
# 3) Kommentar til en metode før klasse
Dette er kommentaren for, at metoden skal udføres en gang, før den første testmetode i klassen køres.
| JUnit 5 | TestNG |
|---|---|
| @BeforeAll | @BeforeClass |
# 4) Kommentar til en metode før test
- Denne kommentar udføres en gang før de metoder, der er erklæret i tagget for testng.xml.
- Denne kommentar er kun tilgængelig for TestNG.
| JUnit 5 | TestNG |
|---|---|
| Ikke anvendelig | @BeforeTest |
# 5) Bemærkning om, at metoden skal udføres, før hver metode med @Test påberåber sig
| JUnit 5 | TestNG |
|---|---|
| @BeforeEach | @BeforeMethod |
# 6) Kommentar til den metode, der skal udføres efter hver metode med @Test påberåber sig
| JUnit 5 | TestNG |
|---|---|
| @AfterEach | @AfterMethod |
# 7) Kommentar til metode efter test
- Denne kommentar udføres én gang efter de metoder, der er erklæret i tagget for testng.xml.
- Denne kommentar er kun tilgængelig for TestNG.
| JUnit 5 | TestNG |
|---|---|
| Ikke anvendelig | @AfterTest |
# 8) Kommentar til metode efter klasse
Dette er kommentaren for, at metoden skal udføres en gang, efter at den sidste testmetode i klassen er kørt.
| JUnit 5 | TestNG |
|---|---|
| @Trods alt | @Efter skole |
# 9) Kommentar for at deaktivere udførelsen af testmetoden.
- JUnit 5 giver en kommentar for at deaktivere en specifik testudførelse.
- TestNG leverer en attribut til @Test, dvs. 'aktiveret' med den boolske værdi, der bestemmer, om udførelsen af metoden ville være deaktiveret eller aktiveret
| JUnit 5 | TestNG |
|---|---|
| @ignorere | @Test (aktiveret = falsk) |
Henvise til Tutorial 7 Spring over udførelse at forstå, hvordan du deaktiverer test i JUnit4 vs JUnit 5
# 10) Timeout-kommentar
Annotationen er den samme for JUnit 5 og TestNG
| JUnit 5 | TestNG |
|---|---|
| @Test (timeout = 2000) | @Test (timeout = 2000) |
# 11) Forventet undtagelsesattribut
- Undtagelsesklasse angiver, at når testen udføres, kastes undtagelsen fra den givne klasse.
- Dette understøttes både i JUnit og TestNG med variation i den måde, begge erklæres på.
| JUnit 5 | TestNG | |
|---|---|---|
| @Test (forventet = NullPointerException.class) | @Test (forventetException = NullPointerException.class) |
# 12) Suite-relateret kommentar
- En metode med kommentar @AfterSuite udføres en gang, efter at den aktuelle testpakke kører.
- Denne kommentar gælder kun i TestNG.
| JUnit 5 | TestNG |
|---|---|
| Ikke anvendelig | @AfterSuite |
# 13) Grupperelateret kommentar
- Annotationen er kun tilgængelig i TestNG.
- Metoden med kommentar @BeforeGroups kører, før testmetoderne, der tilhører en bestemt gruppe, køres.
| JUnit 5 | TestNG | |
|---|---|---|
| Ikke anvendelig | @BeforeGroups |
- Annotationen er kun tilgængelig i TestNG.
- Metoden med annotering @BeforeGroups kører efter testmetoderne, der tilhører en bestemt gruppekørsel.
| JUnit 5 | TestNG |
|---|---|
| Ikke anvendelig | @AfterGroups |
# 14) Bekendtgørelse om udførelsesrelaterede kommentarer
Både JUnit og TestNG understøtter eksplicit indstilling af rækkefølgen af test til udførelse. Med andre ord, indstilling af prioritet for testsager.
- JUnit 5 har kommentar @ TestMethodOrder () med MethodOrderer-pakkens indbyggede klasse - Alphanumeric.class eller OrderAnnotation.class eller Random.class som inputparameter til kommentaren.
Henvise til Tutorial 9 - Junit Test Execution Order for flere detaljer om indstilling af testudførelsesordre i JUnit.
- TestNG inkluderer attributten 'prioritet' til @Test-kommentar, som accepterer en numerisk værdi.
| JUnit 5 | TestNG |
|---|---|
| @TestMethodOrder (alfanumerisk.klasse) | @Test (prioritet = 1) |
Grundprogram til TestNG og JUnit 4
# 1) TestNG-kode
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'); } } Forventet output:
# 2) JUnit 4-kode
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'); } } Forventet output:
JUnit 5 vs TestNG: Funktionsforskel med eksempler
# 1) Test Suite
- Testpakken er en samling af test, hvilket betyder, at vi slags indpakker flere testsager fra flere klasser sammen.
- Den tilgang, TestNG bruger suite, er anderledes og stærk i forhold til JUnit.
Testpakke i JUnit 5
Lad os hurtigt se på, hvordan JUnit 5 anvender testpakken.
Henvise til Tutorial 8 -JUnit Test Suites & Filtering Testcases for en bedre forståelse af implementeringen af testpakken i JUnit 4 og i JUnit 5.
@RunWith(JUnitPlatform.class) @SelectClasses({JUnit5TestCase1.class, JUnit5TestCase2.class }) public class JUnitTestSuite { } Test suite i TestNG
TestNG bruger XML som nedenstående skabelon til at pakke alle de logisk forbundne testklasser
# 2) Parameteriseret test
Både TestNG og JUnit tillader parametrering af tests, som kun er at køre de samme tests med datavariationer.
Parameteriseret test i 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); } } Parametreret test i TestNG
Der er to måder, hvorpå du kan bruge parametrering i TestNG
- @Parameters og passerer gennem TestNG XML
- Annotation @ DataProvider
a) @Parameters og passerer gennem 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 for det samme
b) DataProvider
DataProvider-kommentaren returnerer altid Objekt () (), som er arrayet af objekter.
@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) Timeout
Hvis en bestemt test ikke gennemføres i den fastsatte tid, får den en timeout. I andre tilfælde afbrydes tråden.
c ++ og java forskelle
Timeout i JUnit
Der er forskellige tilgange til implementering af Timeout i JUnit. Disse er:
- Brug af den sædvanlige timeout med specifikke millisekunder
- Brug af timeout med påstanden
- Brug af global timeout
Vi vil have en detaljeret tutorial, der fokuserer på timeout til JUnit 4 og JUnit 5.
Nedenfor er uddraget, der viser brugen af den sædvanlige timeout i JUnit 5:
@Test(timeout = 5000) public void testTimeout() throws InterruptedException { while (true) { } } Ovenstående test-timeout efter 5 sekunder.
Timeout i TestNG
TestNG bruger også den enkle måde at implementere Timeout på:
@Test(timeout = 5000) public void testTimeout() throws InterruptedException { while (true) { } } # 4) Undtagelsestest
Undtagelsestest sørger for, at når der er kastet denne foruddefinerede undtagelse, fanges den yndefuldt og underrettes om logfiler.
Undtagelsestest i JUnit 4
@Test (expected = NumberFormatException.class) public void converttoint() { Int j=Integer.parseInt(“Four”); } Der vil være en separat tutorial, der dækker undtagelser for JUnit 4 og 5 i detaljer.
Undtagelsestest i TestNG
Der er en lille ændring i erklæringen om undtagelsestest i TestNG:
@Test (expectedExceptions = NumberFormatException.class) public void converttoint() { Int j=Integer.parseInt(“Four”); } # 5) Deaktiver test
Både TestNG og JUnit tillader deaktivering af en test til udførelse.
Deaktiveret test i JUnit 5
@Deaktiveret kommentar, når den bruges øverst i klassen, springes alle testene i klassen over til udførelse. Kommentaren, når den bruges oven på en bestemt @Test-metode, er den specifikke testtilstand deaktiveret til udførelse.
import org.junit.AfterClass; @Disabled('the testcase is under development') public class JUnitProgram { Deaktiveret test i TestNG
TestNG tillader, at en test deaktiverer eksekvering af en test, når attributten 'aktiveret' for kommentar @Test er sat til falsk, og den er aktiveret, når attributten er sat til sand. Hvis alle tests inden for en klasse skal aktiveres, skal du eksplicit markere aktiveret = sand for hver @Test-metode.
Nedenfor er kodestykket, der viser springet over en test.
@Test(enabled=false) public void f_validate(){ // let us skip this function} # 6) Gruppetest
Der har været modstridende udsagn på flere steder og fora, hvor folk har nævnt, at JUnit aldrig støttede grupperingen af tests med det specifikke gruppenavn.
Annotationer @BeforeGroups og @AfterGroups kommer kun med TestNG, men gruppering er tilladt i JUnit 4 såvel som i JUnit 5. Her viser vi hurtigt brugen af gruppetests i JUnit 5. Gruppetest kaldes kategorier i JUnit 4 og tags i JUnit 5.
Du kan henvise til Tutorial 8 - JUnit Test Suites & Filtering Tests for detaljer om brugen i JUnit.
Gruppetest i JUnit 5
@Tag(“Regression”) @Test public void junitMethod1(){} @Tag(“SmokeTest”) @Test public void junitMethod2(){ Kodestykke fra JUnit5TestSuite.java:
Nedenstående kode inkluderer gruppen med navnet 'Regression' og ekskluderer gruppen 'SmokeTest', som udleder, at junitMethod1 () køres, men junitMethod2 () er ekskluderet.
@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludeTags(“Regression”) @ExcludeTags(“SmokeTest”) public class JUnit5TestSuite { } Gruppetest i TestNG
ado.net spørgsmål og svar til erfarne
Hvis ovenstående uddrag skal fortolkes i TestNG, er nedenstående kode for det samme:
@Test(groups={“Regression” }) public void junitMethod1(){} @Test(groups={“SmokeTest” }) public void junitMethod2(){} TestNG XML er som følger:
Her er Regression-gruppemetoderne inkluderet i løberen, mens resten af grupperne inklusive SmokeTest er ekskluderet.
# 7) Parallelle tests
Dette er den funktion, der kun er tilgængelig med TestNG. Normalt er testsager slags tråde, der påberåbes den ene efter den anden. Men hvis du ønsker at spare på udførelsestiden, kan du kontrollere dette i TestNG ved at indstille testene, der skal køres parallelt, og angive det antal tråde, der skal køre på én gang.
Vi vil kort demonstrere brugen af afhænger af metoder her og vil ikke diskutere afhænger af grupper.
Den afhængige test på en anden metode indstilles via TestNG XML som følger:
# 8) Afhængige tests
Afhængige tests er avancerede funktioner, der kun er tilgængelige med TestNG. Afhængighederne kan være på en test eller på en gruppe.
@Test mytest1(){ System.out.println(“My test : mytest1”); } @Test (dependensOnMethods={“mytest1”}) public void mytest2(){ System.out.println(“My test : mytest2”); } I det ovennævnte program, da mytest2 afhænger af mytest1, køres først mytest1 og derefter mytest2. Hvis mytest1 mislykkes, påberåbes mytest2 ikke. Dette er, hvordan afhængige testtilfælde kan foruddefineres til at styre en bestemt arbejdsgang, du ønsker at udføre.
# 9) Lyttere
Lyttere lytter til hver begivenhed, der finder sted inden for test. Lyttere understøttes både i JUnit såvel som TestNG. Så hvis du ønsker at udføre bestemte opgaver eller vise en bestemt besked i loggen, før testen starter, efter at testen er færdig, når testen springes over, når testen er bestået eller mislykkes, har vi disse lytterfunktioner, der gør det muligt for os at gør dette
JUnit bruger klassen Listener, og TestNG bruger en Listener-grænseflade. TestNG skriver en lytterklasse, der definerer lyttergrænseflademetoderne, og det andet trin er at kalde dette lytterklassens navn ved hjælp af @Listeners-kommentar i hovedklassen.
JUnit arver også metoderne fra den overordnede klasse Listener, hvorefter en Listener-løberklasse er defineret til at anvende lytterfunktionerne på en eller flere hovedklasser.
Lytter i TestNG
Der er en ITestListener-grænseflade, hvorfra TestNG implementeres.
Nedenfor er de metoder, der skal defineres, når ITestListener implementeres -
- OnTestStart ()
- OnTestFailure ()
- OnTestSuccess ()
- OnTestSkipped ()
- OnStart ()
- OnFinish ()
Nedenfor er kodestykket, der demonstrerer onTestStart () og onTestSuccess ()
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()); } Ring til denne lytterklasse i din hovedklasse som vist nedenfor ved hjælp af kommentar @Listener:
import org.testng.annotations.Listeners; import org.testng.annotations.Test; @Listeners(com.javatpoint.Listener.class) public class MymainClass { @Test public void sum() { Lytteren i JUnit 5
RunListener er den klasse, der skal udvides af din lytterklasse for at definere lytterfunktionerne.
Vi har metoder som følger for JUnit:
- testRunStarted
- testRunFinished
- testFejl
- tesIgnoreret
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()); } Der skal være en lytteudførelsesklasse, der skal oprettes for at påkalde ovenstående lytterklasse.
Du kan anvende Mylistener-klassen til lytter til flere klasser med testmetoder.
public class ListenerRunner { public static void main(String() args) { JUnitCore runme = new JUnitCore(); runme.addListener(new ListenerRunner()); runner.run(FirstClass.class, SecondClass.class); } Konklusion
I denne JUnit Vs TestNG tutorial har vi sammenlignet TestNG og JUnit rammer. Vi lærte de almindelige funktioner, der understøttes i både rammerne samt yderligere funktioner, der kun understøttes i TestNG. Tilsyneladende er der kun et par ekstra funktioner i TestNG, som parallelkørsel og afhængighedstest. De fleste af de funktioner, der understøttes af TestNG, er også tilgængelige i JUnit.
Der er små afvigelser med hensyn til syntaks, terminologier i JUnit vs TestNG for de fælles træk. De, der underminerede styrken af JUnit over TestNG, ville have realiseret indtil nu, dvs. JUnit er også en af de stærke automatiseringsrammer.
Vi kommer tilbage med mange flere interessante aspekter af JUnit. Hold dig til de kommende tutorials !!!
Anbefalet læsning
- JUnit Tutorial for begyndere - Hvad er JUnit-test
- Liste over JUnit-kommentarer: JUnit 4 Vs JUnit 5
- Sådan bruges JUnit 5-kommentar @RepeatedTest med eksempler
- JUnit Ignore Test Case: JUnit 4 @Ignore Vs JUnit 5 @Disabled
- TestNG-installation, grundlæggende program og rapporter
- TestNG-kommentarer og lyttere
- TestNG Tutorial: Introduktion til TestNG Framework
- Påstande i selen ved hjælp af Junit og TestNG Frameworks