JUnit Tutoriel d'annotations avec exemple : Qu'est-ce que @Test et @After

Par : George McGovern George McGovern
Hours Le kit de préparation mis à jour

Qu’est ce qu' JUnit Annotation ?

JUnit Annotations est une forme spéciale de métadonnées syntaxiques qui peuvent être ajoutées à Java code source pour une meilleure lisibilité et structure du code. Les variables, paramètres, packages, méthodes et classes peuvent être annotés. Les annotations ont été introduites dans Junit4, ce qui rend Java code plus lisible et plus simple. C'est la grande différence entre Junit3 et Junit4 : Junit4 est basé sur les annotations.

Avec la connaissance des annotations dans Junit5, on peut facilement apprendre et mettre en œuvre un JUnit test. Vous trouverez ci-dessous les informations importantes et fréquemment utilisées JUnit liste d'annotations :

S.No. Annotations Description
1. @Tester Cette annotation remplace org.junit.TestCase qui indique que la méthode public void à laquelle elle est attachée peut être exécutée en tant que scénario de test.
2. @Avant que Cette annotation est utilisée si vous souhaitez exécuter une instruction telle que des conditions préalables avant chaque scénario de test.
3. @Avant les cours Cette annotation est utilisée si vous souhaitez exécuter certaines instructions avant tous les cas de test, par exemple la connexion de test doit être exécutée avant tous les cas de test.
4. @Après Cette annotation peut être utilisée si vous souhaitez exécuter certaines instructions après chaque Cas de test par exemple, réinitialiser les variables, supprimer des fichiers temporaires, des variables, etc.
5. @Après les cours Cette annotation peut être utilisée si vous souhaitez exécuter certaines instructions après tous les scénarios de test, par exemple en libérant des ressources après l'exécution de tous les scénarios de test.
6. @Ne tient pas compte Cette annotation peut être utilisée si vous souhaitez ignorer certaines instructions lors de l'exécution du test, par exemple en désactivant certains scénarios de test lors de l'exécution du test.
7. @Test(délai d'attente=500) Cette annotation peut être utilisée si vous souhaitez définir un délai d'attente pendant l'exécution des tests, par exemple si vous travaillez sous un SLA (accord de niveau de service) et que les tests doivent être terminés dans un délai spécifié.
8. @Test (expected = IllegalArgumentException.class) Cette annotation peut être utilisée si vous souhaitez gérer une exception lors de l'exécution du test. Par exemple, si vous souhaitez vérifier si une méthode particulière lève ou non une exception spécifiée.

JUnit Exemple d'annotations

Créons une classe couvrant les sujets importants JUnit annotations avec des instructions d'impression simples et exécutez-les avec une classe d'exécution de tests :

Étape 1) Considérez ci-dessous la classe Java ayant diverses méthodes attachées aux annotations répertoriées ci-dessus :

Exemple d'annotations Junit.java

package guru99.junit;		

import static org.junit.Assert.assertEquals;				
import static org.junit.Assert.assertFalse;				

import java.util.ArrayList;		

import org.junit.After;		
import org.junit.AfterClass;		
import org.junit.Before;		
import org.junit.BeforeClass;		
import org.junit.Ignore;		
import org.junit.Test;		

public class JunitAnnotationsExample {				

    private ArrayList<String> list;					

    @BeforeClass		
    public static void m1() {							
        System.out.println("Using @BeforeClass , executed before all test cases ");					
    }		

    @Before		
    public void m2() {					
        list = new ArrayList<String>();					
        System.out.println("Using @Before annotations ,executed before each test cases ");					
    }		

    @AfterClass		
    public static void m3() {							
        System.out.println("Using @AfterClass ,executed after all test cases");					
    }		

    @After		
    public void m4() {					
        list.clear();			
        System.out.println("Using @After ,executed after each test cases");					
    }		

    @Test		
    public void m5() {					
        list.add("test");					
        assertFalse(list.isEmpty());			
        assertEquals(1, list.size());			
    }		

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

    @Test(timeout = 10)			
    public void m7() {					
        System.out.println("Using @Test(timeout),it can be used to enforce timeout in JUnit4 test case");					
    }		

    @Test(expected = NoSuchMethodException.class)					
    public void m8() {					
        System.out.println("Using @Test(expected) ,it will check for specified exception during its execution");					

    }		

}

Étape 2) Créons une classe d'exécuteur de tests pour exécuter le test ci-dessus :

TestRunner.java

package guru99.junit;		

import org.junit.runner.JUnitCore;		
import org.junit.runner.Result;		
import org.junit.runner.notification.Failure;		

public class TestRunner {				
			public static void main(String[] args) {									
      Result result = JUnitCore.runClasses(JunitAnnotationsExample.class);					
			for (Failure failure : result.getFailures()) {							
         System.out.println(failure.toString());					
      }		
      System.out.println("Result=="+result.wasSuccessful());							
   }		
}

