junit vs testng what are differences
Une comparaison complète entre les frameworks JUnit Vs TestNG. Comprend la comparaison des annotations et la comparaison des fonctionnalités avec des exemples:
Dans le didacticiel précédent, nous avons appris l'annotation DisplayName et l'exécution de tests conditionnels basés sur différents critères tels que la version JRE, les variables d'environnement, etc. Nous avons également abordé certaines questions importantes autour du sujet.
Étant donné que nous avons continuellement appris à propos de JUnit dans les tutoriels précédents, celui-ci fonctionnera comme un répit pour notre public, car nous passerons pendant un moment de JUnit en tant qu'agenda unique à la comparaison entre JUnit et TestNG.
=> Consultez le guide de formation Perfect JUnit ici.
Ce que vous apprendrez:
- JUnit Vs TestNG: une comparaison
- Conclusion
JUnit Vs TestNG: une comparaison
| Fonctionnalités | JUnit | TestNG |
|---|---|---|
| Délai d'expiration des tests | Oui | Oui |
| Cadre OpenSource | Oui JUnit est un framework OpenSource | Oui TestNG est un framework open source |
| Convivial | JUnit est réparti sur différents modules, exemple: ? Pour le paramétrage, vous aurez peut-être besoin de JUnit Jupiter. ? Cela rend JUnit légèrement difficile à utiliser par rapport à TestNG | Toutes les fonctionnalités de TestNG sont regroupées dans un seul module. Cela rend TestNG plus convivial. |
| Support IDE majeur ( Exemple: Eclipse, IntelliJ) | Oui Les deux prennent en charge la plupart des IDE de manière égale | Oui Les deux prennent en charge la plupart des IDE de manière égale |
| Mise en œuvre des annotations | Oui JUnit fonctionne sur des annotations avec de légères variations pour différentes fonctionnalités | Oui TestNG fonctionne sur des annotations avec de légères variations pour différentes fonctionnalités |
| Mise en œuvre des assertions | Oui JUnit fournit suffisamment d'assertions pour valider les résultats attendus et réels avec quelques variations des assertions dans TestNG | Oui TestNG prend également en charge une énorme liste d'assertions pour la comparaison des résultats attendus et réels. De plus, TestNG fournit deux mécanismes pour les assertions: l'assertion souple et l'assertion matérielle |
| Des exceptions | Oui JUnit fournit la fonction de test d'exception avec une légère variation de TestNG | Oui TestNG fournit également la fonction de test d'exception |
| Tests paramétrés | Oui JUnit prend en charge les tests paramétrés | Oui TestNG prend également en charge les tests paramétrés |
| Suite de tests | Oui JUnit prend en charge l'utilisation des suites de tests | Oui TestNG prend également en charge Test Suite. |
| Test de dépendance | Ne pas JUnit ne prend pas en charge la fonctionnalité de test de dépendance | Oui Il s'agit d'une fonctionnalité avancée de TestNG sur JUnit. Avec cette fonctionnalité, une méthode peut être rendue dépendante d'une autre, de sorte que la méthode ne s'exécutera qu'après que la méthode dépendante s'exécute et réussit, sinon le test dépendant ne sera pas exécuté. |
| Exécution de tests parallèles | Ne pas L'exécution parallèle n'est pas disponible dans JUnit | Oui TestNG prend en charge l'exécution parallèle des tests, mais JUnit ne le fait pas. Il existe un xml TestNG où l'exécution parallèle peut être définie |
| Intégration Maven | Oui Les deux outils prennent en charge l'intégration Maven | Oui Les deux outils prennent en charge l'intégration Maven |
| Implémentations d'hypothèses | Oui Des hypothèses sont utilisées pour sauter des tests basés sur certaines hypothèses ou conditions et cela n'est applicable que dans JUnit. | Ne pas TestNG ne prend pas en charge les hypothèses |
| Ordre d'exécution des tests | Oui Junit prend en charge l'ordre d'exécution des tests. | Oui TestNG prend en charge l'ordre d'exécution des tests |
| Implémentation d'auditeurs | Oui JUnit prend en charge les écouteurs non pas via des annotations mais via l'API Listeners. | Oui TestNG prend en charge les écouteurs via des annotations. |
| Ignorer les tests | Oui Les deux prennent en charge la désactivation des tests, mais JUnit prend en charge la désactivation des tests pour l'exécution en fonction de différentes conditions | Oui Les deux prennent en charge la désactivation des tests |
| Rapports | Oui JUnit doit être intégré à maven pour générer des rapports HTML | Oui TestNG a ses rapports HTML intégrés. Il peut également être intégré à maven ou à des bibliothèques de rapports externes telles que les rapports ATU ou les rapports d'étendue |
Comparaison des annotations
TestNG et JUnit sont tous deux des frameworks de tests unitaires issus du monde de Java. Les deux implémentent des fonctionnalités très proches et similaires. Dans cette section, nous examinerons certaines similitudes dans l'implémentation de quelques fonctionnalités, tandis que nous aurions également l'occasion de voir quelques autres fonctionnalités implémentées différemment dans JUnit et TestNG.
# 1) Annotation de la méthode de test
Il n'y a aucune différence dans la façon dont nous spécifions une méthode comme méthode de test à la fois dans JUnit et TestNG.
| JUnit 5 | TestNG |
|---|---|
| @Test | @Test |
# 2) Annotation relative à la suite
- Une méthode avec l'annotation @BeforeSuite est exécutée une fois avant l'exécution de la suite de tests actuelle.
- Cette annotation n'est applicable que dans TestNG.
| JUnit 5 | TestNG |
|---|---|
| N'est pas applicable | @BeforeSuite |
# 3) Annotation pour une méthode avant la classe
Il s'agit de l'annotation de la méthode à exécuter une fois avant l'exécution de la première méthode de test de la classe.
| JUnit 5 | TestNG |
|---|---|
| @Avant tout | @Avant les cours |
# 4) Annotation pour une méthode avant test
- Cette annotation s'exécute une fois avant les méthodes déclarées à l'intérieur de la balise testng.xml.
- Cette annotation n'est disponible que pour TestNG.
| JUnit 5 | TestNG |
|---|---|
| N'est pas applicable | @BeforeTest |
# 5) Annotation pour la méthode à exécuter avant chaque méthode avec @Test invoque
| JUnit 5 | TestNG |
|---|---|
| @BeforeEach | @BeforeMethod |
# 6) Annotation pour la méthode à exécuter après chaque méthode avec @Test invoque
| JUnit 5 | TestNG |
|---|---|
| @Après chaque | @AfterMethod |
# 7) Annotation pour la méthode après le test
- Cette annotation s'exécute une fois après les méthodes déclarées à l'intérieur de la balise testng.xml.
- Cette annotation n'est disponible que pour TestNG.
| JUnit 5 | TestNG |
|---|---|
| N'est pas applicable | @AfterTest |
# 8) Annotation pour la méthode après la classe
Il s'agit de l'annotation de la méthode à exécuter une fois après l'exécution de la dernière méthode de test de la classe.
| JUnit 5 | TestNG |
|---|---|
| @Après tout | @Après les cours |
# 9) Annotation pour désactiver l'exécution de la méthode Test.
- JUnit 5 fournit une annotation pour désactiver une exécution de test spécifique.
- TestNG fournit un attribut pour @Test, c'est-à-dire «activé» avec la valeur booléenne qui décide si l'exécution de la méthode serait désactivée ou activée
| JUnit 5 | TestNG |
|---|---|
| @ignorer | @Test (activé = faux) |
Faire référence à Tutoriel 7 Ignorer l'exécution pour comprendre comment désactiver les tests dans JUnit4 vs JUnit 5
# 10) Annotation de délai d'expiration
L'annotation est la même pour JUnit 5 et TestNG
| JUnit 5 | TestNG |
|---|---|
| @Test (délai d'expiration = 2000) | @Test (délai d'expiration = 2000) |
# 11) Attribut d'exception attendue
- La classe d'exception indique que lorsque le test s'exécute, l'exception de la classe donnée est levée.
- Ceci est pris en charge à la fois dans JUnit et TestNG avec des variations dans la manière dont les deux sont déclarés.
| JUnit 5 | TestNG | |
|---|---|---|
| @Test (attendu = NullPointerException.class) | @Test (expectedException = NullPointerException.class) |
# 12) Annotation relative à la suite
- Une méthode avec l'annotation @AfterSuite est exécutée une fois après l'exécution de la suite de tests actuelle.
- Cette annotation n'est applicable que dans TestNG.
| JUnit 5 | TestNG |
|---|---|
| N'est pas applicable | @AfterSuite |
# 13) Annotation relative au groupe
- L'annotation est disponible uniquement dans TestNG.
- La méthode avec l'annotation @BeforeGroups s'exécute avant l'exécution des méthodes de test appartenant à un groupe particulier.
| JUnit 5 | TestNG | |
|---|---|---|
| N'est pas applicable | @BeforeGroups |
- L'annotation est disponible uniquement dans TestNG.
- La méthode avec l'annotation @BeforeGroups s'exécute après l'exécution des méthodes de test appartenant à un groupe particulier.
| JUnit 5 | TestNG |
|---|---|
| N'est pas applicable | @AfterGroups |
# 14) Annotations relatives à l'ordre d'exécution
JUnit et TestNG prennent en charge la définition explicite de l'ordre des tests à exécuter. En d'autres termes, définir la priorité des cas de test.
- JUnit 5 a l'annotation @TestMethodOrder () avec la classe intégrée du package MethodOrderer - Alphanumeric.class ou OrderAnnotation.class ou Random.class comme paramètre d'entrée pour l'annotation.
Faire référence à Tutoriel 9 - Ordre d'exécution des tests Junit pour plus de détails sur la définition de l'ordre d'exécution des tests dans JUnit.
- TestNG inclut l'attribut «priorité» pour l'annotation @Test, qui accepte une valeur numérique.
| JUnit 5 | TestNG |
|---|---|
| @TestMethodOrder (Alphanumeric.class) | @Test (priorité = 1) |
Programme de base pour TestNG et JUnit 4
# 1) Code 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'); } } Production attendue:
# 2) Code 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'); } } Production attendue:
JUnit 5 vs TestNG: différence de fonctionnalité avec des exemples
# 1) Suite de tests
- La suite de tests est une collection de tests, ce qui signifie que nous sommes en quelque sorte en train de regrouper plusieurs cas de test de plusieurs classes.
- L'approche que TestNG utilise suite est différente et puissante par rapport à celle de JUnit.
Suite de tests dans JUnit 5
Voyons rapidement comment JUnit 5 applique la suite de tests.
Faire référence à Tutoriel 8 - Suites de tests et filtrage JUnit Des tests pour une meilleure compréhension de l'implémentation de la suite de tests dans JUnit 4 et JUnit 5.
@RunWith(JUnitPlatform.class) @SelectClasses({JUnit5TestCase1.class, JUnit5TestCase2.class }) public class JUnitTestSuite { } Suite de tests dans TestNG
TestNG utilise le XML comme modèle ci-dessous pour envelopper toutes les classes de test connectées logiquement
# 2) Test paramétré
TestNG et JUnit permettent le paramétrage des tests qui n'est rien d'autre que l'exécution des mêmes tests avec des variations de données.
Test paramétré dans 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 paramétré dans TestNG
Il y a 2 façons d'utiliser le paramétrage dans TestNG
- @Parameters et en passant par TestNG XML
- Annotation @DataProvider
a) @Parameters et en passant par 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 pour le même
b) DataProvider
L'annotation DataProvider renvoie toujours Object () () qui est le tableau d'objets.
@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) Délai d'expiration
Si un test particulier ne se termine pas dans le délai imparti, il obtient un délai d’expiration. Dans d'autres, le fil est interrompu.
meilleures applications d'écriture pour Windows 10
Timeout dans JUnit
Il existe différentes approches de l'implémentation de Timeout dans JUnit. Ceux-ci sont:
- Utilisation du délai habituel avec des millisecondes spécifiques
- Utilisation de timeout avec l'assertion
- Utilisation du délai d'expiration global
Nous aurons un tutoriel détaillé sur le timeout pour JUnit 4 et JUnit 5.
Vous trouverez ci-dessous l'extrait montrant l'utilisation du délai habituel dans JUnit 5:
@Test(timeout = 5000) public void testTimeout() throws InterruptedException { while (true) { } } Le délai de test ci-dessus après 5 secondes.
Timeout dans TestNG
Le TestNG utilise également le moyen simple d'implémentation de Timeout:
@Test(timeout = 5000) public void testTimeout() throws InterruptedException { while (true) { } } # 4) Test d'exception
Le test d'exception garantit que lorsque cette exception prédéfinie est levée, elle est correctement interceptée et notifiée dans les journaux.
Test d'exception dans JUnit 4
@Test (expected = NumberFormatException.class) public void converttoint() { Int j=Integer.parseInt(“Four”); } Il y aura un tutoriel séparé couvrant en détail les exceptions pour JUnit 4 et 5.
Test d'exception dans TestNG
Il y a un léger changement dans la déclaration de test d'exception dans TestNG:
@Test (expectedExceptions = NumberFormatException.class) public void converttoint() { Int j=Integer.parseInt(“Four”); } # 5) Désactiver le test
TestNG et JUnit permettent de désactiver un test pour l'exécution.
Test désactivé dans JUnit 5
Annotation @Disabled lorsqu'elle est utilisée en haut de la classe, tous les tests de la classe sont ignorés pour l'exécution. L'annotation lorsqu'elle est utilisée par-dessus une méthode @Test particulière, ce cas de test spécifique est désactivé pour l'exécution.
import org.junit.AfterClass; @Disabled('the testcase is under development') public class JUnitProgram { Test désactivé dans TestNG
TestNG permet à un test de désactiver l'exécution d'un test lorsque l'attribut «activé» de l'annotation @Test est défini sur false et il est activé lorsque l'attribut est défini sur true. Si tous les tests d'une classe doivent être activés, marquez explicitement enabled = true pour chaque méthode @Test.
Vous trouverez ci-dessous l'extrait de code qui illustre le saut d'un test.
@Test(enabled=false) public void f_validate(){ // let us skip this function} # 6) Tests de groupe
Il y a eu des déclarations contradictoires dans plusieurs sites et forums où les gens ont mentionné que JUnit n'a jamais pris en charge le regroupement de tests avec le nom de groupe spécifique.
Les annotations @BeforeGroups et @AfterGroups ne sont fournies qu'avec TestNG mais le regroupement est autorisé dans JUnit 4 ainsi que dans JUnit 5. Ici, nous allons démontrer rapidement l'utilisation des tests de groupe dans JUnit 5. Les tests de groupe sont appelés Catégories dans JUnit 4 et Tags dans JUnit 5.
Vous pouvez vous référer à Tutoriel 8 - Suites de tests JUnit et tests de filtrage pour plus de détails sur l'utilisation dans JUnit.
Tests de groupe dans JUnit 5
@Tag(“Regression”) @Test public void junitMethod1(){} @Tag(“SmokeTest”) @Test public void junitMethod2(){ Extrait de code de JUnit5TestSuite.java:
Le code ci-dessous inclut le groupe avec le nom «Regression» et exclut le groupe «SmokeTest» qui en déduit que junitMethod1 () sera exécuté mais junitMethod2 () est exclu.
@RunWith(JUnitPlatform.class) @SelectPackages({“demo.tests“}) @IncludeTags(“Regression”) @ExcludeTags(“SmokeTest”) public class JUnit5TestSuite { } Tests de groupe dans TestNG
Si l'extrait de code ci-dessus doit être interprété dans TestNG, le code ci-dessous est le même:
@Test(groups={“Regression” }) public void junitMethod1(){} @Test(groups={“SmokeTest” }) public void junitMethod2(){} TestNG XML est le suivant:
Ici, les méthodes de groupe de régression sont incluses dans le runner tandis que le reste des groupes, y compris SmokeTest, est exclu.
# 7) Tests parallèles
C'est la fonctionnalité qui n'est disponible qu'avec TestNG. Habituellement, les cas de test sont des sortes de threads qui sont appelés les uns après les autres. Cependant, si vous souhaitez économiser sur le temps d'exécution, vous pouvez contrôler cela dans TestNG en définissant les tests à exécuter en parallèle et en fournissant le nombre de threads à exécuter en même temps.
Nous démontrerons brièvement l'utilisation de dépend des méthodes ici et ne discuterons pas des dépend des groupes.
Le test dépendant d'une autre méthode est défini via le XML TestNG comme suit:
# 8) Tests dépendants
Les tests dépendants sont des fonctionnalités avancées disponibles uniquement avec TestNG. Les dépendances peuvent être sur un test ou sur un groupe.
@Test mytest1(){ System.out.println(“My test : mytest1”); } @Test (dependensOnMethods={“mytest1”}) public void mytest2(){ System.out.println(“My test : mytest2”); } Dans le programme ci-dessus, comme mytest2 dépend de mytest1, d'abord mytest1 s'exécute, puis mytest2 est exécuté. Si mytest1 échoue, mytest2 ne sera pas appelé. C'est ainsi que les cas de test dépendants peuvent être prédéfinis pour contrôler un flux de travail spécifique que vous souhaitez exécuter.
# 9) Auditeurs
Les auditeurs écoutent chaque événement qui se produit dans les tests. Les écouteurs sont pris en charge à la fois dans JUnit et TestNG. Donc, si vous souhaitez effectuer certaines tâches ou afficher un message spécifique dans le journal avant le début du test, après la fin du test, lorsque le test est ignoré, lorsque le test est réussi ou échoué, nous avons ces fonctions Listener qui nous permettent de fais ça
JUnit utilise la classe Listener et TestNG utilise une interface Listener. TestNG écrit une classe d'écouteur définissant les méthodes d'interface d'écoute, et la deuxième étape consiste à appeler ce nom de classe d'écouteur à l'aide de l'annotation @Listeners dans la classe principale.
JUnit hérite également des méthodes de la classe parent Listener à la suite de laquelle une classe d'exécution Listener est définie pour appliquer les fonctions d'écoute à une ou plusieurs classes principales.
Auditeur dans TestNG
Il existe une interface ITestListener à partir de laquelle TestNG est implémenté.
Vous trouverez ci-dessous les méthodes à définir lors de la mise en œuvre d'ITestListener -
- OnTestStart ()
- OnTestFailure ()
- OnTestSuccess ()
- OnTestSkipped ()
- Au début ()
- À la fin ()
Vous trouverez ci-dessous l'extrait de code démontrant onTestStart () et 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()); } Appelez cette classe d'écouteur dans votre classe principale comme indiqué ci-dessous, en utilisant l'annotation @Listener:
import org.testng.annotations.Listeners; import org.testng.annotations.Test; @Listeners(com.javatpoint.Listener.class) public class MymainClass { @Test public void sum() { Écouteur dans JUnit 5
RunListener est la classe qui doit être étendue par votre classe d'écouteur afin de définir les fonctions d'écouteur.
Nous avons les méthodes suivantes pour JUnit:
- testRunStarted
- testRunFinished
- testFailure
- tesIgnoré
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()); } Il doit y avoir une classe d'exécution d'écouteur create pour appeler la classe d'écouteur ci-dessus.
Vous pouvez appliquer la classe d'écouteur Mylistener à plusieurs classes avec des méthodes de test.
comment ouvrir le fichier .java
public class ListenerRunner { public static void main(String() args) { JUnitCore runme = new JUnitCore(); runme.addListener(new ListenerRunner()); runner.run(FirstClass.class, SecondClass.class); } Conclusion
Dans ce tutoriel JUnit Vs TestNG, nous avons comparé les frameworks TestNG et JUnit. Nous avons appris les fonctionnalités communes prises en charge dans les deux frameworks ainsi que les fonctionnalités supplémentaires prises en charge uniquement dans TestNG. Apparemment, il y a quelques fonctionnalités supplémentaires uniquement dans TestNG, comme l'exécution parallèle et les tests de dépendance. La plupart des fonctionnalités prises en charge par TestNG sont également disponibles dans JUnit.
Il y a de légers écarts en termes de syntaxe, de terminologies dans JUnit vs TestNG pour les fonctionnalités communes. Ceux qui ont miné la force de JUnit sur TestNG auraient réalisé jusqu'à présent que JUnit est également l'un des puissants frameworks d'automatisation.
Nous reviendrons avec de nombreux aspects plus intéressants de JUnit. Tenez-vous-en aux prochains tutoriels !!!
lecture recommandée
- Tutoriel JUnit pour les débutants - Qu'est-ce que le test JUnit
- Liste des annotations JUnit: JUnit 4 vs JUnit 5
- Comment utiliser l'annotation JUnit 5 @RepeatedTest avec des exemples
- JUnit Ignore Test Case: JUnit 4 @Ignore Vs JUnit 5 @Disabled
- Installation de TestNG, programme de base et rapports
- Annotations et auditeurs TestNG
- Tutoriel TestNG: Introduction à TestNG Framework
- Assertions dans Selenium à l'aide des cadres Junit et TestNG