junit vs testng what are differences
En omfattande jämförelse mellan JUnit Vs TestNG-ramar. Inkluderar jämförelse av anteckningar och jämförelse med exempel med exempel:
I föregående handledning lärde vi oss DisplayName-anteckningar och villkorligt testkörning baserat på olika kriterier som JRE-version, miljövariabler etc. Vi tog också upp några viktiga frågor kring ämnet.
Eftersom vi kontinuerligt har lärt oss om JUnit i tidigare tutorials kommer den här att fungera som en andning för vår publik eftersom vi ett tag kommer att flytta vårt fokus från JUnit som enda dagordning till jämförelsen mellan JUnit vs TestNG.
=> Kolla in den perfekta JUnit-träningsguiden här.
Vad du kommer att lära dig:
- JUnit Vs TestNG: En jämförelse
- Slutsats
JUnit Vs TestNG: En jämförelse
| Funktioner | JUnit | TestNG |
|---|---|---|
| Tidsgräns för tester | Ja | Ja |
| Öppnar källans ram | Ja JUnit är ett open source-ramverk | Ja TestNG är ett open source-ramverk |
| Användarvänlig | JUnit distribueras över olika moduler, exempel: ? För parametrering kan du behöva JUnit Jupiter. ? Detta gör JUnit något besvärligt att använda jämfört med TestNG | Alla TestNG-funktioner finns i en modul. Detta gör TestNG mer användarvänligt. |
| Stort IDE-stöd ( Exempel: Eclipse, IntelliJ) | Ja Båda stöder större delen av IDE lika | Ja Båda stöder större delen av IDE lika |
| Implementering av anteckningar | Ja JUnit arbetar med anteckningar med små variationer för olika funktioner | Ja TestNG arbetar med anteckningar med små variationer för olika funktioner |
| Implementering av påståenden | Ja JUnit ger tillräckligt med påståenden för att validera förväntade och faktiska resultat med vissa variationer i påståenden i TestNG | Ja TestNG stöder också en enorm lista med påståenden för jämförelse av förväntade och faktiska resultat. Dessutom tillhandahåller TestNG två mekanismer för påståenden - Soft Assertion och Hard Assertion |
| Undantag | Ja JUnit tillhandahåller funktionen för undantagstest med en liten variation till TestNG | Ja TestNG tillhandahåller också funktionen för undantagstest |
| Parametrerade tester | Ja JUnit stöder parametrerade tester | Ja TestNG stöder också parametrerade tester |
| Test svit | Ja JUnit stöder användning av testsviter | Ja TestNG stöder också Test Suite. |
| Beroendestest | Nej JUnit stöder inte funktionen för beroendestest | Ja Detta är en avancerad funktion i TestNG över JUnit. Med den här funktionen kan en metod göras beroende av den andra så att metoden bara körs efter att den beroende metoden har körts och annars går det beroende testet inte. |
| Parallell testutförande | Nej Parallell körning är inte tillgänglig i JUnit | Ja TestNG stöder parallell körning av tester men JUnit gör det inte. Det finns en TestNG xml där parallell körning kan ställas in |
| Maven Integration | Ja Båda verktygen stöder Maven Integration | Ja Båda verktygen stöder Maven Integration |
| Implementeringar av antaganden | Ja Antaganden används för att hoppa över tester baserat på vissa antaganden eller villkor och detta är endast tillämpligt i JUnit. | Nej TestNG stöder inte antaganden |
| Order för testutförande | Ja Junit stöder orderns utförande av test. | Ja TestNG stöder ordning på utförande av test |
| Implementering av lyssnare | Ja JUnit stöder lyssnare inte genom anteckningar utan via lyssnarens API. | Ja TestNG stöder lyssnare genom anteckningar. |
| Ignorera tester | Ja Båda stöder inaktivera tester men JUnit stöder inaktivera tester för körning baserat på olika förhållanden | Ja Båda stöder inaktivera tester |
| Rapportering | Ja JUnit måste integreras med maven för att generera HTML-rapporter | Ja TestNG har sina inbyggda HTML-rapporter. Det kan integreras med maven samt externa rapporteringsbibliotek som ATU-rapport eller Extent-rapporter |
Jämförelse av kommentarer
TestNG och JUnit är båda enhetstestramar från Java-världen. Båda implementerar mycket närmare och liknande funktioner. I det här avsnittet ska vi titta på några likheter med att implementera ett par funktioner medan vi också skulle få se några andra funktioner som implementeras annorlunda i JUnit och TestNG.
# 1) Testmetodnotering
Det finns ingen skillnad i hur vi anger en metod som testmetod i både JUnit och TestNG.
| JUnit 5 | TestNG |
|---|---|
| @Testa | @Testa |
# 2) Svitrelaterad kommentar
- En metod med kommentar @BeforeSuite körs en gång innan den nuvarande testsviten körs.
- Denna kommentar gäller endast i TestNG.
| JUnit 5 | TestNG |
|---|---|
| Inte tillämpbar | @BeforeSuite |
# 3) Kommentar för en metod före klass
Detta är anteckningen om att metoden ska köras en gång innan den första testmetoden i klassen körs.
| JUnit 5 | TestNG |
|---|---|
| @BeforeAll | @Innan lektionen |
# 4) Kommentar för en metod före testet
- Denna kommentar körs en gång innan metoderna deklareras inuti taggen för testng.xml.
- Denna kommentar är endast tillgänglig för TestNG.
| JUnit 5 | TestNG |
|---|---|
| Inte tillämpbar | @BeforeTest |
# 5) Anmärkning för metoden som ska köras före varje metod med @Test åberopar
| JUnit 5 | TestNG |
|---|---|
| @BeforeEach | @BeforeMethod |
# 6) Anmärkning för metoden som ska köras efter varje metod med @Test åberopar
| JUnit 5 | TestNG |
|---|---|
| @EfterEach | @AfterMethod |
# 7) Kommentar för metod efter test
- Denna kommentar körs en gång efter de metoder som deklarerats inuti taggen för testng.xml.
- Denna kommentar är endast tillgänglig för TestNG.
| JUnit 5 | TestNG |
|---|---|
| Inte tillämpbar | @AfterTest |
# 8) Kommentar för metod efter klass
Detta är anteckningen för metoden som ska köras en gång efter att den sista testmetoden i klassen har körts.
| JUnit 5 | TestNG |
|---|---|
| @Trots allt | @Efter lektionen |
# 9) Kommentar för att inaktivera körningen av testmetoden.
- JUnit 5 ger en kommentar för att inaktivera en specifik testkörning.
- TestNG tillhandahåller ett attribut för @Test dvs 'aktiverat' med det booleska värdet som avgör om körningen av metoden skulle inaktiveras eller aktiveras
| JUnit 5 | TestNG |
|---|---|
| @ignorera | @Test (aktiverat = falskt) |
Hänvisa till Självstudie 7 Hoppa över utförande för att förstå hur man inaktiverar tester i JUnit4 vs JUnit 5
# 10) Timeout-kommentar
Anteckningen är densamma för JUnit 5 och TestNG
| JUnit 5 | TestNG |
|---|---|
| @Test (timeout = 2000) | @Test (timeout = 2000) |
# 11) Förväntat undantagsattribut
- Undantagsklass anger att när testet körs kastas undantaget för den angivna klassen.
- Detta stöds både i JUnit och TestNG med variation i hur båda deklareras.
| JUnit 5 | TestNG | |
|---|---|---|
| @Test (förväntat = NullPointerException.class) | @Test (expectException = NullPointerException.class) |
# 12) Svitrelaterad kommentar
- En metod med kommentar @AfterSuite körs en gång efter att den aktuella testsviten körs.
- Denna kommentar gäller endast i TestNG.
| JUnit 5 | TestNG |
|---|---|
| Inte tillämpbar | @AfterSuite |
# 13) Grupprelaterad kommentar
- Anteckningen är endast tillgänglig i TestNG.
- Metoden med anteckningen @BeforeGroups körs innan testmetoderna som tillhör en viss grupp körs.
| JUnit 5 | TestNG | |
|---|---|---|
| Inte tillämpbar | @BeforeGroups |
- Anteckningen är endast tillgänglig i TestNG.
- Metoden med anteckningen @BeforeGroups körs efter testmetoderna som tillhör en viss gruppkörning.
| JUnit 5 | TestNG |
|---|---|
| Inte tillämpbar | @AfterGroups |
# 14) Annoteringar relaterade till ordning för utförande
Både JUnit och TestNG stöder uttryckligen ordningen på testerna för körning. Med andra ord, ställa in prioritet för testfall.
- JUnit 5 har kommentar @ TestMethodOrder () med MethodOrderer-paketets inbyggda klass - Alphanumeric.class eller OrderAnnotation.class eller Random.class som ingångsparameter för kommentaren.
Hänvisa till Självstudie 9 - Junit Test Execution Order för mer information om inställning av testkörningsorder i JUnit.
- TestNG inkluderar attributet 'prioritet' för @Test-kommentar, som accepterar ett numeriskt värde.
| JUnit 5 | TestNG |
|---|---|
| @TestMethodOrder (alfanumerisk.klass) | @Test (prioritet = 1) |
Grundprogram för TestNG och JUnit 4
# 1) TestNG-kod
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'); } } Förväntad produktion:
# 2) JUnit 4-kod
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'); } } Förväntad produktion:
JUnit 5 vs TestNG: Funktionsskillnad med exempel
# 1) Test Suite
- Testpaketet är en samling tester, vilket innebär att vi typ av sluter samman flera testfall från flera klasser tillsammans.
- Metoden som TestNG använder är annorlunda och kraftfull jämfört med JUnit.
Testpaket i JUnit 5
Låt oss snabbt titta på hur JUnit 5 tillämpar testpaketet.
Hänvisa till Självstudie 8 -JUnit Test Suites & Filtering Testcases för en bättre förståelse för implementeringen av Test Suite i JUnit 4 och i JUnit 5.
@RunWith(JUnitPlatform.class) @SelectClasses({JUnit5TestCase1.class, JUnit5TestCase2.class }) public class JUnitTestSuite { } Testpaket i TestNG
TestNG använder XML som nedanstående mall för att slå in alla logiskt anslutande testklasser
# 2) Parameteriserat test
Både TestNG och JUnit tillåter parametrering av tester som bara är att köra samma tester med datavariationer.
Parameteriserat 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); } } Parameteriserat test i TestNG
Det finns två sätt att använda parametreringen i TestNG
- @Parameters och passerar genom TestNG XML
- Annotation @ DataProvider
a) @Parameters och passerar genom 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 samma
b) DataProvider
DataProvider-anteckningen returnerar alltid Object () () som är arrayen av objekt.
@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
Om ett visst test inte slutförts under den angivna tiden får det en timeout. I andra fall avbryts tråden.
hur man spelar mkv på pc
Timeout i JUnit
Det finns olika sätt att implementera Timeout i JUnit. Dessa är:
- Använd den vanliga timeout med specifika millisekunder
- Använda timeout med påståendet
- Använda global timeout
Vi kommer att ha en detaljerad handledning som fokuserar på timeout för JUnit 4 och JUnit 5.
Nedan är utdraget som visar användningen av den vanliga Timeout i JUnit 5:
@Test(timeout = 5000) public void testTimeout() throws InterruptedException { while (true) { } } Ovanstående test timeout efter 5 sekunder.
Timeout i TestNG
TestNG använder också det enkla sättet att implementera Timeout:
@Test(timeout = 5000) public void testTimeout() throws InterruptedException { while (true) { } } # 4) Undantagstest
Undantagstest ser till att när det här fördefinierade undantaget kastas, fångas det graciöst och meddelas i stockarna.
Undantagstest i JUnit 4
@Test (expected = NumberFormatException.class) public void converttoint() { Int j=Integer.parseInt(“Four”); } Det kommer att finnas en separat handledning som omfattar undantag för JUnit 4 och 5 i detalj.
Undantagstest i TestNG
Det finns en liten förändring i deklarationen om undantagstest i TestNG:
@Test (expectedExceptions = NumberFormatException.class) public void converttoint() { Int j=Integer.parseInt(“Four”); } # 5) Inaktivera test
Både TestNG och JUnit tillåter att inaktivera ett test för körning.
Inaktiverat test i JUnit 5
@Inaktiverad kommentar när den används högst upp i klassen hoppas alla tester inom klassen för körning. Anmärkningen när den används ovanpå en viss @Test-metod är det specifika testfallet inaktiverat för körning.
import org.junit.AfterClass; @Disabled('the testcase is under development') public class JUnitProgram { Inaktiverat test i TestNG
TestNG tillåter ett test att inaktivera körning för ett test när attributet 'aktiverat' för kommentar @Test är inställt på falskt och det är aktiverat när attributet är satt till true. Om alla tester inom en klass måste aktiveras markerar du uttryckligen aktiverat = sant för varje @Test-metod.
youtube musikvideor gratis nedladdningsprogramvara
Nedan är kodavsnittet som visar att ett test hoppas över.
@Test(enabled=false) public void f_validate(){ // let us skip this function} # 6) Grupptest
Det har varit motsägelsefulla uttalanden på flera webbplatser och forum där människor har nämnt att JUnit aldrig stödde grupperingen av tester med det specifika gruppnamnet.
Kommentarer @BeforeGroups och @AfterGroups kommer endast med TestNG men gruppering är tillåten i JUnit 4 liksom i JUnit 5. Här visar vi snabbt användningen av grupptest i JUnit 5. Grupptest kallas kategorier i JUnit 4 och Taggar i JUnit 5.
Du kan hänvisa till Självstudie 8 - JUnit Test Suites & Filtering Tests för information om användningen i JUnit.
Grupptester i JUnit 5
@Tag(“Regression”) @Test public void junitMethod1(){} @Tag(“SmokeTest”) @Test public void junitMethod2(){ Kodavsnitt från JUnit5TestSuite.java:
Koden nedan inkluderar gruppen med namnet 'Regression' och exkluderar gruppen 'SmokeTest' som hävdar att junitMethod1 () kommer att köras men junitMethod2 () utesluts.
@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludeTags(“Regression”) @ExcludeTags(“SmokeTest”) public class JUnit5TestSuite { } Grupptester i TestNG
Om kodavsnittet ovan måste tolkas i TestNG, nedan är koden för samma:
@Test(groups={“Regression” }) public void junitMethod1(){} @Test(groups={“SmokeTest” }) public void junitMethod2(){} TestNG XML är som följer:
Här ingår Regression-gruppmetoderna i löparen medan resten av grupperna inklusive SmokeTest exkluderas.
# 7) Parallella tester
Det här är funktionen som endast är tillgänglig med TestNG. Vanligtvis är testfall typ av trådar som åberopas efter varandra. Men om du vill spara på körningstiden kan du styra detta i TestNG genom att ställa in testerna som ska köras parallellt och ange antalet trådar som behöver köras på en gång.
Vi kommer i korthet att visa användningen av beror på metoder här och kommer inte att diskutera beror på grupper.
Det beroende testet på en annan metod ställs in via TestNG XML enligt följande:
# 8) Beroende tester
Beroende tester är avancerade funktioner som endast är tillgängliga med TestNG. Beroenden kan vara på ett test eller på en grupp.
@Test mytest1(){ System.out.println(“My test : mytest1”); } @Test (dependensOnMethods={“mytest1”}) public void mytest2(){ System.out.println(“My test : mytest2”); } I ovanstående program, eftersom mytest2 beror på mytest1, körs först mytest1 och sedan mytest2. Om mytest1 misslyckas kommer mytest2 inte att åberopas. Det här är hur beroende testfall kan fördefinieras för att styra ett specifikt arbetsflöde som du vill utföra.
# 9) Lyssnare
Lyssnare lyssnar på varje händelse som inträffar inom test. Lyssnare stöds både i JUnit såväl som i TestNG. Så om du vill utföra vissa uppgifter eller visa ett specifikt meddelande i loggen innan testet startar, efter att testet är klart, när testet hoppas över, när testet klaras eller misslyckas, har vi dessa lyssnarfunktioner som gör det möjligt för oss att gör det här
JUnit använder lyssnarklassen och TestNG använder ett lyssnargränssnitt. TestNG skriver en lyssnarklass som definierar metoderna för lyssnargränssnittet, och det andra steget är att kalla detta lyssnarklassnamn med @Listeners-kommentar i huvudklassen.
JUnit ärver också metoderna från föräldraklassen Listener, varefter en Listener-löparklass definieras för att använda lyssnarfunktionerna på en eller flera huvudklasser.
Lyssnare i TestNG
Det finns ett ITestListener-gränssnitt som TestNG implementeras från.
Nedan följer metoderna som behöver definieras när ITestListener implementeras -
- OnTestStart ()
- OnTestFailure ()
- OnTestSuccess ()
- OnTestSkipped ()
- OnStart ()
- OnFinish ()
Nedan är kodavsnittet som demonstrerar onTestStart () och 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 den här lyssnarklassen i huvudklassen, som visas nedan, med hjälp av kommentaren @Listener:
import org.testng.annotations.Listeners; import org.testng.annotations.Test; @Listeners(com.javatpoint.Listener.class) public class MymainClass { @Test public void sum() { Lyssnare i JUnit 5
RunListener är den klass som behöver utvidgas av din lyssnarklass för att definiera lyssnarfunktionerna.
Vi har följande metoder för JUnit:
- testRunStarted
- testRunFinished
- testFailure
- tesIgnorerad
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()); } Det måste finnas en exekveringsklass för lyssnare för att åberopa ovanstående lyssnarklass.
Du kan tillämpa lyssnarens Mylistener-klass på flera 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); } Slutsats
I denna JUnit Vs TestNG-handledning har vi jämfört TestNG- och JUnit-ramar. Vi lärde oss de vanliga funktionerna som stöds i både ramarna och ytterligare funktioner som endast stöds i TestNG. Tydligen finns det bara några extra funktioner i TestNG, som parallella körningar och beroendestester. De flesta funktioner som stöds av TestNG finns också i JUnit.
Det finns små avvikelser när det gäller syntax, terminologier i JUnit vs TestNG för de gemensamma funktionerna. De som undergrävde styrkan hos JUnit över TestNG skulle ha insett fram till nu, dvs. JUnit är också en av de kraftfulla automatiseringsramarna.
Vi kommer tillbaka med många fler intressanta aspekter av JUnit. Håll dig till de kommande handledningarna !!!
Rekommenderad läsning
- JUnit-handledning för nybörjare - Vad är JUnit-testning?
- Lista över JUnit-kommentarer: JUnit 4 Vs JUnit 5
- Hur man använder JUnit 5 Annotation @RepeatedTest med exempel
- JUnit Ignorera testfall: JUnit 4 @Ignore Vs JUnit 5 @Disabled
- TestNG Installation, grundläggande program och rapporter
- TestNG-kommentarer och lyssnare
- TestNG Tutorial: Introduktion till TestNG Framework
- Påståenden i selen med Junit och TestNG Frameworks