list junit annotations
Ce tutoriel explique tout sur les annotations JUnit avec une comparaison des annotations dans JUnit 4 vs JUnit 5:
Nous avons appris les différentes manières d'exécuter des cas de test JUnit et vu comment créer et exécuter une suite de tests dans notre tutoriel précédent.
Dans ce tutoriel, nous apprendrons à connaître l'aspect proéminent de JUnit qui s'appelle Annotations. À partir de JUnit 4, les annotations sont en place et rendent JUnit très simple, plus avantageux et beaucoup plus convivial à utiliser.
Annotations est une API Java qui permet à JVM de reconnaître le type de méthode défini dans la classe de test. Il existe des «annotations de rappel de cycle de vie» qui sont fréquemment utilisées.
=> Visitez ici pour apprendre JUnit From Scratch.
Ce que vous apprendrez:
Annotations JUnit - JUnit 4 contre JUnit 5
Une exécution de test passe par différentes étapes du cycle de vie comme indiqué ci-dessous:
- Avant de commencer un test, il y a certaines activités à effectuer au début d'un cours.
- Certaines autres activités à effectuer avant le début de l'exécution d'un scénario de test.
- Certaines activités qui doivent être effectuées après l'exécution du test et
- Certaines activités à la fin de l'exécution de tous les tests d'une classe.
Afin de s'assurer que ces activités sont exécutées tout au long de chaque étape du cycle de vie Java, certaines méthodes ou fonctions définies par l'utilisateur doivent être mises en place, appelées « méthodes de rappel du cycle de vie .
Le comportement de ces méthodes de rappel du cycle de vie est déterminé par le « annotations de rappel du cycle de vie ' utilisé dans JUnit.
Exemple: Essayons de le rendre encore plus simple en associant ces méthodes de rappel et annotations de cycle de vie à un exemple de tester un distributeur automatique de café.
- Une méthode machinePrêt () qui vérifie si de l'eau, du lait et des grains de café sont disponibles avant la mise en marche de la machine peut être nécessaire.
- Une autre méthode startMachine () qui allume la machine, place un nouveau gobelet en papier dans la machine peut être nécessaire.
- Un testcase qui vérifie le « Eau chaude () ’Option.
- Un autre testcase qui vérifie le ‘ Cappuccino () ’Option.
- Un autre testcase qui vérifie le ‘ ExpressoCoffee () ’Option.
- Une autre méthode ' lancerCoupe () ”Qui jette les tasses utilisées dans la poubelle.
- Une méthode au niveau de la classe ' throwTrashandSwitchOff () ”Jette le liquide usé débordant du bac dans le bassin et éteint la machine.
Donc, dans l'exemple ci-dessus, voici comment suit le cycle de vie du test:
- startMachine () s'exécutera avant chaque cas de test - Eau chaude (), Cappuccino () et ExpressoCoffee () s'exécute.
- Chacun de ce cas de test suit également la méthode lancerCoupe ().
- Les méthodes machinePrêt () et throwTrashandSwitchOff () sont des méthodes au niveau de la classe qui ne s'exécutent qu'une seule fois pour une classe. La méthode machinePrêt () s'exécute une fois pendant que la classe lance l'exécution. La méthode throwTrashandSwitchOff () s'exécute une fois après l'exécution de tous les cas de test.
Maintenant, la question se pose: ce ne sont que de simples méthodes Java, alors:
c ++ char * à int
- Comment allons-nous insister pour que JVM fonctionne machinePrêt () une seule fois au niveau de la classe et throwTrashandSwitchOff () à la fin de l'exécution de classe?
- Comment ferons-nous savoir à JVM que startMachine () et lancerCoupe () doit être exécuté avant d'exécuter chaque testcase et après la fin de chaque exécution de testcase, respectivement?
- Comment pouvons-nous faire en sorte que JVM identifie que les méthodes Eau chaude (), Cappuccino () et ExpressoCoffee () les cas de test doivent-ils être exécutés?
Réponse: La seule réponse aux questions ci-dessus est que les annotations de rappel du cycle de vie font toute la magie requise.
(Pour l'instant, supposons que nous créons cette classe dans JUnit 4)
Les annotations du cycle de vie - @BeforeClass, @AfterClass, @Before, @After, et @Test sont les vraies réponses aux trois questions ci-dessus. Nous sommes à peu près sûrs qu'après avoir lu les pointeurs ci-dessous, vous serez clair avec les annotations de rappel du cycle de vie et son flux de travail.
- Annoter la méthode machinePrêt () avec @Avant les cours et JVM le fera fonctionner une fois au début du cours.
- Annoter la méthode jeter des déchets () avec @Après les cours et JVM le fera fonctionner une fois à la fin du cours.
- Annoter la méthode startMachine () avec @Avant que et JVM l'exécutera avant l'exécution de chaque cas de test.
- Annoter la méthode lancerCoupe () avec @Après et JVM l'exécutera après l'exécution de chaque scénario de test.
- Annotez chacune de ces méthodes Eau chaude (), Cappuccino () et ExpressoCoffee () avec @Test et JVM sait que ce sont les cas de test principaux pour la classe JUnit à exécuter.
Jetons rapidement un œil à la Annotations de rappel du cycle de vie JUnit pour JUnit 4 vs JUnit 5
| ANNOTATION JUNIT 4 | ANNOTATION JUNIT 5 | |
|---|---|---|
| @Test répété | 1.JUnit 5 prend en charge l'exécution répétée de la méthode de test un certain nombre de fois en utilisant l'annotation @RepeatedTest | |
| @Avant que | @BeforeEach | |
| @Après | @Après chaque | |
| @Avant les cours | @Avant tout | |
| @Après les cours | @Après tout | |
| @Test | @Test |
Flux de travail séquentiel des annotations du cycle de vie
Vous trouverez ci-dessous le flux de travail séquentiel des annotations de cycle de vie pour JUnit 4:
- La méthode annotée avec @BeforeClass est exécutée une fois au début de la classe.
- La méthode annotée avec @Before s'exécute avant le début du Testcase 1.
- La méthode Testcase1 annotée avec @Test est le testcase de la classe.
- La méthode annotée avec @After s'exécute une fois que Testcase 1 a terminé son exécution.
- La méthode annotée avec @Before s'exécute avant le début de Testcase 2.
- La méthode Testcase2 annotée avec @Test est le testcase de la classe.
- La méthode annotée avec @After s'exécute une fois l'exécution de Testcase 2 terminée.
- La méthode annotée avec @AfterClass est exécutée une fois à la fin de la classe après l'exécution des cas de test 1 et 2.
Le flux de travail séquentiel des annotations de cycle de vie pour JUnit 5 est le suivant:
- La méthode annotée avec @BeforeAll est exécutée une fois au début de la classe.
- La méthode annotée avec @BeforeEach s'exécute avant le début du Testcase 1.
- La méthode Testcase1 annotée avec @Test est le testcase de la classe.
- La méthode annotée avec @AfterEach s'exécute une fois que Testcase 1 a terminé l'exécution.
- La méthode annotée avec @BeforeEach s'exécute avant le début de Testcase 2.
- La méthode Testcase2 annotée avec @Test est le testcase de la classe.
- La méthode annotée avec @AfterEach s'exécute une fois que Testcase 2 a terminé l'exécution.
- La méthode annotée avec @AfterAll est exécutée une fois à la fin de la classe après l'exécution des cas de test 1 et 2.
Élaboration sur chaque annotation
Dans cette section, examinons en détail et comprenons en détail ce que fait chacun des annotations de rappel de cycle de vie:
@Before (JUnit 4) / @ BeforeEach (JUnit 5):
- La méthode annotée s'exécute avant l'exécution de chaque méthode de test dans la classe de test.
- Cette annotation peut être utilisée lorsque vous souhaitez que les ressources ou les données de test soient configurées juste avant le lancement de chaque test.
- Par exemple, s'il y a 5 cas de test dans une classe de test JUnit, la méthode annotée avec @ Before / @ BeforeEach s'exécute 5 fois avant chaque exécution du scénario de test.
@After (JUnit 4) / @ AfterEach (JUnit 5):
- La méthode annotée s'exécute après l'exécution de chaque méthode de test de la classe de test.
- Cette annotation peut être utilisée lorsque vous souhaitez avoir à libérer des ressources utilisées ou des données de test après l'exécution de chaque scénario de test.
- Par exemple, s'il y a 5 cas de test dans une classe de test JUnit, la méthode annotée avec @ After / @ AfterEach s'exécute 5 fois après l'exécution des cas de test.
@BeforeClass (JUnit 4) / @ BeforeAll (JUnit 5):
- La méthode annotée s'exécute avant que toutes les méthodes de test d'une classe de test ne soient exécutées.
- Cette annotation peut être utilisée lorsque vous souhaitez configurer des ressources ou tester des données au niveau de la classe.
- Comme cette méthode est annotée avec @ BeforeClass / @ BeforeAll est exécutée une seule fois pour une classe de test et la copie de la méthode est partagée dans toute la classe, et la méthode doit être indiquée statique.
- Par exemple, s'il y a 5 cas de test dans une classe de test JUnit, la méthode annotée avec @ BeforeClass / @ BeforeAll s'exécute une fois par classe de test avant le lancement de tout test.
@AfterClass (JUnit 4) / @ AfterAll (JUnit 5):
- La méthode annotée s'exécute après l'exécution de toutes les méthodes de test d'une classe de test.
- Cette annotation peut être utilisée lorsque vous souhaitez libérer les ressources utilisées ou tester les données au niveau de la classe.
- Comme cette méthode est annotée avec @ AfterClass / @ AfterAll est exécutée une seule fois pour une classe de test et que la copie de la méthode est partagée dans toute la classe, la méthode doit être indiquée statique.
- Par exemple, s'il y a 5 cas de test dans une classe de test JUnit, la méthode annotée avec @ AfterClass / @ AfterAll s'exécute une fois par classe de test après l'exécution de tous les cas de test.
@Test (JUnit 4 et JUnit 5):
- L'annotation @Test est commune pour JUnit 4 ainsi que JUnit 5. Les méthodes annotées représentent les cas de test de la classe.
- Il peut y avoir plusieurs méthodes annotées chacune avec @Test dans une classe JUnit. Cela implique qu'une classe peut avoir plusieurs cas de test.
- Il existe différents attributs ou paramètres à tester que l'on pourrait passer. Vous pouvez ajouter un délai d'expiration forcé pour un scénario de test ou ajouter une exception. Cela sera couvert en détail dans un didacticiel séparé.
- La méthode annotée ne peut pas être privée ou statique et ne peut renvoyer aucune valeur.
- La méthode @Test doit être déclarée comme publique dans JUnit 4 alors que Junit 5 autorise un cas de test défini sans le modificateur d'accès «public» car il considère «aucun modificateur d'accès» comme «public» par défaut.
Exemple de test de base JUNIT
Un basique JUNIT 4 exemple pour les annotations @BeforeClass, @Before, @Test, @After et @AfterClass a été montré à travers le code avec son explication dans notre précédent tutoriel sur 'Test Fixtures'.
Regardons les bases JUnit 5 Programme pour démontrer le fonctionnement des annotations de rappel Lifecycle @BeforeAll, @BeforeEach, @Test, @AfterEach et @AfterAll.
Code pour JUnit5Program.java:
public class JUnit5Program { @BeforeAll public static void preClass() { System.out.println('@BeforeAll – the annotated method runs once before all other methods execute'); } @BeforeEach public void setUp() { System.out.println('_______________________________________________________
'); System.out.println('@BeforeEach – the annotated method executes before each test '); } @Test public void test_JUnit1() { System.out.println('@Test – this is test case 1'); } @Test public void test_JUnit2() { System.out.println('@Test – this is test case 2'); } @Test public void test_JUnit3() { System.out.println('@Test – this is test case 3'); } @AfterEach public void tearDown() { System.out.println('@AfterEach – the annotated method executes after each test executes'); System.out.println('_______________________________________________________
'); } @AfterAll public static void postClass() { System.out.println('@AfterAll – the annotated method runs once after all other methods execute'); } }Lors de l'exécution du fichier de classe, le résultat ci-dessous apparaît dans la fenêtre de la console.
Annotations supplémentaires - JUnit 4 vs JUnit 5
De nombreuses annotations supplémentaires sont utilisées à des fins spécifiques. Nous verrons la liste des annotations pour JUnit 4 vs JUnit 5 et son objectif en bref.
Il y aura un tutoriel détaillé sur chacune de ces annotations dans nos prochains tutoriels.
| ANNOTATION JUNIT 4 | ANNOTATION JUNIT 5 | Description en bref |
|---|---|---|
| @FixMethodOrder | @TestMethodOrder et @Order | 1. Ces annotations permettent à l'utilisateur de choisir l'ordre d'exécution des méthodes au sein d'une classe de test |
| @Rule et @ClassRule | @ExtendWith | 1. @Rule - L'annotation est étendue à partir de la classe TestRule qui permet d'appliquer certaines règles sur les cas de test. 2. Par exemple: la création d'un dossier temporaire avant l'exécution du scénario de test et la suppression du dossier après l'exécution peuvent être définies via une règle. 3. @Rule est disponible uniquement dans JUnit 4 qui peut être utilisé dans JUnit 5 Vintage, cependant, @ExtendWith fournit une fonctionnalité plus proche pour JUnit 5 4. De même, un délai d'expiration global peut être défini à l'aide de @Rule. |
| N / A | @TestFactory | 1. Cette annotation est uniquement prise en charge par JUnit 5 et aide à la création de tests dynamiques ou d'exécution. 2. Il renvoie un flux de données en tant que collection et ne peut pas utiliser d'annotations de rappel de cycle de vie |
| N / A | @ Imbriqué | Cette annotation est prise en charge par JUnit Jupiter uniquement Cela nous aide à créer des cas de test imbriqués. 3.Par exemple, la classe 1 avec testcase 1 peut avoir une @Nested Class 2 avec testcase 2. Cela fait du testcase 2 un test case imbriqué vers testcase 1. Par conséquent, testcase 1 s'exécute, puis testcase 2 s'exécute. 4.Si l'annotation @Nested n'est pas utilisée, la classe imbriquée ne s'exécutera pas. |
| @Catégorie | @Étiqueter | 1.Cette annotation permet de baliser et de filtrer les tests Vous pouvez inclure des tests à exécuter ou les exclure en filtrant en fonction des catégories auxquelles ils appartiennent. |
| @RunWith (Parameterized.class) @ Parameterized.Parameters | @ParameterizedTest et @ValueSource | 1. Cette annotation est utilisée pour exécuter une méthode avec des variations de données de test plusieurs fois. 2.JUnit 4 prend en charge @RunWith et @Parameters tandis que JUnit 5 Jupiter prend en charge @ParameterizedTest avec @ValueSource |
| @Afficher un nom | 1. Un nom défini par l'utilisateur peut être donné à une méthode ou une classe de test à des fins d'affichage. | |
| @TestInstance (LifeCycle.PER_CLASS) et @TestInstance (LifeCycle.PER_METHOD) | 1. JUnit 5 prend en charge la configuration du cycle de vie des tests. 2. Les JUnit 4 et 5 suivent le rappel par défaut du cycle de vie de la méthode, tandis que la configuration par classe peut également être effectuée. |
Références => JUnit 4 , JUnit 5
Conclusion
- Nous avons découvert les annotations de rappel du cycle de vie et le flux de travail séquentiel dans lequel les méthodes de test s'exécutent en fonction de leurs annotations.
- Nous avons appris les annotations utilisées pour JUnit 4 et les annotations pour JUnit 5.
- Nous avons également découvert les annotations supplémentaires prises en charge par JUnit 4 et celles qui ne prennent en charge que JUnit 5.
=> Regardez la série de formation Simple JUnit ici.
lecture recommandée
- Qu'est-ce qu'un montage de test JUnit: Tutoriel avec des exemples JUnit 4
- Tests JUnit: Comment écrire des cas de test JUnit avec des exemples
- Tutoriel JUnit pour les débutants - Qu'est-ce que le test JUnit
- Téléchargez, installez et configurez JUnit dans Eclipse
- Plusieurs façons d'exécuter des tests JUnit
- Introduction à JUnit Framework et à son utilisation dans Selenium Script - Tutoriel Selenium # 11
- Liste secrète pour tableau et autres collections en Java
- Méthodes de liste Java - Trier la liste, contient, ajouter une liste, supprimer une liste