junit vs testng what are differences
Un confronto completo tra i framework JUnit Vs TestNG. Include il confronto delle annotazioni e il confronto per funzionalità con esempi:
Nel tutorial precedente, abbiamo appreso l'annotazione DisplayName e l'esecuzione del test condizionale in base a diversi criteri come la versione JRE, le variabili ambientali, ecc. Abbiamo anche affrontato alcune importanti domande sull'argomento.
Dal momento che abbiamo appreso continuamente su JUnit nei tutorial precedenti, questo funzionerà come un attimo di respiro per il nostro pubblico poiché per un po 'sposteremo la nostra attenzione da JUnit come unica agenda al confronto tra JUnit vs TestNG.
=> Dai un'occhiata alla guida alla formazione Perfect JUnit qui.
Cosa imparerai:
- JUnit Vs TestNG: un confronto
- Conclusione
JUnit Vs TestNG: un confronto
Caratteristiche | JUnit | TestNG |
---|---|---|
Timeout per i test | sì | sì |
Framework opensource | sì JUnit è un framework opensource | sì TestNG è un framework opensource |
Facile da usare | JUnit è distribuito su diversi moduli, ad esempio: ? Per la parametrizzazione potresti aver bisogno di JUnit Jupiter. ? Questo rende JUnit leggermente ingombrante da usare rispetto a TestNG | Tutte le funzionalità di TestNG sono contenute in un modulo. Questo rende TestNG più facile da usare. |
Supporto IDE principale ( Esempio: Eclipse, IntelliJ) | sì Entrambi supportano la maggior parte dell'IDE allo stesso modo | sì Entrambi supportano la maggior parte dell'IDE allo stesso modo |
Implementazione delle annotazioni | sì JUnit lavora sulle annotazioni con lievi variazioni per caratteristiche diverse | sì TestNG funziona sulle annotazioni con leggere variazioni per diverse funzionalità |
Implementazione delle asserzioni | sì JUnit fornisce abbastanza asserzioni per convalidare i risultati attesi ed effettivi con alcune variazioni alle asserzioni in TestNG | sì TestNG supporta anche un enorme elenco di affermazioni per il confronto dei risultati attesi ed effettivi. Inoltre, TestNG fornisce due meccanismi per le asserzioni: Soft Assertion e Hard Assertion |
Eccezioni | sì JUnit fornisce la funzionalità per il test di eccezione con una leggera variazione a TestNG | sì TestNG fornisce anche la funzionalità per il test delle eccezioni |
Test parametrizzati | sì JUnit supporta test parametrizzati | sì TestNG supporta anche test parametrizzati |
Test Suite | sì JUnit supporta l'utilizzo di suite di test | sì TestNG supporta anche Test Suite. |
Test di dipendenza | Non JUnit non supporta la funzione per il test delle dipendenze | sì Questa è una funzionalità avanzata in TestNG su JUnit. Con questa funzione, un metodo può essere reso dipendente da un altro in modo che il metodo venga eseguito solo dopo che il metodo dipendente viene eseguito e superato, altrimenti il test dipendente non verrà eseguito. |
Esecuzione parallela del test | Non L'esecuzione parallela non è disponibile in JUnit | sì TestNG supporta l'esecuzione parallela dei test ma JUnit no. Esiste un XML TestNG in cui è possibile impostare l'esecuzione parallela |
Integrazione Maven | sì Entrambi gli strumenti supportano l'integrazione di Maven | sì Entrambi gli strumenti supportano l'integrazione di Maven |
Implementazioni delle ipotesi | sì I presupposti vengono utilizzati per saltare i test basati su determinati presupposti o condizioni e questo è applicabile solo in JUnit. | Non TestNG non supporta i presupposti |
Ordine di esecuzione del test | sì Junit supporta l'ordine di esecuzione dei test. | sì TestNG supporta l'ordine di esecuzione dei test |
Attuazione degli ascoltatori | sì JUnit supporta i listener non tramite annotazioni ma tramite l'API Listeners. | sì TestNG supporta i listener tramite annotazioni. |
Ignora i test | sì Entrambi supportano la disabilitazione dei test, ma JUnit supporta la disabilitazione dei test per l'esecuzione in base a condizioni diverse | sì Entrambi supportano la disabilitazione dei test |
Segnalazione | sì JUnit deve essere integrato con Maven per generare report HTML | sì TestNG ha i suoi report HTML integrati. Può essere integrato anche con Maven o librerie di report esterne come report ATU o report Extent |
Confronto di annotazioni
TestNG e JUnit sono entrambi framework di unit test del mondo di Java. Entrambi implementano caratteristiche molto vicine e simili. In questa sezione, esamineremo alcune somiglianze nell'implementazione di un paio di funzionalità mentre vedremo anche alcune altre funzionalità implementate in modo diverso in JUnit e TestNG.
# 1) Annotazione del metodo di prova
Non c'è differenza nel modo in cui specifichiamo un metodo come metodo di test sia in JUnit che in TestNG.
JUnit 5 | TestNG |
---|---|
@Test | @Test |
# 2) Annotazione relativa alla suite
- Un metodo con l'annotazione @BeforeSuite viene eseguito una volta prima dell'esecuzione della suite di test corrente.
- Questa annotazione è applicabile solo in TestNG.
JUnit 5 | TestNG |
---|---|
Non applicabile | @BeforeSuite |
# 3) Annotazione per un metodo prima di Class
Questa è l'annotazione per il metodo da eseguire una volta prima che venga eseguito il primo metodo di test nella classe.
JUnit 5 | TestNG |
---|---|
@BeforeAll | @Prima della lezione |
# 4) Annotazione per un metodo prima del test
- Questa annotazione viene eseguita una volta prima dei metodi dichiarati all'interno del tag di testng.xml.
- Questa annotazione è disponibile solo per TestNG.
JUnit 5 | TestNG |
---|---|
Non applicabile | @BeforeTest |
# 5) Annotazione per il metodo da eseguire prima di ogni metodo richiamato da @Test
JUnit 5 | TestNG |
---|---|
@BeforeEach | @BeforeMethod |
# 6) Annotazione per il metodo da eseguire dopo ogni metodo con invocazioni @Test
JUnit 5 | TestNG |
---|---|
@Dopo ogni | @AfterMethod |
# 7) Annotazione per il metodo dopo il test
- Questa annotazione viene eseguita una volta dopo i metodi dichiarati all'interno del tag di testng.xml.
- Questa annotazione è disponibile solo per TestNG.
JUnit 5 | TestNG |
---|---|
Non applicabile | @AfterTest |
# 8) Annotazione per il metodo dopo la lezione
Questa è l'annotazione per il metodo da eseguire una volta dopo che è stato eseguito l'ultimo metodo di test nella classe.
JUnit 5 | TestNG |
---|---|
@Dopotutto | @Dopo la lezione |
# 9) Annotazione per disabilitare l'esecuzione del metodo Test.
- JUnit 5 fornisce un'annotazione per disabilitare una specifica esecuzione di test.
- TestNG fornisce un attributo per @Test cioè 'abilitato' con il valore booleano che decide se l'esecuzione del metodo sarebbe disabilitata o abilitata
JUnit 5 | TestNG |
---|---|
@ignorare | @Test (abilitato = falso) |
Fare riferimento a Tutorial 7 Saltare l'esecuzione per capire come disabilitare i test in JUnit4 vs JUnit 5
# 10) Annotazione timeout
L'annotazione è la stessa per JUnit 5 e TestNG
JUnit 5 | TestNG |
---|---|
@Test (timeout = 2000) | @Test (timeout = 2000) |
# 11) Attributo di eccezione prevista
- La classe di eccezione afferma che quando viene eseguito il test, viene generata l'eccezione della classe data.
- Questo è supportato sia in JUnit che in TestNG con variazioni nel modo in cui vengono dichiarati entrambi.
JUnit 5 | TestNG | |
---|---|---|
@Test (previsto = NullPointerException.class) | @Test (expectedException = NullPointerException.class) |
# 12) Annotazione relativa alla suite
- Un metodo con l'annotazione @AfterSuite viene eseguito una volta dopo l'esecuzione della suite di test corrente.
- Questa annotazione è applicabile solo in TestNG.
JUnit 5 | TestNG |
---|---|
Non applicabile | @AfterSuite |
# 13) Annotazione relativa al gruppo
- L'annotazione è disponibile solo in TestNG.
- Il metodo con l'annotazione @BeforeGroups viene eseguito prima che vengano eseguiti i metodi di test appartenenti a un particolare gruppo.
JUnit 5 | TestNG | |
---|---|---|
Non applicabile | @BeforeGroups |
- L'annotazione è disponibile solo in TestNG.
- Il metodo con l'annotazione @BeforeGroups viene eseguito dopo l'esecuzione dei metodi di test appartenenti a un particolare gruppo.
JUnit 5 | TestNG |
---|---|
Non applicabile | @AfterGroups |
# 14) Annotazioni relative all'ordine di esecuzione
Sia JUnit che TestNG supportano l'impostazione esplicita dell'ordine dei test per l'esecuzione. In altre parole, impostare la priorità per i casi di test.
- JUnit 5 ha l'annotazione @TestMethodOrder () con la classe incorporata del pacchetto MethodOrderer - Alphanumeric.class o OrderAnnotation.class o Random.class come parametro di input per l'annotazione.
Fare riferimento a Tutorial 9 - Junit Test Execution Order per maggiori dettagli sull'impostazione dell'ordine di esecuzione dei test in JUnit.
- TestNG include l'attributo 'priorità' per l'annotazione @Test, che accetta un valore numerico.
JUnit 5 | TestNG |
---|---|
@TestMethodOrder (Alphanumeric.class) | @Test (priorità = 1) |
Programma base per TestNG e JUnit 4
# 1) Codice 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'); } }
Uscita prevista:
# 2) Codice 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'); } }
Uscita prevista:
JUnit 5 vs TestNG: differenza di funzionalità con esempi
# 1) Suite di prova
- La suite di test è una raccolta di test, il che significa che stiamo raggruppando più casi di test da più classi insieme.
- L'approccio utilizzato da TestNG suite è diverso e potente rispetto a quello di JUnit.
Suite di test in JUnit 5
Vediamo rapidamente come JUnit 5 applica la suite di test.
Fare riferimento a Tutorial 8 -JUnit Test Suite e filtri Test case per una migliore comprensione dell'implementazione della suite di test in JUnit 4 e in JUnit 5.
@RunWith(JUnitPlatform.class) @SelectClasses({JUnit5TestCase1.class, JUnit5TestCase2.class }) public class JUnitTestSuite { }
Suite di test in TestNG
TestNG utilizza l'XML come modello seguente per racchiudere tutte le classi di Test che si connettono logicamente
# 2) Test parametrizzato
Sia TestNG che JUnit consentono la parametrizzazione dei test che non è altro che l'esecuzione degli stessi test con variazioni dei dati.
Test parametrizzato 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); } }
Test parametrizzato in TestNG
Esistono 2 modi per utilizzare la parametrizzazione in TestNG
- @Parameters e passando attraverso TestNG XML
- Annotazione @DataProvider
a) @Parameters e passando attraverso 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 per lo stesso
b) DataProvider
L'annotazione DataProvider restituisce sempre Object () () che è l'array di oggetti.
@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
Se un determinato test non viene completato entro il tempo stabilito, si verifica un timeout. In altri, il filo viene interrotto.
ho bisogno di un nuovo provider di posta elettronica
Timeout in JUnit
Esistono diversi approcci all'implementazione del timeout in JUnit. Questi sono:
con cosa aprire i file xml
- Utilizzando il solito timeout con millisecondi specifici
- Utilizzo del timeout con l'asserzione
- Utilizzo del timeout globale
Avremo un tutorial dettagliato incentrato sul timeout per JUnit 4 e JUnit 5.
Di seguito è riportato lo snippet che mostra l'utilizzo del solito Timeout in JUnit 5:
@Test(timeout = 5000) public void testTimeout() throws InterruptedException { while (true) { } }
Il suddetto timeout del test dopo 5 secondi.
Timeout in TestNG
Il TestNG utilizza anche il modo semplice di implementazione del timeout:
@Test(timeout = 5000) public void testTimeout() throws InterruptedException { while (true) { } }
# 4) Test di eccezione
Il test di eccezione si assicura che quando viene generata questa eccezione predefinita, viene correttamente rilevata e notificata nei log.
Test di eccezione in JUnit 4
@Test (expected = NumberFormatException.class) public void converttoint() { Int j=Integer.parseInt(“Four”); }
Ci sarà un tutorial separato che coprirà dettagliatamente le eccezioni per JUnit 4 e 5.
Test di eccezione in TestNG
C'è un leggero cambiamento nella dichiarazione del test di eccezione in TestNG:
@Test (expectedExceptions = NumberFormatException.class) public void converttoint() { Int j=Integer.parseInt(“Four”); }
# 5) Disabilita test
Sia TestNG che JUnit consentono di disabilitare un test per l'esecuzione.
Test disabilitato in JUnit 5
Annotazione @Disabled se utilizzata all'inizio della classe, tutti i test all'interno della classe vengono ignorati per l'esecuzione. L'annotazione quando viene utilizzata sopra un particolare metodo @Test, quello specifico test case è disabilitato per l'esecuzione.
import org.junit.AfterClass; @Disabled('the testcase is under development') public class JUnitProgram {
Test disabilitato in TestNG
TestNG consente a un test di disabilitare l'esecuzione di un test quando l'attributo 'enabled' dell'annotazione @Test è impostato su false ed è abilitato quando l'attributo è impostato su true. Se tutti i test all'interno di una classe devono essere abilitati, contrassegnare esplicitamente abilitato = true per ogni metodo @Test.
Di seguito è riportato lo snippet di codice che dimostra come saltare un test.
@Test(enabled=false) public void f_validate(){ // let us skip this function}
# 6) Test di gruppo
Ci sono state dichiarazioni contraddittorie in più siti e forum in cui le persone hanno affermato che JUnit non ha mai supportato il raggruppamento di test con il nome del gruppo specifico.
Le annotazioni @BeforeGroups e @AfterGroups vengono fornite solo con TestNG, tuttavia il raggruppamento è consentito in JUnit 4 e in JUnit 5. Qui dimostreremo rapidamente l'uso dei test di gruppo in JUnit 5. I test di gruppo sono indicati come Categorie in JUnit 4 e Tag in JUnit 5.
Puoi fare riferimento a Tutorial 8 - Suite di test JUnit e test di filtraggio per i dettagli sull'utilizzo in JUnit.
Test di gruppo in JUnit 5
@Tag(“Regression”) @Test public void junitMethod1(){} @Tag(“SmokeTest”) @Test public void junitMethod2(){
Snippet di codice da JUnit5TestSuite.java:
Il codice seguente include il gruppo con il nome 'Regression' ed esclude il gruppo 'SmokeTest' che deduce che junitMethod1 () verrà eseguito ma junitMethod2 () è escluso.
@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludeTags(“Regression”) @ExcludeTags(“SmokeTest”) public class JUnit5TestSuite { }
Test di gruppo in TestNG
Se lo snippet precedente deve essere interpretato in TestNG, di seguito è riportato il codice per lo stesso:
@Test(groups={“Regression” }) public void junitMethod1(){} @Test(groups={“SmokeTest” }) public void junitMethod2(){}
TestNG XML è il seguente:
Qui, i metodi del gruppo di regressione sono inclusi nel runner mentre il resto dei gruppi, incluso SmokeTest, è escluso.
# 7) Test paralleli
Questa è la funzionalità disponibile solo con TestNG. Di solito, i casi di test sono tipi di thread che vengono richiamati uno dopo l'altro. Tuttavia, se desideri risparmiare sul tempo di esecuzione, puoi controllarlo in TestNG impostando i test da eseguire in parallelo e fornendo il numero di thread che devono essere eseguiti contemporaneamente.
Dimostreremo in breve l'uso di dipende dai metodi qui e non discuteremo dei dipendenti dai gruppi.
Il test dipendente su un altro metodo viene impostato tramite TestNG XML come segue:
# 8) Test dipendenti
I test dipendenti sono funzionalità avanzate disponibili solo con TestNG. Le dipendenze potrebbero essere su un test o su un gruppo.
@Test mytest1(){ System.out.println(“My test : mytest1”); } @Test (dependensOnMethods={“mytest1”}) public void mytest2(){ System.out.println(“My test : mytest2”); }
Nel programma precedente, poiché mytest2 dipende da mytest1, viene eseguito prima mytest1 e poi mytest2. Se mytest1 fallisce, mytest2 non verrà richiamato. Questo è il modo in cui i casi di test dipendenti possono essere predefiniti per controllare un flusso di lavoro specifico che si desidera eseguire.
# 9) ascoltatori
Gli ascoltatori ascoltano ogni evento che si verifica all'interno dei test. I listener sono supportati sia in JUnit che in TestNG. Quindi, se desideri eseguire determinate attività o mostrare un messaggio specifico nel registro prima dell'inizio del test, al termine del test, quando il test viene saltato, quando il test viene superato o fallito, abbiamo queste funzioni Listener che ci consentono di Fai questo
JUnit utilizza la classe Listener e TestNG utilizza un'interfaccia Listener. TestNG scrive una classe listener che definisce i metodi dell'interfaccia Listener e il secondo passaggio consiste nel chiamare questo nome di classe Listener utilizzando l'annotazione @Listeners nella classe principale.
JUnit eredita anche i metodi dalla classe genitore Listener in seguito alla quale viene definita una classe runner Listener per applicare le funzioni listener su una o più classi principali.
Listener in TestNG
Esiste un'interfaccia ITestListener da cui è implementato TestNG.
Di seguito sono riportati i metodi che devono essere definiti quando viene implementato ITestListener:
- OnTestStart ()
- OnTestFailure ()
- OnTestSuccess ()
- OnTestSkipped ()
- OnStart ()
- OnFinish ()
Di seguito è riportato lo snippet di codice che dimostra onTestStart () e 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()); }
Chiama questa classe listener nella tua classe principale come mostrato di seguito, usando l'annotazione @Listener:
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 è la classe che deve essere estesa dalla tua classe listener per definire le funzioni Listener.
Abbiamo i seguenti metodi per JUnit:
- testRunStarted
- testRunFinished
- testFailure
- ignorato
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()); }
Deve essere creata una classe di esecuzione listener per richiamare la classe listener sopra.
È possibile applicare la classe listener Mylistener a più classi con metodi di test.
public class ListenerRunner { public static void main(String() args) { JUnitCore runme = new JUnitCore(); runme.addListener(new ListenerRunner()); runner.run(FirstClass.class, SecondClass.class); }
Conclusione
In questo tutorial JUnit Vs TestNG, abbiamo confrontato i framework TestNG e JUnit. Abbiamo appreso le funzionalità comuni supportate in entrambi i framework, nonché funzionalità aggiuntive supportate solo in TestNG. Apparentemente, ci sono un paio di funzionalità extra solo in TestNG, come l'esecuzione parallela e i test di dipendenza. La maggior parte delle funzionalità supportate da TestNG è disponibile anche in JUnit.
Ci sono lievi deviazioni in termini di sintassi, terminologie in JUnit vs TestNG per le caratteristiche comuni. Coloro che hanno minato la forza di JUnit su TestNG si sarebbero resi conto fino ad ora che JUnit è anche uno dei potenti framework di automazione.
Torneremo con molti altri aspetti interessanti di JUnit. Attenersi ai prossimi tutorial !!!
Lettura consigliata
- Tutorial JUnit per principianti - Che cos'è il test JUnit
- Elenco delle annotazioni JUnit: JUnit 4 Vs JUnit 5
- Come utilizzare JUnit 5 Annotation @RepeatedTest con esempi
- JUnit Ignore Test Case: JUnit 4 @Ignore Vs JUnit 5 @Disabled
- Installazione di TestNG, programma di base e rapporti
- Annotazioni e listener di TestNG
- Tutorial TestNG: Introduzione a TestNG Framework
- Asserzioni in selenio utilizzando framework Junit e TestNG