Qu'est-ce que les annotations JUnit?
JUNIT ANNOTATIONS est une forme spéciale de métadonnées syntaxiques qui peuvent être ajoutées au code source Java pour une meilleure lisibilité et une meilleure structure du code. Les variables, paramètres, packages, méthodes et classes peuvent être annotés. Des annotations ont été introduites dans Junit4, ce qui rend le code Java plus lisible et plus simple. C'est la grande différence entre Junit3 et Junit4 que Junit4 est basé sur les annotations.
Avec la connaissance des annotations dans Junit5, on peut facilement apprendre et implémenter un test JUnit. Vous trouverez ci-dessous la liste des annotations importantes et fréquemment utilisées:
| S.No. | Annotations | Description |
|---|---|---|
| 1. | @Test | Cette annotation remplace org.junit.TestCase qui indique que la méthode publique 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 que tous les cas de test, par exemple la connexion de test, ne soient exécutés avant tous les cas de test. |
| 4. | @Après | Cette annotation peut être utilisée si vous souhaitez exécuter des instructions après chaque scénario de test pour, par exemple, réinitialiser des 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 cas de test, par exemple la libération de ressources après l'exécution de tous les cas de test. |
| 6. | @Ne tient pas compte | Cette annotation peut être utilisée si vous souhaitez ignorer certaines instructions pendant l'exécution du test, par exemple la désactivation de certains cas de test pendant l'exécution du test. |
| 7. | @Test (délai d'expiration = 500) | Cette annotation peut être utilisée si vous souhaitez définir un délai pendant l'exécution du test, 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 (attendu = IllegalArgumentException.class) | Cette annotation peut être utilisée si vous souhaitez gérer une exception lors de l'exécution du test. Pour, par exemple, si vous voulez vérifier si une méthode particulière lève une exception spécifiée ou non. |
Dans ce didacticiel, vous apprendrez-
- Exemple d'annotations JUnit
- Classe d'assert JUnit
- Classe de cas de test JUnit
- Classe JUnit TestResult
- Classe de la suite de tests JUnit
Exemple d'annotations JUnit
Créons une classe couvrant les annotations JUnit importantes avec des instructions d'impression simples et exécutons-la avec une classe de lanceur de test:
Étape 1) Considérez ci-dessous la classe Java ayant diverses méthodes qui sont attachées aux annotations énumérées ci-dessus:
JunitAnnotationsExample.java
package guru99.junit;import statique org.junit.Assert.assertEquals;import statique 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;classe publique JunitAnnotationsExample {liste privée ArrayList ;@Avant les courspublic static void m1 () {System.out.println ("Utilisation de @BeforeClass, exécuté avant tous les cas de test");}@Avant quepublic void m2 () {list = new ArrayList ();System.out.println ("Utilisation des annotations @Before, exécutées avant chaque cas de test");}@Après les courspublic static void m3 () {System.out.println ("Utilisation de @AfterClass, exécuté après tous les cas de test");}@Aprèspublic void m4 () {list.clear ();System.out.println ("Utilisation de @After, exécuté après chaque cas de test");}@Testpublic void m5 () {list.add ("test");assertFalse (list.isEmpty ());assertEquals (1, list.size ());}@Ignorerpublic void m6 () {System.out.println ("En utilisant @Ignore, cette exécution est ignorée");}@Test (délai d'expiration = 10)public void m7 () {System.out.println ("En utilisant @Test (timeout), il peut être utilisé pour appliquer le timeout dans le cas de test JUnit4");}@Test (attendu = NoSuchMethodException.class)public void m8 () {System.out.println ("En utilisant @Test (attendu), il vérifiera l'exception spécifiée lors de son exécution");}}
Étape 2) Créons une classe de lanceur de test 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) {Résultat résultat = JUnitCore.runClasses (JunitAnnotationsExample.class);for (Échec d'échec: 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 peuvent être vues sur une console.
- Comme indiqué dans le tableau ci-dessus @Before, @BeforeClass [les méthodes m1 () et m2 ()] seront exécutées avant chacun et avant tous les cas de test respectivement.
- De la même manière @ after, @ afterClass (les méthodes m3 () et m4 ()) seront exécutées après chacun et après tous les cas de test respectivement. @ignore (méthode m6 ()) sera considérée comme ignorant le test.
Analysons en détail les cas de test utilisés dans la classe java ci-dessus:
- Considérez la méthode m5 () comme donnée ci-dessous:
@Testpublic 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 "liste",
- list.isEmpty () retournera false.
- assertFalse (list.isEmpty ()) doit renvoyer true.
- En conséquence, le scénario de test passera .
Comme vous n'avez ajouté qu'une seule chaîne dans la liste, la taille est une.
- list.size () doit renvoyer la valeur int comme "1".
- Donc assertEquals (1, list.size ()) doit retourner true.
- En conséquence, le scénario de test passera .
- Considérez la méthode m7 () comme donnée ci-dessous:
@Test (délai d'expiration = 10)public void m7 () {System.out.println ("En utilisant @Test (timeout), il peut être utilisé pour appliquer le timeout dans le cas de test JUnit4");}
Comme indiqué ci-dessus, l' annotation @Test (timeout = 10) est utilisée pour appliquer le délai d'expiration dans le cas de test.
- Considérez la méthode m8 () comme donnée ci-dessous:
@Test (attendu = NoSuchMethodException.class)public void m8 () {System.out.println ("En utilisant @Test (attendu), il vérifiera l'exception spécifiée lors de son exécution");}
Comme indiqué ci-dessus, @Test (attendu) vérifiera l'exception spécifiée lors de son exécution, donc la méthode m8 () lèvera "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 aboutit à une exécution de test réussie.
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 :
Voir ci-dessous les instructions d'impression qui peuvent être vues 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
En utilisant @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 le timeout dans le cas de test JUnit4
En utilisant @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
En utilisant @After, exécuté après chaque cas de test
Utilisation de @AfterClass, exécuté après tous les cas de test
Classe d'assert JUnit
Cette classe fournit un tas de méthodes d'assertion utiles pour écrire un cas de test. Si toutes les instructions assert sont réussies, les résultats du test réussissent. 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 principales méthodes Assert 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 equals de la classe Object |
| 2. | void assertFalse (condition booléenne) | la fonctionnalité consiste à vérifier qu'une condition est fausse. |
| 3. | void assertNotNull (objet Object) | La fonctionnalité "assertNotNull" consiste à vérifier qu'un objet n'est pas nul. |
| 4. | void assertNull (objet Object) | 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. | void fail () | Si vous voulez lancer 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 ([Message de chaîne] | La fonctionnalité "assertNotSame" consiste à vérifier que les deux objets ne font pas référence au même objet. |
Classe de cas de test JUnit
Pour exécuter plusieurs tests, la classe TestCase est disponible dans les packages org.junit.TestCase . Annotation @Test indique à JUnit que cette méthode publique void (Test Case ici) à laquelle elle est attachée peut être exécutée en tant que test case.
Le tableau ci-dessous montre quelques méthodes importantes disponibles dans la classe org.junit.TestCase :
| 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 la méthode run (TestResult tr) . |
| 2. | TestResult createResult () | Cette méthode est utilisée pour créer un objet TestResult . |
| 3. | Chaîne getName () | Cette méthode renvoie une chaîne qui n'est rien d'autre qu'un TestCase . |
| 4. | TestResult exécuter () | Cette méthode est utilisée pour exécuter un test qui retourne un objet TestResult |
| 5. | void run (résultat TestResult) | Cette méthode est utilisée pour exécuter un test ayant un objet TestResult qui ne renvoie rien. |
| 6. | void setName (nom de chaîne) | Cette méthode est utilisée pour définir le nom d'un TestCase. |
| 7. | void setup() | Cette méthode est utilisée pour écrire le code d'association de ressources. Par exemple, créez une connexion à la base de données. |
| 8. | void tearDown () | Cette méthode est utilisée pour écrire le code de libération des ressources. Par exemple, relâchez la connexion à la base de données après avoir effectué une opération de transaction. |
Classe JUnit TestResult
Lorsque vous exécutez un test, il renvoie un résultat (sous la forme d' un objet TestResult ). 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 de test, AssertionFailedError t) | Cette méthode est utilisée si vous avez besoin d'ajouter un échec à la liste des échecs. |
| 3. | void endTest (test de test) | Cette méthode est utilisée pour notifier qu'un test est effectué (terminé) |
| 4. | int errorCount () | Cette méthode est utilisée pour obtenir l'erreur détectée lors de l'exécution du test. |
| 5. | Erreurs d'énumération | Cette méthode renvoie simplement une collection (énumération ici) d'erreurs. |
| 6. | int failureCount () | Cette méthode est utilisée pour obtenir le nombre d'erreurs détectées lors de l'exécution du test. |
| 7. | void run (test TestCase) | Cette méthode est utilisée pour exécuter un cas de test. |
| 8. | int runCount () | Cette méthode compte simplement le test exécuté. |
| 9. | void startTest (test de test) | Cette méthode est utilisée pour notifier qu'un test est démarré. |
| dix. | void stop () | Cette méthode est utilisée pour tester l'exécution à arrêter. |
Classe de la suite de tests JUnit
Si vous souhaitez exécuter plusieurs tests dans un ordre spécifié, vous pouvez le faire en combinant tous les tests en un seul endroit. Cet endroit s'appelle les suites de tests.
Voir le tableau ci-dessous pour les méthodes importantes utilisées dans la classe org.junit.TestSuite :
| S.No. | Méthode | Description |
|---|---|---|
| 1. | void addTest (test de test) | Cette méthode est utilisée si vous souhaitez ajouter un test à la suite. |
| 2. | void addTestSuite (Classe testClass) | 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. | void run (résultat TestResult) | Cette méthode est utilisée pour exécuter un test et collecter le résultat du test dans l' objet TestResult . |
| 6. | void setName (nom de chaîne) | Cette méthode est utilisée pour définir le nom de TestSuite . |
| 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 et annotations importantes utiles à l'écriture d'un test unitaire.
- Classes très utiles lors de l'écriture d'un cas de test
- org.junit.Assert
- org.junit.TestCase
- org.junit.TestResult
- org.junit.TestSuite
- liste des annotations importantes et fréquemment utilisées
@Avant que
@Avant les cours
@Après
@Après les cours
@Test
@Ignorer