TestNG vs JUnit – Différence entre eux

Différence clé entre TestNG et JUnit

  • TestNG est un framework basé sur Java, tandis que JUnit est un framework de tests unitaires open source pour JAVA.
  • En comparant TestNG et JUnit, les annotations TestNG sont plus faciles à utiliser et à comprendre que JUnit.
  • TestNG nous permet de créer des tests parallèles, alors que JUnit ne prend pas en charge l'exécution de tests parallèles.
  • Dans TestNG, les cas de test peuvent être regroupés, tandis que dans JUnit, le regroupement des tests n'est pas possible.
TestNG contre JUnit
TestNG contre JUnit

Qu'est-ce que TestNG?

TestNG est un cadre de test d'automatisation dans lequel NG signifie « Next Generation ». TestNG s'inspire de JUnit qui utilise les annotations (@). TestNG surmonte les inconvénients de JUnit et est conçu pour faire tests de bout en bout facile.

En utilisant TestNG, vous pouvez générer un rapport approprié et vous pouvez facilement savoir combien de cas de test ont réussi, échoué et ignorés. Vous pouvez exécuter les scénarios de test ayant échoué séparément.

Qu'est-ce que Junit ?

JUnit est une unité open source Essais Cadre pour JAVA. Il est utile pour Java Les développeurs doivent écrire et exécuter des tests reproductibles. Erich Gamma et Kent Beck le développent initialement. C'est une instance de xUnit architecture. Comme son nom l'indique, il est utilisé pour Tests unitaires d'un petit morceau de code.

Les développeurs qui suiventwing La méthodologie basée sur les tests doit écrire et exécuter des tests unitaires avant tout code.

Une fois que vous avez terminé avec le code, vous devez exécuter tous les tests et cela devrait réussir. Chaque fois qu'un code est ajouté, vous devez réexécuter tous les cas de test et vous assurer que rien n'est cassé.

Différences entre JUnit et TestNG

TestNG et JUnit4 se ressemblent tous deux, à l'exception d'une ou deux fonctionnalités. Faisons une comparaison entre les deux pour décider rapidement quelle technologie est la plus favorable aux tests unitaires. Le tableau ci-dessous met en évidence les fonctionnalités prises en charge par les deux :

Différences entre JUnit et TestNG

Annotations

JUnit et TestNG utilisent des annotations et presque toutes les annotations se ressemblent.

TestNG utilise @BeforeMethod ,@AfterMethod similaire à @Before ,@After dans JUnit4.

TestNG et Junit4 utilisent @Test(timeout = 1000) pour le délai d'expiration. Consultez le tableau ci-dessous pour plus de détails.tails-

SN Description TestNG Unité 4
1 Annotation de test @Tester @Tester
2 S'exécute avant que la première méthode de test ne soit invoquée dans la classe actuelle @Avant les cours @Avant les cours
3 S'exécute après toutes les méthodes de test de la classe actuelle @Après les cours @Après les cours
4 S'exécute avant chaque méthode de test @AvantMéthode @Avant que
5 S'exécute après chaque méthode de test @AprèsMéthode @Après
6 annotation pour ignorer un test @Test (activer = faux) @ignorer
7 annotation pour exception @Test (expectedExceptions = ArithmeticException.class) @Test (attendu = ArithmeticException.class)
8 temps mort @Test (délai d'attente = 1000) @Test (délai d'attente = 1000)
9 S'exécute avant tous les tests de la suite @AvantSuite n / a
10 S'exécute après tous les tests de la suite @AprèsSuite n / a
11 S'exécute avant l'exécution d'un test @AvantTest n / a
12 S'exécute après un test @AprèsTest n / a
13 S'exécute avant l'appel de la première méthode de test appartenant à l'un de ces groupes. @AvantGroupes n / a
14 exécuter après la dernière méthode de test appartenant à l'un des groupes ici @AfterGroups n / a

Test de la suite

Les suites sont utilisées pour exécuter plusieurs tests ensemble. Les suites peuvent être créées à l'aide de TestNG et JUnit4. Cependant, les suites sont plus puissantes dans TestNG car elles utilisent des méthodes très différentes pour l'exécution des tests. Comprenons-le en utilisant l'extrait de code ci-dessous :

Utiliser JUnit4

La classe ci-dessous décrit l'utilisation de la suite lorsque vous travaillez avec JUnit4 :

package guru99.junit;		
import org.junit.runner.RunWith;		
import org.junit.runners.Suite;		

@RunWith(Suite.class)				
@Suite.SuiteClasses({				
    SuiteTest1.class,			
    SuiteTest2.class,			

})		

public class JunitTest {		
// This class remains empty,it is used only as a holder for the above annotations		
}

Utilisation de TestNG

