junit vs testng what are differences
Una comparació completa entre els marcs JUnit Vs TestNG. Inclou la comparació d’anotacions i la comparació de característiques amb exemples:
Al tutorial anterior, vam aprendre l’anotació DisplayName i l’execució de proves condicionals basant-nos en diferents criteris com la versió de JRE, variables ambientals, etc. També vam abordar algunes qüestions importants sobre el tema.
Com que hem estat aprenent contínuament sobre JUnit en tutorials anteriors, aquest funcionarà com un respir per al nostre públic, ja que durant un temps canviarem el nostre enfocament de JUnit com a única agenda a la comparació entre JUnit i TestNG.
=> Consulteu aquí la guia de formació JUnit perfecta.
Què aprendreu:
- JUnit Vs TestNG: una comparació
- Conclusió
JUnit Vs TestNG: una comparació
| Característiques | JUnit | TestNG |
|---|---|---|
| Temps d'espera per a les proves | Sí | Sí |
| Marc d’opensource | Sí JUnit és un marc de codi obert | Sí TestNG és un marc de codi obert |
| Fàcil d’utilitzar | JUnit es distribueix en diferents mòduls, per exemple: ? Per a la parametrització, és possible que necessiteu JUnit Jupiter. ? Això fa que JUnit sigui lleugerament pesat d’utilitzar en comparació amb TestNG | Totes les funcions de TestNG vénen en un mòdul. Això fa que TestNG sigui més fàcil d'utilitzar. |
| Suport IDE important ( Exemple: Eclipsi, IntelliJ) | Sí Tots dos admeten la majoria de l’IDE per igual | Sí Tots dos admeten la majoria de l’IDE per igual |
| Implementació d’anotacions | Sí JUnit funciona en anotacions amb lleugeres variacions per a diferents funcions | Sí TestNG funciona en anotacions amb lleugeres variacions per a diferents funcions |
| Implementació d’assercions | Sí JUnit proporciona prou afirmacions per validar els resultats esperats i reals amb algunes variacions a les afirmacions de TestNG | Sí TestNG també admet una enorme llista d’afirmacions per comparar els resultats esperats i reals. A més, TestNG proporciona dos mecanismes per afirmar: Soft Assertion i Hard Assertion |
| Excepcions | Sí JUnit proporciona la funció per a la prova d’excepcions amb una lleugera variació a TestNG | Sí TestNG també proporciona la funció per a la prova d’excepcions |
| Proves parametritzades | Sí JUnit admet proves parametritzades | Sí TestNG també admet proves parametritzades |
| Suite de proves | Sí JUnit admet l’ús de suites de prova | Sí TestNG també admet Test Suite. |
| Prova de dependència | no JUnit no admet la funció per a la prova de dependència | Sí Aquesta és una característica avançada de TestNG sobre JUnit. Amb aquesta característica, es pot fer que un mètode depengui d'altres, de manera que el mètode només s'executarà després que el mètode dependent s'executi i passi el contrari que la prova dependent no s'executarà. |
| Execució de proves paral·leles | no L'execució en paral·lel no està disponible a JUnit | Sí TestNG admet l'execució en paral·lel de proves, però JUnit no. Hi ha un xml TestNG on es pot establir l'execució en paral·lel |
| Integració de Maven | Sí Les dues eines admeten la integració de Maven | Sí Les dues eines admeten la integració de Maven |
| Implementacions de supòsits | Sí Els supòsits s’utilitzen per saltar les proves basades en determinats supòsits o condicions i això només és aplicable a JUnit. | no TestNG no admet hipòtesis |
| Ordre d'execució de la prova | Sí Junit admet l'ordre d'execució de la prova. | Sí TestNG admet l'ordre d'execució de la prova |
| Implementació dels oients | Sí JUnit admet els oients no mitjançant anotacions, sinó mitjançant l'API Listeners. | Sí TestNG admet els oients mitjançant anotacions. |
| Ignora les proves | Sí Tots dos admeten la desactivació de proves, però JUnit admet la desactivació de proves per a l'execució basades en diferents condicions | Sí Tots dos admeten la desactivació de les proves |
| Informes | Sí JUnit s'ha d'integrar amb maven per generar informes HTML | Sí TestNG ha incorporat informes HTML. També es pot integrar amb biblioteques maven o externes, com ara informes ATU o informes Extent |
Comparació d'anotacions
TestNG i JUnit són marcs de proves d’unitats del món de Java. Tots dos implementen funcions molt més properes i similars. En aquesta secció, veurem algunes similituds en la implementació d'un parell de funcions, mentre que també podríem veure algunes altres funcions que s'implementen de manera diferent a JUnit i TestNG.
# 1) Anotació del mètode de prova
No hi ha cap diferència en la manera d’especificar un mètode com a mètode de prova tant a JUnit com a TestNG.
| JUnitat 5 | TestNG |
|---|---|
| @Prova | @Prova |
# 2) Anotació relacionada amb la suite
- Un mètode amb anotació @BeforeSuite s'executa una vegada abans que s'executi el conjunt de proves actual.
- Aquesta anotació només és aplicable a TestNG.
| JUnitat 5 | TestNG |
|---|---|
| No aplicable | @BeforeSuite |
# 3) Anotació per a un mètode abans de la classe
Aquesta és l’anotació del mètode que s’executarà una vegada abans que s’executi el primer mètode de prova de la classe.
| JUnitat 5 | TestNG |
|---|---|
| @BeforeAll | @BeforeClass |
# 4) Anotació per a un mètode abans de la prova
- Aquesta anotació s'executa una vegada abans dels mètodes declarats dins de l'etiqueta testng.xml.
- Aquesta anotació només està disponible per a TestNG.
| JUnitat 5 | TestNG |
|---|---|
| No aplicable | @BeforeTest |
# 5) Anotació del mètode que cal executar abans de cada mètode amb @Test invoca
| JUnitat 5 | TestNG |
|---|---|
| @BeforeEach | @BeforeMethod |
# 6) Anotació del mètode que cal executar després de cada mètode amb la invocació @Test
| JUnitat 5 | TestNG |
|---|---|
| @AfterEach | @AfterMethod |
# 7) Anotació del mètode després de la prova
- Aquesta anotació s'executa una vegada després dels mètodes declarats dins de l'etiqueta testng.xml.
- Aquesta anotació només està disponible per a TestNG.
| JUnitat 5 | TestNG |
|---|---|
| No aplicable | @AfterTest |
# 8) Anotació del mètode després de la classe
Aquesta és l’anotació del mètode que s’executarà una vegada després d’executar l’últim mètode de prova de la classe.
| JUnitat 5 | TestNG |
|---|---|
| @Després de tot | @Després de classe |
# 9) Anotació per desactivar l'execució del mètode de prova.
- JUnit 5 proporciona una anotació per desactivar una execució de prova específica.
- TestNG proporciona un atribut per a @Test, és a dir, 'activat' amb el valor booleà que decideix si l'execució del mètode estaria desactivada o habilitada
| JUnitat 5 | TestNG |
|---|---|
| @ignore | @Test (activat = fals) |
Consulteu Tutorial 7 Saltar l'execució per entendre com desactivar les proves a JUnit4 vs JUnit 5
# 10) Anotació de temps d'espera
L'anotació és la mateixa per a JUnit 5 i TestNG
| JUnitat 5 | TestNG |
|---|---|
| @Test (temps d'espera = 2000) | @Test (temps d'espera = 2000) |
# 11) Atribut d'excepció esperada
- La classe d'excepció indica que quan s'executa la prova, es genera l'excepció de la classe donada.
- Això s'admet tant a JUnit com a TestNG, amb variacions en la forma en què es declaren ambdues.
| JUnitat 5 | TestNG | |
|---|---|---|
| @Test (esperat = NullPointerException.class) | @Test (expectedException = NullPointerException.class) |
# 12) Anotació relacionada amb la suite
- Un mètode amb anotació @AfterSuite s'executa una vegada després d'executar el conjunt de proves actual.
- Aquesta anotació només és aplicable a TestNG.
| JUnitat 5 | TestNG |
|---|---|
| No aplicable | @AfterSuite |
# 13) Anotació relacionada amb el grup
- L'anotació només està disponible a TestNG.
- El mètode amb anotació @BeforeGroups s'executa abans que s'executin els mètodes de prova pertanyents a un grup concret.
| JUnitat 5 | TestNG | |
|---|---|---|
| No aplicable | @BeforeGroups |
- L'anotació només està disponible a TestNG.
- El mètode amb anotació @BeforeGroups s'executa després que s'executin els mètodes de prova pertanyents a un grup concret.
| JUnitat 5 | TestNG |
|---|---|
| No aplicable | @AfterGroups |
# 14) Anotacions relacionades amb l’ordre d’execució
Tant JUnit com TestNG admeten establir explícitament l'ordre de les proves per a l'execució. En altres paraules, establir la prioritat per als casos de prova.
- JUnit 5 té l’anotació @TestMethodOrder () amb la classe integrada del paquet MethodOrderer: Alphanumeric.class o OrderAnnotation.class o Random.class com a paràmetre d’entrada per a l’anotació.
Consulteu Tutorial 9: Ordre d'execució de la prova Junit per obtenir més detalls sobre l'establiment de l'ordre d'execució de la prova a JUnit.
- TestNG inclou l'atribut 'prioritat' per a l'anotació @Test, que accepta un valor numèric.
| JUnitat 5 | TestNG |
|---|---|
| @TestMethodOrder (Alphanumeric.class) | @Test (prioritat = 1) |
Programa bàsic per a TestNG i JUnit 4
# 1) Codi 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'); } } Sortida prevista:
# 2) Codi 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'); } } Sortida prevista:
JUnit 5 vs TestNG: diferència de característiques amb exemples
# 1) Suite de proves
- El conjunt de proves és una col·lecció de proves, cosa que significa que estem embolicant diversos casos de proves de diverses classes.
- L’enfocament que TestNG utilitza la suite és diferent i potent en comparació amb el de JUnit.
Suite de proves a JUnit 5
Vegem ràpidament com JUnit 5 aplica el conjunt de proves.
Consulteu Tutorial 8: suites i filtratge de proves JUnit Casos de prova per a una millor comprensió de la implementació del conjunt de proves a la JUnit 4 i a la JUnit 5.
@RunWith(JUnitPlatform.class) @SelectClasses({JUnit5TestCase1.class, JUnit5TestCase2.class }) public class JUnitTestSuite { } Suite de proves a TestNG
TestNG utilitza l'XML com a plantilla següent per incloure totes les classes de prova que es connecten lògicament
# 2) Prova parametritzada
Tant TestNG com JUnit permeten parametritzar proves que no són altra cosa que executar les mateixes proves amb variacions de dades.
Prova parametritzada a 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); } } Prova parametritzada a TestNG
Hi ha dues maneres de fer servir la parametrització a TestNG
- @Parameters i passant per TestNG XML
- Anotació @DataProvider
a) @Parameters i passant per 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 al mateix
b) DataProvider
L'anotació DataProvider sempre retorna Object () () que és la matriu d'objectes.
@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) Temps d'espera
Si una prova concreta no es completa en el temps estipulat, obtindrà un temps d'espera. D’altra banda, el fil s’interromp.
Preguntes i respostes d’entrevistes a la base de dades d’oracle
Temps d'espera a JUnit
Hi ha diferents enfocaments per a la implementació del temps d'espera a JUnit. Aquests són:
- Utilitzant el temps d'espera habitual amb mil·lisegons específics
- Utilitzar el temps d'espera amb l'afirmació
- S’utilitza el temps d’espera global
Tindrem un tutorial detallat centrat en el temps d'espera per a JUnit 4 i JUnit 5.
A continuació es mostra el fragment que mostra l’ús del temps d’espera habitual a JUnit 5:
@Test(timeout = 5000) public void testTimeout() throws InterruptedException { while (true) { } } El temps d'espera de la prova anterior al cap de 5 segons.
Temps d'espera a TestNG
TestNG també utilitza la forma senzilla d'implementar el temps d'espera:
@Test(timeout = 5000) public void testTimeout() throws InterruptedException { while (true) { } } # 4) Prova d’excepció
La prova d’excepcions assegura que quan es produeix aquesta excepció predefinida, es captura i es notifica amb gràcia als registres.
Prova d’excepció a JUnit 4
@Test (expected = NumberFormatException.class) public void converttoint() { Int j=Integer.parseInt(“Four”); } Hi haurà un tutorial separat que cobreixi detalladament les excepcions de la JUnit 4 i 5.
Prova d'excepció a TestNG
Hi ha un lleuger canvi en la prova de declaració d'excepció a TestNG:
@Test (expectedExceptions = NumberFormatException.class) public void converttoint() { Int j=Integer.parseInt(“Four”); } # 5) Desactiva la prova
Tant TestNG com JUnit permeten desactivar una prova per a l'execució.
millors llocs per veure animis gratis
Prova desactivada a JUnit 5
@Anotació desactivada quan s'utilitza a la part superior de la classe, totes les proves de la classe s'ometen per executar-les. Quan s’utilitza l’anotació a sobre d’un mètode @Test concret, aquest cas de prova específic es desactiva per executar-lo.
import org.junit.AfterClass; @Disabled('the testcase is under development') public class JUnitProgram { Prova desactivada a TestNG
TestNG permet que una prova desactivi l'execució d'una prova quan l'atribut 'activat' de l'anotació @Test s'estableix en false i s'activa quan l'atribut es defineix com a true. Si s'han d'activar totes les proves d'una classe, marqueu explícitament enabled = true per a cada mètode @Test.
A continuació es mostra el fragment de codi que demostra saltar-se una prova.
@Test(enabled=false) public void f_validate(){ // let us skip this function} # 6) Proves de grup
Hi ha hagut afirmacions contradictòries en diversos llocs i fòrums on la gent ha mencionat que JUnit mai no va donar suport a l'agrupació de proves amb el nom del grup específic.
Les anotacions @BeforeGroups i @AfterGroups només vénen amb TestNG, tot i que es permet l’agrupament tant a JUnit 4 com a JUnit 5. Aquí demostrarem ràpidament l’ús de proves de grup a JUnit 5. Les proves de grup es denominen categories a JUnit 4 i Etiquetes a JUnit 5.
Podeu fer referència a Tutorial 8 - JUnit Test Suites i proves de filtratge per obtenir detalls sobre l'ús a JUnit.
Proves de grup a la JUnit 5
@Tag(“Regression”) @Test public void junitMethod1(){} @Tag(“SmokeTest”) @Test public void junitMethod2(){ Fragment de codi de JUnit5TestSuite.java:
El codi següent inclou el grup amb el nom 'Regressió' i exclou el grup 'SmokeTest' que dedueix que junitMethod1 () s'executarà, tot i que junitMethod2 () està exclòs.
@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludeTags(“Regression”) @ExcludeTags(“SmokeTest”) public class JUnit5TestSuite { } Proves de grup a TestNG
Si el fragment anterior s’ha d’interpretar a TestNG, a continuació es mostra el codi del mateix:
@Test(groups={“Regression” }) public void junitMethod1(){} @Test(groups={“SmokeTest” }) public void junitMethod2(){} TestNG XML és el següent:
Aquí, els mètodes del grup de regressió s’inclouen al corredor mentre s’exclou la resta de grups que inclouen SmokeTest.
# 7) Proves paral·leles
Aquesta és la característica que només està disponible amb TestNG. Normalment, els casos de prova són una mena de fils que s’invoquen un darrere l’altre. Tot i això, si voleu estalviar temps d’execució, podeu controlar-ho a TestNG configurant les proves que s’executaran en paral·lel i proporcionant el nombre de fils que s’han d’executar alhora.
Aquí demostrarem breument que l’ús de mètodes depèn dels mètodes i no discutirem depèn dels grups.
La prova dependent d’un altre mètode s’estableix mitjançant TestNG XML de la següent manera:
# 8) Proves dependents
Les proves dependents són funcions avançades disponibles només amb TestNG. Les dependències podrien ser en una prova o en un grup.
@Test mytest1(){ System.out.println(“My test : mytest1”); } @Test (dependensOnMethods={“mytest1”}) public void mytest2(){ System.out.println(“My test : mytest2”); } Al programa anterior, com mytest2 depèn de mytest1, primer s'executa mytest1 i després s'executa mytest2. Si falla mytest1, no s’invocarà mytest2. Així es poden predefinir casos de prova dependents per controlar un flux de treball específic que vulgueu executar.
# 9) Oients
Els oients escolten tots els esdeveniments que es produeixen a les proves. Els oients són compatibles tant amb JUnit com amb TestNG. Per tant, si voleu realitzar determinades tasques o mostrar un missatge específic al registre abans que comenci la prova, un cop finalitzada la prova, quan s’omet la prova, quan la prova es passa o no, tenim aquestes funcions de Listener que ens permeten fer això
JUnit utilitza la classe Listener i TestNG utilitza una interfície Listener. TestNG escriu una classe d'escolta que defineix els mètodes de la interfície d'escolta, i el segon pas és trucar a aquest nom de classe d'escolta mitjançant l'anotació @Listeners a la classe principal.
JUnit també hereta els mètodes de la classe pare Listener seguint els quals es defineix una classe Runner Listener per aplicar les funcions de listener a una o més classes principals.
Oient a TestNG
Hi ha una interfície ITestListener des de la qual s’implementa TestNG.
A continuació es mostren els mètodes que cal definir quan s’implementa ITestListener -
- OnTestStart ()
- OnTestFailure ()
- OnTestSuccess ()
- OnTestSkipped ()
- OnStart ()
- OnFinish ()
A continuació es mostra el fragment de codi que demostra 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()); } Truqueu a aquesta classe d’oients de la vostra classe principal com es mostra a continuació, mitjançant l’anotació @Listener:
import org.testng.annotations.Listeners; import org.testng.annotations.Test; @Listeners(com.javatpoint.Listener.class) public class MymainClass { @Test public void sum() { Oient a JUnit 5
RunListener és la classe que necessita ampliar la vostra classe d'escolta per definir les funcions d'escolta.
Tenim els mètodes següents per a JUnit:
- testRunStarted
- testRunFinished
- fracàs de prova
- 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()); } Hi ha d’haver una classe d’execució de l’oient per invocar la classe d’oient anterior.
Podeu aplicar la classe d'oient Mylistener a diverses classes amb mètodes de prova.
public class ListenerRunner { public static void main(String() args) { JUnitCore runme = new JUnitCore(); runme.addListener(new ListenerRunner()); runner.run(FirstClass.class, SecondClass.class); } Conclusió
En aquest tutorial de JUnit Vs TestNG, hem comparat els marcs TestNG i JUnit. Vam aprendre les funcions comunes compatibles amb els dos frameworks, així com les funcions addicionals admeses només a TestNG. Pel que sembla, només hi ha un parell de funcions addicionals a TestNG, com l'execució en paral·lel i les proves de dependència. La majoria de les funcions compatibles amb TestNG també estan disponibles a JUnit.
Hi ha lleugeres desviacions en termes de sintaxi, terminologies a JUnit vs TestNG per a les característiques comunes. Aquells que van minar la força de JUnit sobre TestNG s’haurien adonat fins ara, és a dir, que JUnit també és un dels marcs d’automatització de gran abast.
Tornarem amb molts aspectes més interessants de JUnit. Enganxeu-vos als propers tutorials !!!
Lectura recomanada
- Tutorial JUnit per a principiants: què és la prova JUnit
- Llista d’anotacions de JUnit: JUnit 4 Vs JUnit 5
- Com s'utilitza JUnit 5 Annotation @RepeatedTest amb exemples
- JUnit Ignora el cas de prova: JUnit 4 @Ignore Vs JUnit 5 @Disabled
- Instal·lació de TestNG, programa bàsic i informes
- Anotacions i oients de TestNG
- Tutorial TestNG: Introducció a TestNG Framework
- Afirmacions en seleni mitjançant marcs Junit i TestNG