junit vs testng what are differences
O comparație cuprinzătoare între cadrele JUnit Vs TestNG. Include comparația adnotărilor și comparația caracteristică cu exemple:
În tutorialul anterior, am învățat adnotarea DisplayName și execuția condiționată a testului pe baza diferitelor criterii, cum ar fi versiunea JRE, variabilele de mediu etc. Am abordat și câteva întrebări importante despre subiect.
Întrucât am învățat continuu despre JUnit în tutoriale anterioare, acesta va funcționa ca o suflare pentru publicul nostru, deoarece ne vom schimba pentru o vreme atenția de la JUnit ca unică agendă la comparația dintre JUnit și TestNG.
=> Consultați aici ghidul perfect de formare JUnit.
Ce veți învăța:
- JUnit Vs TestNG: O comparație
- Concluzie
JUnit Vs TestNG: O comparație
| Caracteristici | JUnit | TestNG |
|---|---|---|
| Timeout pentru teste | da | da |
| Cadrul open source | da JUnit este un cadru open source | da TestNG este un cadru open source |
| Ușor de utilizat | JUnit este distribuit în diferite module, de exemplu: ? Pentru parametrizare este posibil să aveți nevoie de JUnit Jupiter. ? Acest lucru face ca JUnit să fie ușor dificil de utilizat în comparație cu TestNG | Toate caracteristicile TestNG vin într-un singur modul. Acest lucru face TestNG mai ușor de utilizat. |
| Suport major IDE ( Exemplu: Eclipse, IntelliJ) | da Ambele acceptă majoritatea IDE în mod egal | da Ambele acceptă majoritatea IDE în mod egal |
| Implementarea adnotărilor | da JUnit funcționează la adnotări cu ușoare variații pentru diferite caracteristici | da TestNG funcționează pe adnotări cu ușoare variații pentru diferite caracteristici |
| Implementarea afirmațiilor | da JUnit oferă suficiente afirmații pentru a valida rezultatele așteptate și efective, cu unele variații ale afirmațiilor din TestNG | da TestNG acceptă, de asemenea, o listă imensă de afirmații pentru compararea rezultatelor așteptate și reale. În plus, TestNG oferă două mecanisme pentru afirmații - Soft Assertion și Hard Assertion |
| Excepții | da JUnit oferă funcția pentru testul Exception cu o ușoară variație la TestNG | da TestNG oferă, de asemenea, caracteristica pentru testul de excepție |
| Teste parametrizate | da JUnit acceptă teste parametrizate | da TestNG acceptă, de asemenea, teste parametrizate |
| Test Suite | da JUnit acceptă utilizarea suitelor de testare | da TestNG acceptă și Test Suite. |
| Test de dependență | Nu face JUnit nu acceptă funcția pentru testul de dependență | da Aceasta este o caracteristică avansată în TestNG peste JUnit. Cu această caracteristică, o metodă poate fi făcută dependentă de alta, astfel încât metoda să ruleze numai după ce metoda dependentă rulează și trece altfel testul dependent nu va rula. |
| Execuție test paralel | Nu face Execuția în paralel nu este disponibilă în JUnit | da TestNG acceptă executarea paralelă a testelor, dar JUnit nu. Există un TestNG xml unde se poate seta execuția paralelă |
| Integrarea Maven | da Ambele instrumente acceptă integrarea Maven | da Ambele instrumente acceptă integrarea Maven |
| Implementarea ipotezelor | da Ipotezele sunt folosite pentru a ignora testele bazate pe anumite ipoteze sau condiții iar acest lucru este aplicabil numai în JUnit. | Nu face TestNG nu acceptă ipoteze |
| Ordinul de executare a testului | da Junit acceptă ordinea de execuție a testului. | da TestNG acceptă ordinea de execuție a testului |
| Implementarea ascultătorilor | da JUnit acceptă ascultătorii nu prin adnotări, ci prin API Ascultători. | da TestNG sprijină ascultătorii prin adnotări. |
| Ignorați testele | da Ambele acceptă dezactivarea testelor, dar JUnit acceptă dezactivarea testelor pentru execuție bazate pe condiții diferite | da Ambele acceptă dezactivarea testelor |
| Raportare | da JUnit trebuie integrat cu maven pentru a genera rapoarte HTML | da TestNG are rapoarte HTML încorporate. Poate fi integrat și cu maven sau cu biblioteci de raportare externe, cum ar fi rapoarte ATU sau rapoarte Extent |
Compararea adnotărilor
TestNG și JUnit sunt ambele cadre de testare unitară din lumea Java. Ambele implementează caracteristici foarte apropiate și similare. În această secțiune, vom analiza unele asemănări în implementarea a câteva caracteristici, în timp ce vom vedea și alte câteva caracteristici care sunt implementate diferit în JUnit și TestNG.
# 1) Adnotarea metodei de testare
Nu există nicio diferență în modul în care specificăm o metodă ca metodă de testare atât în JUnit, cât și în TestNG.
| JUnitatea 5 | TestNG |
|---|---|
| @Test | @Test |
# 2) Adnotare legată de suită
- O metodă cu adnotare @BeforeSuite este executată o dată înainte de executarea suitei de test curente.
- Această adnotare se aplică numai în TestNG.
| JUnitatea 5 | TestNG |
|---|---|
| Nu se aplică | @BeforeSuite |
# 3) Adnotare pentru o metodă înainte de clasă
Aceasta este adnotarea pentru metoda care trebuie executată o dată înainte de executarea primei metode de testare din clasă.
| JUnitatea 5 | TestNG |
|---|---|
| @BeforeAll | @Înainte de curs |
# 4) Adnotare pentru o metodă înainte de test
- Această adnotare se execută o dată înainte de metodele declarate în eticheta testng.xml.
- Această adnotare este disponibilă numai pentru TestNG.
| JUnitatea 5 | TestNG |
|---|---|
| Nu se aplică | @BeforeTest |
# 5) Adnotare pentru metoda care trebuie executată înainte de fiecare metodă cu invocare @Test
| JUnitatea 5 | TestNG |
|---|---|
| @Înainte de fiecare | @BeforeMethod |
# 6) Adnotare pentru metoda care trebuie executată după fiecare metodă cu invocare @Test
| JUnitatea 5 | TestNG |
|---|---|
| @După fiecare | @AfterMethod |
# 7) Adnotare pentru metodă după test
- Această adnotare se execută o dată după metodele declarate în interiorul etichetei testng.xml.
- Această adnotare este disponibilă numai pentru TestNG.
| JUnitatea 5 | TestNG |
|---|---|
| Nu se aplică | @AfterTest |
# 8) Adnotare pentru metodă după clasă
Aceasta este adnotarea pentru metoda care trebuie executată o dată după executarea ultimei metode de testare din clasă.
| JUnitatea 5 | TestNG |
|---|---|
| @Dupa toate acestea | @După clasa |
# 9) Adnotare pentru a dezactiva executarea metodei de testare.
- JUnit 5 oferă o adnotare pentru a dezactiva o execuție de test specifică.
- TestNG oferă un atribut pentru @Test, adică „activat” cu valoarea booleană care decide dacă executarea metodei ar fi dezactivată sau activată
| JUnitatea 5 | TestNG |
|---|---|
| @ignora | @Test (activat = fals) |
A se referi la Tutorial 7 Omiterea executării pentru a înțelege cum să dezactivați testele în JUnit4 vs JUnit 5
# 10) Adnotare de expirare
Adnotarea este aceeași pentru JUnit 5 și TestNG
| JUnitatea 5 | TestNG |
|---|---|
| @Test (timeout = 2000) | @Test (timeout = 2000) |
# 11) Atribut de excepție așteptat
- Clasa de excepție afirmă că atunci când testul se execută, se aruncă excepția clasei date.
- Acest lucru este acceptat atât în JUnit, cât și în TestNG, cu variații în modul în care sunt declarate ambele.
| JUnitatea 5 | TestNG | |
|---|---|---|
| @Test (asteptat = NullPointerException.class) | @Test (expectedException = NullPointerException.class) |
# 12) Adnotare legată de suită
- O metodă cu adnotare @AfterSuite este executată o dată după executarea suitei de test curente.
- Această adnotare se aplică numai în TestNG.
| JUnitatea 5 | TestNG |
|---|---|
| Nu se aplică | @AfterSuite |
# 13) Adnotare legată de grup
- Adnotarea este disponibilă numai în TestNG.
- Metoda cu adnotare @BeforeGroups rulează înainte de a rula metodele de testare aparținând unui anumit grup.
| JUnitatea 5 | TestNG | |
|---|---|---|
| Nu se aplică | @BeforeGroups |
- Adnotarea este disponibilă numai în TestNG.
- Metoda cu adnotare @BeforeGroups rulează după executarea metodelor de testare aparținând unui anumit grup.
| JUnitatea 5 | TestNG |
|---|---|
| Nu se aplică | @AfterGroups |
# 14) Adnotări legate de Ordinul de executare
Atât JUnit, cât și TestNG acceptă setarea explicită a ordinii testelor pentru execuție. Cu alte cuvinte, stabilirea priorității pentru cazurile de testare.
- JUnit 5 are adnotare @TestMethodOrder () cu clasa încorporată a pachetului MethodOrderer - Alphanumeric.class sau OrderAnnotation.class sau Random.class ca parametru de intrare pentru adnotare.
A se referi la Tutorial 9 - Ordinul de executare a testului Junit pentru mai multe detalii despre setarea ordinii de execuție a testului în JUnit.
- TestNG include atributul „prioritate” pentru adnotarea @Test, care acceptă o valoare numerică.
| JUnitatea 5 | TestNG |
|---|---|
| @TestMethodOrder (Alphanumeric.class) | @Test (prioritate = 1) |
Program de bază pentru TestNG și JUnit 4
# 1) Cod TestNG
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'); } } Ieșire preconizată:
# 2) Codul JUnit 4
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'); } } Ieșire preconizată:
JUnit 5 vs TestNG: Diferența de caracteristică cu exemple
# 1) Test Suite
- Suita de testare este o colecție de teste, ceea ce înseamnă că încheiem mai multe cazuri de testare din mai multe clase.
- Abordarea pe care o folosește suita TestNG este diferită și puternică în comparație cu cea a JUnit.
Suită de testare în JUnit 5
Să ne uităm rapid la modul în care JUnit 5 aplică suita de testare.
A se referi la Tutorial 8 -JUnit Test Suites & Filtering Casete de testare pentru o mai bună înțelegere a implementării suitei de testare în JUnit 4 și JUnit 5.
@RunWith(JUnitPlatform.class) @SelectClasses({JUnit5TestCase1.class, JUnit5TestCase2.class }) public class JUnitTestSuite { } Suită de testare în TestNG
TestNG folosește XML ca șablon de mai jos pentru a încheia toate clasele de testare conectate logic
# 2) Test parametrizat
Atât TestNG, cât și JUnit permit parametrizarea testelor, care nu este altceva decât efectuarea acelorași teste cu variații de date.
Test parametrizat în JUnitatea 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); } } Test parametrizat în TestNG
Există 2 moduri în care ați putea folosi parametrizarea în TestNG
- @Parameters și trecerea prin TestNG XML
- Adnotare @DataProvider
a) @Parameters și trecerea prin 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 pentru același lucru
b) DataProvider
Adnotarea DataProvider returnează întotdeauna obiectul () (), care este matricea de obiecte.
@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) Expirare
Dacă un anumit test nu se finalizează în timpul prevăzut, atunci acesta se întrerupe. În alta, firul este întrerupt.
cum se scrie un plan de testare software
Expirare în JUnit
Există diferite abordări ale implementării Timeout în JUnit. Acestea sunt:
- Folosirea expirării obișnuite cu milisecunde specifice
- Utilizarea timeout-ului cu afirmația
- Utilizarea timeout-ului global
Vom avea un tutorial detaliat axat pe timeout pentru JUnit 4 și JUnit 5.
Mai jos este fragmentul care arată utilizarea Timeout-ului obișnuit în JUnit 5:
@Test(timeout = 5000) public void testTimeout() throws InterruptedException { while (true) { } } Expirarea testului de mai sus după 5 secunde.
Timeout în TestNG
TestNG folosește, de asemenea, modul simplu de implementare Timeout:
@Test(timeout = 5000) public void testTimeout() throws InterruptedException { while (true) { } } # 4) Test de excepție
Testul de excepție se asigură că atunci când există această excepție predefinită aruncată, aceasta este prinsă cu grație și notificată în jurnale.
Test de excepție în JUnit 4
@Test (expected = NumberFormatException.class) public void converttoint() { Int j=Integer.parseInt(“Four”); } Va exista un tutorial separat care acoperă în detaliu excepțiile pentru JUnit 4 și 5.
Test de excepție în TestNG
Există o ușoară modificare în testul declarației de excepție în TestNG:
@Test (expectedExceptions = NumberFormatException.class) public void converttoint() { Int j=Integer.parseInt(“Four”); } # 5) Dezactivați testul
Atât TestNG, cât și JUnit permit dezactivarea unui test pentru execuție.
Test dezactivat în JUnit 5
@Anotație dezactivată atunci când este utilizată în partea de sus a clasei, toate testele din clasă sunt omise pentru executare. Adnotarea atunci când este utilizată deasupra unei anumite metode @Test, acest caz de test specific este dezactivat pentru executare.
import org.junit.AfterClass; @Disabled('the testcase is under development') public class JUnitProgram { Test dezactivat în TestNG
TestNG permite un test pentru a dezactiva executarea unui test atunci când atributul „activat” al adnotării @Test este setat la fals și este activat atunci când atributul este setat la adevărat. Dacă toate testele dintr-o clasă trebuie să fie activate, marcați explicit activat = adevărat pentru fiecare metodă @Test.
Mai jos este fragmentul de cod care demonstrează omiterea unui test.
@Test(enabled=false) public void f_validate(){ // let us skip this function} # 6) Teste de grup
Au existat declarații contradictorii în mai multe site-uri și forumuri în care oamenii au menționat că JUnit nu a sprijinit niciodată gruparea testelor cu numele grupului specific.
Adnotările @BeforeGroups și @AfterGroups vin doar cu TestNG, însă gruparea este permisă în JUnit 4, precum și în JUnit 5. Aici vom demonstra rapid utilizarea testelor de grup în JUnit 5. Testele de grup sunt denumite Categorii în JUnit 4 și Etichete în JUnitatea 5.
Vă puteți referi la Tutorial 8 - JUnit Test Suites și teste de filtrare pentru detalii despre utilizarea în JUnit.
Teste de grup în JUnit 5
@Tag(“Regression”) @Test public void junitMethod1(){} @Tag(“SmokeTest”) @Test public void junitMethod2(){ Fragment de cod din JUnit5TestSuite.java:
Codul de mai jos include grupul cu numele „Regresie” și exclude grupul „SmokeTest” care deduce că junitMethod1 () va fi rulat, totuși junitMethod2 () este exclus.
@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludeTags(“Regression”) @ExcludeTags(“SmokeTest”) public class JUnit5TestSuite { } Teste de grup în TestNG
Dacă fragmentul de mai sus trebuie interpretat în TestNG, atunci mai jos este codul pentru același:
@Test(groups={“Regression” }) public void junitMethod1(){} @Test(groups={“SmokeTest” }) public void junitMethod2(){} TestNG XML este după cum urmează:
Aici, metodele grupului de regresie sunt incluse în alergător, în timp ce restul grupurilor, inclusiv SmokeTest, este exclus.
# 7) Teste paralele
Aceasta este caracteristica disponibilă numai cu TestNG. De obicei, cazurile de testare sunt un fel de fire care sunt invocate unul după altul. Cu toate acestea, dacă doriți să economisiți timpul de execuție, puteți controla acest lucru în TestNG setând testele care vor fi executate în paralel și oferind numărul de fire care trebuie să ruleze simultan.
cum să vizualizați un fișier bin
Vom demonstra pe scurt utilizarea depinde de metodele de aici și nu vom discuta depinde de grupuri.
Testul dependent de o altă metodă este setat prin TestNG XML după cum urmează:
# 8) Teste dependente
Testele dependente sunt caracteristici avansate disponibile numai cu TestNG. Dependențele ar putea fi la un test sau la un grup.
@Test mytest1(){ System.out.println(“My test : mytest1”); } @Test (dependensOnMethods={“mytest1”}) public void mytest2(){ System.out.println(“My test : mytest2”); } În programul de mai sus, deoarece mytest2 depinde de mytest1, mai întâi se execută mytest1 și apoi se execută mytest2. Dacă mytest1 eșuează, mytest2 nu va fi invocat. Acesta este modul în care cazurile de test dependente pot fi predefinite pentru a controla un anumit flux de lucru pe care doriți să îl executați.
# 9) Ascultători
Ascultătorii ascultă fiecare eveniment care are loc în cadrul testelor. Ascultătorii sunt acceptați atât în JUnit, cât și în TestNG. Deci, dacă doriți să efectuați anumite sarcini sau să afișați un mesaj specific în jurnal înainte de începerea testului, după terminarea testului, când testul este omis, când testul este trecut sau eșuat, avem aceste funcții de ascultare care ne permit să fa asta
JUnit utilizează clasa Listener, iar TestNG utilizează o interfață Listener. TestNG scrie o clasă de ascultător care definește metodele interfeței de ascultare, iar al doilea pas este să apelați acest nume de clasă de ascultător utilizând adnotarea @Listeners din clasa principală.
JUnit moștenește, de asemenea, metodele din clasa părinte Listener după care se definește o clasă Runner Listener pentru a aplica funcțiile de ascultător pe una sau mai multe clase principale.
Ascultător în TestNG
Există o interfață ITestListener din care este implementat TestNG.
Mai jos sunt metodele care trebuie definite atunci când ITestListener este implementat -
- OnTestStart ()
- OnTestFailure ()
- OnTestSuccess ()
- OnTestSkipped ()
- OnStart ()
- OnFinish ()
Mai jos este fragmentul de cod care demonstrează onTestStart () și 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()); } Apelați această clasă de ascultător din clasa dvs. principală, așa cum se arată mai jos, utilizând adnotare @Listener:
import org.testng.annotations.Listeners; import org.testng.annotations.Test; @Listeners(com.javatpoint.Listener.class) public class MymainClass { @Test public void sum() { Ascultător în JUnit 5
RunListener este clasa care trebuie extinsă de clasa dvs. de ascultător pentru a defini funcțiile de ascultător.
Avem metode după cum urmează pentru JUnit:
- testRunStarted
- testRunFinished
- test Eșec
- 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()); } Trebuie să existe o clasă de execuție a ascultătorului pentru a invoca clasa de ascultător de mai sus.
Puteți aplica clasa ascultătorului Mylistener la mai multe clase cu metode de testare.
public class ListenerRunner { public static void main(String() args) { JUnitCore runme = new JUnitCore(); runme.addListener(new ListenerRunner()); runner.run(FirstClass.class, SecondClass.class); } Concluzie
În acest tutorial JUnit Vs TestNG, am comparat cadrele TestNG și JUnit. Am aflat caracteristicile comune acceptate în ambele cadre, precum și caracteristicile suplimentare acceptate numai în TestNG. Aparent, există câteva funcții suplimentare doar în TestNG, cum ar fi executarea în paralel și testele de dependență. Majoritatea caracteristicilor acceptate de TestNG sunt disponibile și în JUnit.
Există mici abateri în ceea ce privește sintaxa, terminologiile în JUnit vs TestNG pentru caracteristicile comune. Cei care au subminat puterea JUnit față de TestNG și-ar fi dat seama până acum, adică JUnit este, de asemenea, unul dintre cadrele puternice de automatizare.
Vom reveni cu multe alte aspecte interesante ale JUnit. Rămâneți la tutorialele viitoare !!!
Lectură recomandată
- JUnit Tutorial pentru începători - Ce este testarea JUnit
- Lista adnotărilor JUnit: JUnit 4 Vs JUnit 5
- Cum se utilizează JUnit 5 Annotation @RepeatedTest cu exemple
- JUnit Ignore Test Case: JUnit 4 @Ignore Vs JUnit 5 @Disabled
- Instalare TestNG, program de bază și rapoarte
- Adnotări și ascultători TestNG
- Tutorial TestNG: Introducere în TestNG Framework
- Afirmații în seleniu folosind cadrele Junit și TestNG