TestNG utilise XML pour regrouper tous les tests en un seul endroit. Ci-dessous, XML décrit l'utilisation de la suite lorsque vous travaillez avec TestNG :

<!DOCTYPE suite SYSTEM "http://beust.com/testng/testng-1.0.dtd" >
<suite name="My test suite">
<test name="testing">
<classes>
<class name="com.guru99.SuiteTest1" />
<class name="com.guru99.SuiteTest2" />
</classes>
</test>
</suite>

Ignorer le test

En utilisant les deux, nous pouvons ignorer un test. Voyons-le en utilisant l'exemple de code ci-dessous :

Utiliser JUnit4

L'extrait de code ci-dessous décrit l'utilisation de l'annotation @ignore lorsque vous travaillez avec JUnit4 :

@Ignore
public void method1() 
{
	System.out.println("Using @Ignore , this execution is ignored");
}

Utilisation de TestNG

L'extrait de code ci-dessous décrit l'utilisation de l'annotation @Test(enabled=false) lorsque vous travaillez avec TestNG :

@Test(enabled=false)
public void TestWithException()
{  
	System.out.println("Method should be ignored as it's not ready yet");
}

Test d'exception

Les tests d'exception sont disponibles à la fois dans TestNG et JUnit4. Il est utilisé pour vérifier quelle exception est levée du test ?

Utiliser JUnit4

L'extrait de code ci-dessous décrit l'utilisation du test d'exception lors de l'utilisation de JUnit4 :

@Test(expected = ArithmeticException.class)  
public void divideByZero() 
{  
	Int i = 1/0;
}

Utilisation de TestNG

L'extrait de code ci-dessous décrit l'utilisation du test d'exception lorsque vous travaillez avec TestNG :

@Test(expectedExceptions = ArithmeticException.class)  
public void divideByZero()
{  
Int i = 1/0;
}	

Temps mort

Cette fonctionnalité est implémentée à la fois dans TestNg et JUnit4.Timeout est utilisé pour terminer un test qui prend plus de temps que spécifié (en millisecondes).

Utiliser JUnit4

L'extrait de code ci-dessous décrit l'utilisation du test de délai d'attente lorsque vous travaillez avec JUnit4 :

@Test(timeout = 1000)  
public void method1()
{  
	while (true);  
}

Utilisation de TestNG

L'extrait de code ci-dessous décrit l'utilisation du test de délai d'attente lorsque vous travaillez avec TestNG :

@Test(timeOut = 1000)  
public void method1()
{  
	while (true);  
}

Test paramétré

JUnit fournit une approche de test plus simple et lisible connue sous le nom de test paramétré. TestNG et JUnit prennent tous deux en charge les tests paramétrés mais diffèrent dans la manière dont ils définissent la valeur du paramètre. Voyons cela un par un.

Utiliser JUnit4

Les annotations « @RunWith » et « @Parameter » sont utilisées pour fournir la valeur du paramètre pour le test unitaire. L'annotation @Parameters doit renvoyer List[] . Ce paramètre sera passé au constructeur de classe en tant qu'argument.

@RunWith(value = Parameterized.class)
public class JunitTest{
    
    privateint number;
    
    public JunitTest6(int number)
 {
    this.number = number;
     }

     @Parameters
    public static Collection<Object[]> data() 
{
       Object[][] data = new Object[][] { { 1 }, { 2 }, { 3 }, { 4 } };
    returnArrays.asList(data);
    }
     
     @Test
    public void parameterTest()
 {
    System.out.println("Parameterized Number is : " + number);
     }
}

Utilisation de TestNG

Dans TestNG, le fichier XML ou « @DataProvider » est utilisé pour fournir un paramètre à tester.

Ici, l'annotation @Parameters déclarée dans la méthode nécessite un paramètre pour les tests. Les données utilisées comme paramètre seront fournies dans les fichiers de configuration XML de TestNG. En faisant cela, nous pouvons réutiliser un seul Cas de test avec différents ensembles de données, et nous pouvons obtenir des résultats différents.

public class Test1 {

    @Test
    @Parameters(value="number")
    public void parameterTest(int number)
	{
    	System.out.println("Parameterized Number is : " + number);
    }
     
}

Voir le fichier XML ci-dessous à utiliser pour la classe ci-dessus :

<!DOCTYPE suite SYSTEM "http://beust.com/testng/testng-1.0.dtd" >
<suite name="My test suite">
<test name="testing">
    
<parameter name="number" value="2"/>    

<classes>
<class name="com.guru99.Test1" />
</classes>
</test>
</suite>

Résumé

Nous avons vu la comparaison JUnit4 et TestNG dans details. Nous avons également vu que les deux sont similaires, à l'exception du test paramétré et du test de dépendance. En bref, nous pouvons dire qu'en fonction de la flexibilité et des exigences, nous pouvons choisir n'importe lequel d'entre eux pour les tests unitaires.