Home-theater-designers
Lorsque vous écrivez une suite de tests unitaires, vous devrez peut-être effectuer certaines activités non liées aux tests. Ces activités peuvent prendre n'importe quelle forme. Vous devrez peut-être vous connecter à une base de données ou rassembler des ressources avant d'effectuer un test. Après l'exécution de chaque scénario de test, vous devrez peut-être libérer certaines ressources.
UTILISEZ LA VIDÉO DU JOUR
L'exécution de l'une de ces activités non liées aux tests en dehors du cadre d'une classe de tests unitaires peut s'avérer fastidieuse, voire impossible. L'exécution réussie de votre classe de test peut dépendre de ces activités, JUnit fournit donc deux paires d'annotations pour résoudre ce problème.
L'annotation @AvantTout
Une classe de test JUnit peut avoir une ou plusieurs méthodes de test. L'annotation @BeforeAll signale qu'une méthode spécifique doit s'exécuter avant toutes les méthodes de test d'une classe de test. La méthode associée à cette annotation ne s'exécute qu'une seule fois (au début du test) quel que soit le nombre de méthodes de test dans la classe de test.
Toute méthode qui utilise l'annotation @BeforeAll doit suivre quelques stipulations. Ces méthodes doivent avoir un type de retour void, doivent être publiques et ne doivent pas être privées. L'annotation @BeforeAll est idéale pour établir un connexion à une base de données ou créer un nouveau fichier. Cet article utilise une classe de test de calculatrice pour montrer comment vous pouvez utiliser l'annotation @BeforeAll.
La classe Calculatrice
package com.app;
public class Calculator {
public static int add(int num1, int num2) {
return num1 + num2;
}
public static int subtract(int num1, int num2) {
return num1 - num2;
}
public static int multiply(int num1, int num2) {
return num1 * num2;
}
public static int divide(int num1, int num2) {
return num1 / num2;
}
}La classe CalculatorTest
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.DisplayName;
@DisplayName("Test class demonstrating how to use the before and after annotations.")
class CalculatorTest {
@BeforeAll
public static void powerOnCalculator() {
System.out.println("The calculator is on");
}
@Test
@DisplayName("Testing method that adds two integer values.")
public void testAdd() {
assertEquals(7, Calculator.add(3, 4));
}
@Test
@DisplayName("Testing method that subtracts one integer value from another.")
public void testSubtract() {
assertEquals(6, Calculator.subtract(9, 3));
}
@Test
@DisplayName("Testing method that multiplies two integer values")
public void testMultiply() {
assertEquals(10, Calculator.multiply(5, 2));
}
@Test
@DisplayName("Testing method that divides one integer value by another")
public void testDivide() {
assertEquals(2, Calculator.divide(4, 2));
}
}Dans cette classe, l'annotation @BeforeAll fonctionne avec la méthode powerOnCalculator(), qui imprime 'La calculatrice est allumée' avant toute exécution de test. L'exécution réussie du test imprime le rapport de test suivant :
Comme vous pouvez le constater, la méthode associée à l'annotation @BeforeAll n'apparaît pas dans le rapport de test. Cependant, s'il y a une erreur dans la méthode d'annotation @BeforeAll, les résultats du rapport de test l'indiqueront avec un échec.
que signifie utiliser l'accélération matérielle lorsqu'elle est disponible
L'annotation @BeforeEach
Comme la méthode annotée @BeforeAll, la méthode annotée @BeforeEach n'apparaîtra pas dans le rapport de test. La méthode annotée @BeforeEach s'exécute avant chaque méthode de test dans une classe de test. Ainsi, si une classe de test contient deux méthodes de test, l'annotation @BeforeEach s'exécutera deux fois.
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@DisplayName("Test class demonstrating how to use the before and after annotations.")
class CalculatorTest {
@BeforeAll
public static void powerOnCalculator() {
System.out.println("The calculator is on");
}
@BeforeEach
public void clearCalculator() {
System.out.println("The calculator is ready");
}
@Test
@DisplayName("Testing method that adds two integer values.")
public void testAdd() {
assertEquals(7, Calculator.add(3, 4));
}
@Test
@DisplayName("Testing method that subtracts one integer value from another.")
public void testSubtract() {
assertEquals(6, Calculator.subtract(9, 3));
}
@Test
@DisplayName("Testing method that multiplies two integer values")
public void testMultiply() {
assertEquals(10, Calculator.multiply(5, 2));
}
@Test
@DisplayName("Testing method that divides one integer value by another")
public void testDivide() {
assertEquals(2, Calculator.divide(4, 2));
}
}
L'ajout de l'annotation @BeforeEach à la classe CalculatorTest produit la sortie suivante :
La méthode associée à l'annotation @BeforeEach s'exécute quatre fois, une fois avant chaque méthode de test. Vous devez noter que la méthode @BeforeEach n'est pas statique, a un type de retour vide et n'est pas privée, car ce sont des stipulations obligatoires. Il est également important de noter que la méthode associée à l'annotation @BeforeEach s'exécute après la méthode @BeforeAll.
L'annotation @AfterAll
Une méthode avec l'annotation @AfterAll s'exécutera une fois que toutes les méthodes de test de la classe de test auront terminé leur exécution. L'annotation @AfterAll est idéale pour opérations de base sur les fichiers , comme la fermeture d'un fichier ou la déconnexion d'une base de données. L'annotation @AfterAll est le pendant de l'annotation @BeforeAll. Comme l'annotation @BeforeAll, l'annotation @AfterAll doit être statique, doit renvoyer void et ne pas être privée.
@AfterAll
public static void powerOffCalculator() {
System.out.println("The calculator is off");
}L'ajout de la méthode annotée @AfterAll à la classe CalculatorTest existante imprime la sortie suivante sur la console :
Notez que la méthode powerOffCalculator(), qui utilise l'annotation @AfterAll, s'imprime à la fin de la classe de test, après l'exécution de toutes les méthodes de test.
L'annotation @AfterEach
L'annotation @AfterEach est le pendant de l'annotation @BeforeEach. Ils ont les mêmes stipulations obligatoires, légèrement différentes de celles des annotations @BeforeAll et @AfterAll. Ce qui distingue l'annotation @AfterEach de l'annotation @BeforeEach (autres que leurs noms) est que la méthode @AfterEach s'exécute après chaque méthode de test.
@AfterEach
public void returnResults() {
System.out.println("The results are ready");
}L'exécution de la classe CalculatorTest imprime la sortie suivante sur la console :
La sortie montre que la méthode associée à l'annotation @AfterEach (returnResults) s'imprime quatre fois. Chaque exécution de la méthode returnResults() ne se produit qu'après l'exécution de chaque test unitaire. Cela est évident par le fait que la sortie de la méthode returnResults() apparaît après chaque sortie de la méthode associée à l'annotation @BeforeEach.
Peaufinez vos suites de tests à l'aide d'annotations
JUnit vous permet de gérer des processus non liés aux tests en utilisant les annotations de paire avant et après. Ces quatre annotations font partie d'une liste de plusieurs autres annotations qui ajoutent de la valeur à vos tests. Une autre des annotations de JUnit est @DisplayName.
Les deux exemples de code qui affichent la classe CalculatorTest complète utilisent l'annotation @DisplayName. L'annotation @DisplayName vous aide à créer des noms plus significatifs pour vos classes de test et vos méthodes de test.