résultat attendu

  • Tous les cas de test seront exécutés un par un et toutes les instructions d'impression seront visibles sur une console.
  • Comme indiqué dans le tableau ci-dessus @Avant l'annotation dans JUnit, @BeforeClass [ méthode m1() et m2() ] sera exécutée respectivement avant chaque et avant tous les cas de test.
  • De la même manière @After dans JUnit, @afterClass (méthodes m3() et m4()) sera exécuté respectivement après chaque et après tous les cas de test. @ignore (méthode m6())sera traité comme ignorant le test.

Analysons en détail les cas de test utilisés dans la classe Java ci-dessus :

  1. Considérez la méthode m5() comme indiqué ci-dessous :
	@Test		
    public void m5() {					
        list.add("test");					
        assertFalse(list.isEmpty());			
        assertEquals(1, list.size());			
    }

Dans la méthode ci-dessus, lorsque vous ajoutez une chaîne dans la variable « list », donc

  • liste.isEmpty() retournera faux.
  • assertFalse(list.isEmpty()) doit retourner vrai.
  • En conséquence, le scénario de test sera pass.

Comme vous n’avez ajouté qu’une seule chaîne dans la liste, la taille est donc une.

  • liste.size() doit renvoyer la valeur int comme « 1 ».
  • So assertEquals(1, list.size()) doit retourner vrai.
  • En conséquence, le scénario de test sera pass.
  1. Considérez la méthode m7() comme indiqué ci-dessous :
@Test(timeout = 10)		
    public void m7() {					
        System.out.println("Using @Test(timeout),it can be used to enforce timeout in JUnit4 test case");					
    }

