Home-theater-designers
Quando scrivi una suite di unit test, potrebbero esserci alcune attività non correlate ai test che devi eseguire. Queste attività possono assumere qualsiasi forma. Potrebbe essere necessario connettersi a un database o raccogliere risorse prima di eseguire un test. Dopo l'esecuzione di ogni test case, potrebbe essere necessario rilasciare alcune risorse.
FARE USO DEL VIDEO DEL GIORNO
L'esecuzione di una di queste attività non correlate al test al di fuori dell'ambito di una classe di unit test potrebbe essere noiosa se non impossibile. La corretta esecuzione della tua classe di test può dipendere da queste attività, quindi JUnit fornisce due coppie di annotazioni per risolvere questo problema.
L'annotazione @BeforeAll
Una classe di test JUnit può avere uno o più metodi di test. L'annotazione @BeforeAll segnala che un metodo specifico deve essere eseguito prima di tutti i metodi di test in una classe di test. Il metodo associato a questa annotazione viene eseguito solo una volta (all'inizio del test) indipendentemente dal numero di metodi di test nella classe di test.
Qualsiasi metodo che utilizza l'annotazione @BeforeAll deve seguire alcune disposizioni. Questi metodi devono avere un tipo restituito void, devono essere pubblici e non privati. L'annotazione @BeforeAll è ideale per stabilire a connessione a un database o creando un nuovo file. Questo articolo usa una classe di prova calcolatrice per mostrare come utilizzare l'annotazione @BeforeAll.
La classe calcolatrice
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));
}
}In questa classe, l'annotazione @BeforeAll funziona con il metodo powerOnCalculator(), che stampa 'La calcolatrice è attiva' prima di qualsiasi esecuzione di test. L'esecuzione del test riuscita stampa il seguente rapporto di test:
come non fare l'identificativo del chiamante
Come puoi vedere il metodo associato all'annotazione @BeforeAll non appare nel rapporto di prova. Tuttavia, se si verifica un errore nel metodo di annotazione @BeforeAll, i risultati del rapporto di prova lo indicheranno con un errore.
L'annotazione @BeforeEach
Come il metodo annotato @BeforeAll, il metodo annotato @BeforeEach non verrà visualizzato nel rapporto di prova. Il metodo annotato @BeforeEach viene eseguito prima di ogni metodo di test in una classe di test. Quindi, se una classe di test contiene due metodi di test, l'annotazione @BeforeEach verrà eseguita due volte.
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'aggiunta dell'annotazione @BeforeEach alla classe CalculatorTest produce il seguente output:
Il metodo associato all'annotazione @BeforeEach viene eseguito quattro volte, una prima di ogni metodo di test. Si noti che il metodo @BeforeEach non è statico, ha un tipo restituito void e non è privato, poiché si tratta di disposizioni obbligatorie. È anche importante notare che il metodo associato all'annotazione @BeforeEach viene eseguito dopo il metodo @BeforeAll.
L'annotazione @AfterAll
Un metodo con l'annotazione @AfterAll verrà eseguito dopo che tutti i metodi di test nella classe di test hanno completato la loro esecuzione. L'annotazione @AfterAll è l'ideale per operazioni di base sui file , come chiudere un file o disconnettersi da un database. L'annotazione @AfterAll è la controparte dell'annotazione @BeforeAll. Come l'annotazione @BeforeAll, l'annotazione @AfterAll deve essere statica, deve restituire void e molto non deve essere privata.
@AfterAll
public static void powerOffCalculator() {
System.out.println("The calculator is off");
}L'aggiunta del metodo annotato @AfterAll alla classe CalculatorTest esistente stampa il seguente output sulla console:
perché Windows Vista era così brutto?
Si noti che il metodo powerOffCalculator(), che utilizza l'annotazione @AfterAll, viene stampato alla fine della classe di test, dopo l'esecuzione di tutti i metodi di test.
L'annotazione @AfterEach
L'annotazione @AfterEach è la controparte dell'annotazione @BeforeEach. Hanno le stesse disposizioni obbligatorie, leggermente diverse da quelle delle annotazioni @BeforeAll e @AfterAll. Ciò che distingue l'annotazione @AfterEach dall'annotazione @BeforeEach (diversa dai nomi) è che il metodo @AfterEach viene eseguito dopo ogni metodo di test.
@AfterEach
public void returnResults() {
System.out.println("The results are ready");
}L'esecuzione della classe CalculatorTest stampa il seguente output sulla console:
L'output mostra che il metodo associato all'annotazione @AfterEach (returnResults) viene stampato quattro volte. Ogni esecuzione del metodo returnResults() avviene solo dopo l'esecuzione di ogni unit test. Ciò è evidente dal fatto che l'output del metodo returnResults() viene visualizzato dopo ogni output del metodo associato all'annotazione @BeforeEach.
Lucida le tue suite di test usando le annotazioni
JUnit ti consente di gestire processi non correlati al test utilizzando le annotazioni di coppia prima e dopo. Queste quattro annotazioni appartengono a un elenco di molte altre annotazioni che aggiungono valore ai test. Un'altra delle annotazioni di JUnit è @DisplayName.
I due esempi di codice che visualizzano la classe CalculatorTest completa usano l'annotazione @DisplayName. L'annotazione @DisplayName ti aiuta a creare nomi più significativi per le tue classi di test e metodi di test.