Comme discuté ci-dessus @Test (délai d'attente = 10)L'annotation est utilisée pour appliquer un délai d'attente dans le scénario de test.

  1. Considérez la méthode m8() comme indiqué ci-dessous :
@Test(expected = NoSuchMethodException.class)				
    public void m8() {					
        System.out.println("Using @Test(expected) ,it will check for specified exception during its execution");					
    
    }

Comme discuté ci-dessus @Test (attendu) vérifiera l'exception spécifiée lors de son exécution, donc la méthode m8() lancera « Aucune exception de méthode de ce type ». En conséquence, le test sera exécuté avec une exception.

Comme tous les cas de test sont réussis, cela entraîne une exécution réussie du test.

Résultat actuel

Comme il y a trois cas de test dans l'exemple ci-dessus, tous les cas de test seront exécutés un par un. Voir la sortie ci-dessous :

JUnit Exemple d'annotations
JUnit Exemple d'annotations

Voir ci-dessous les déclarations d'impression visibles sur la console :

Utilisation de @BeforeClass , exécuté avant tous les cas de test

Utilisation des annotations @Before, exécutées avant chaque cas de test

Utilisation de @After, exécuté après chaque cas de test

Utilisation des annotations @Before, exécutées avant chaque cas de test

En utilisant @Test(timeout), il peut être utilisé pour appliquer un délai d'attente dans JUnit4 cas de tests

Utilisation de @After, exécuté après chaque cas de test

Utilisation des annotations @Before, exécutées avant chaque cas de test

En utilisant @Test (attendu), il vérifiera l'exception spécifiée lors de son exécution

Utilisation de @After, exécuté après chaque cas de test

Utilisation de @AfterClass, exécuté après tous les cas de test

ARTICLES LIÉS

JUnit Classe d'affirmation

Cette classe fournit un ensemble de méthodes d'assertion utiles pour écrire un scénario de test. Si toutes les instructions assert sont réussies, les résultats du test sont réussis. Si une instruction assert échoue, les résultats du test échouent.

Comme vous l'avez vu précédemment, le tableau ci-dessous décrit les méthodes d'assertion importantes et leur description :

S.No. Méthode Description
1. void assertEquals (booléen attendu, booléen réel) Il vérifie si deux valeurs sont égales, similaires à la méthode égale de la classe Object.
2. void assertFalse (condition booléenne) la fonctionnalité consiste à vérifier qu’une condition est fausse.
3. void assertNotNull (objet objet) La fonctionnalité « assertNotNull » consiste à vérifier qu'un objet n'est pas nul.
4. void assertNull (objet objet) La fonctionnalité « assertNull » consiste à vérifier qu'un objet est nul.
5. void assertTrue (condition booléenne) La fonctionnalité « assertTrue » consiste à vérifier qu'une condition est vraie.
6. Échec nul() Si vous souhaitez générer une erreur d'assertion, vous avez fail() qui aboutit toujours à un verdict d'échec.
7. void assertSame ([String message] La fonctionnalité « assertSame » consiste à vérifier que les deux objets font référence au même objet.
8. void assertNotSame ([String message] La fonctionnalité « assertNotSame » consiste à vérifier que les deux objets ne font pas référence au même objet.

JUnit Classe de cas de test

Pour exécuter plusieurs tests, la classe TestCase est disponible dans org.junit.TestCase paquets. L'annotation @Test indique JUnit que cette méthode public void (Cas de test ici) à laquelle elle est attachée peut être exécutée comme scénario de test.

Le tableau ci-dessous montre quelques méthodes importantes disponibles dans org.junit.TestCase classe:

S.No. Méthode Description
1. int countTestCases() Cette méthode est utilisée pour compter le nombre de cas de test exécutés par exécuter (TestResult tr) méthode.
2. TestResult créerResult() Cette méthode est utilisée pour créer un Résultat du test objet.
3. Chaîne getName () Cette méthode renvoie une chaîne qui n'est rien d'autre qu'un Cas de test.
4. Exécution du résultat du test() Cette méthode est utilisée pour exécuter un test qui renvoie un Résultat du test objet
5. exécution nulle (résultat TestResult) Cette méthode permet d'exécuter un test ayant un Résultat du test objet qui ne renvoie rien.
6. void setName (nom de chaîne) Cette méthode est utilisée pour définir le nom d'un Cas de test.
7. void setup() Cette méthode est utilisée pour écrire du code d'association de ressources. par exemple Créer une connexion à une base de données.
8. annuler le démontage() Cette méthode est utilisée pour écrire le code de version de ressource. Par exemple, libérer la connexion à la base de données après avoir effectué une opération de transaction.

JUnit Classe TestResult

Lorsque vous exécutez un test, il renvoie un résultat (sous forme de Résultat du test objet). Cet objet TestResult peut être utilisé pour analyser l'objet résultant. Ce résultat de test peut être un échec ou un succès.

Voir le tableau ci-dessous pour les méthodes importantes utilisées dans la classe org.junit.TestResult :

S.No. Méthode Description
1. void addError (Test test, Throwable t) Cette méthode est utilisée si vous avez besoin d'ajouter une erreur au test.
2. void addFailure (Test test, AssertionFailedError t) Cette méthode est utilisée si vous souhaitez ajouter un échec à la liste des échecs.
3. void endTest(Test test) Cette méthode est utilisée pour notifier qu'un test est effectué (terminé)
4. int nombre d'erreurs() Cette méthode est utilisée pour obtenir l'erreur détectée lors de l'exécution du test.
5. Énumération les erreurs() Cette méthode renvoie simplement une collection (Enumeration ici) d'erreurs.
6. int échecCount() Cette méthode est utilisée pour obtenir le nombre d'erreurs détectées lors de l'exécution du test.
7. exécution annulée (test TestCase) Cette méthode est utilisée pour exécuter un scénario de test.
8. int runCount() Cette méthode compte simplement le test exécuté.
9. void startTest (Test test) Cette méthode est utilisée pour notifier qu'un test est démarré.
10. annuler l'arrêt() Cette méthode est utilisée pour tester l'exécution à arrêter.

JUnit Classe de suite de tests

Si vous souhaitez exécuter plusieurs tests dans un ordre spécifié, cela peut être fait en combinant tous les tests en un seul endroit. Cet endroit est appelé les suites de tests.

Voir le tableau ci-dessous pour les méthodes importantes utilisées dans org.junit.TestSuite classe:

S.No. Méthode Description
1. void addTest (Test test) Cette méthode est utilisée si vous souhaitez ajouter un test à la suite.
2. void addTestSuite(Classe classe de test) Cette méthode est utilisée si vous souhaitez spécifier la classe lors de l'ajout d'un test à la suite.
3. int countTestCases() Cette méthode est utilisée si vous souhaitez compter le nombre de cas de test.
4. Chaîne getName () Cette méthode est utilisée pour obtenir le nom de la suite de tests.
5. exécution nulle (résultat TestResult) Cette méthode est utilisée pour exécuter un test et collecter le résultat du test dans Résultat du test objet.
6. void setName (nom de chaîne) Cette méthode est utilisée pour définir le nom de Suite de tests.
7. Test testAt (index int) Cette méthode est utilisée si vous souhaitez renvoyer le test à un index donné.
8. int testCount() Cette méthode est utilisée si vous souhaitez renvoyer un certain nombre de tests dans la Suite.
9. Avertissement de test statique (message de chaîne) Cette méthode renvoie un test qui échouera et enregistrera un message d'avertissement.

Résumé

  • JUnit fournit une API portable, qui fournit toutes les classes importantes et Selenium annotations utiles pour rédiger un test unitaire.
  • Des cours très utiles lors de la rédaction d'un cas de test
    • org.junit.Assert
    • org.junit.TestCase
    • org.junit.TestResult
    • org.junit.TestSuite
  • Important et fréquemment utilisé JUnit liste d'annotations@Avant@AvantClasse@Après

    @Après les cours

    @Tester

    @Ignorer

Tu pourrais aimer: