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.
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
pacchetto com.app;
pubblicoclasseCalcolatrice{
pubblicostaticointInserisci(int num1, int num2){
Restituzione num1 + num2;
}
pubblicostaticointsottrarre(int num1, int num2){
Restituzione num1 - num2;
}
pubblicostaticointmoltiplicare(int num1, int num2){
Restituzione num1 * num2;
}
pubblicostaticointdividere(int num1, int num2){
Restituzione num1 / num2;
}
}La classe CalculatorTest
importarestaticoorg.giugno.Giove.api.Affermazioni.*;
importareorg.giugno.Giove.api.Prima di tutto;
importareorg.giugno.Giove.api.Test;
importareorg.giugno.Giove.api.Nome da visualizzare;@DisplayName("Test di classe che mostra come uso il primaedopo annotazioni.")
classeCalcolatriceTest{
@Prima di tutto
pubblicostaticovuotopowerOnCalculator(){
System.out.println("La calcolatrice è accesa");
}@Test
@Nome da visualizzare("Metodo di test che aggiunge due valori interi.")
pubblicovuototestAdd(){
assertEquals(7, Calcolatrice.Inserisci(3, 4));
}@Test
@Nome da visualizzare("Metodo di test che sottrae un valore intero da un altro.")
pubblicovuototestSottrai(){
assertEquals(6, Calcolatrice.sottrarre(9, 3));
}@Test
@Nome da visualizzare("Metodo di test che moltiplica due valori interi")
pubblicovuotoprova Moltiplica(){
assertEquals(10, Calcolatrice.moltiplicare(5, 2));
}
@Test
@Nome da visualizzare("Metodo di test che divide un valore intero per un altro")
pubblicovuotoprovaDividi(){
assertEquals(2, Calcolatrice.dividere(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 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.
importarestaticoorg.giugno.Giove.api.Affermazioni.*;
importareorg.giugno.Giove.api.Prima di tutto;
importareorg.giugno.Giove.api.Prima di ciascuno;
importareorg.giugno.Giove.api.Test;
@DisplayName("Test di classe che mostra come uso il primaedopo annotazioni.")
classeCalcolatriceTest{
@Prima di tutto
pubblicostaticovuotopowerOnCalculator(){
System.out.println("La calcolatrice è accesa");
}
@BeforeEach
pubblicovuotoclearCalculator(){
System.out.println("La calcolatrice è pronta");
}
@Test
@Nome da visualizzare("Metodo di test che aggiunge due valori interi.")
pubblicovuototestAdd(){
assertEquals(7, Calcolatrice.Inserisci(3, 4));
}
@Test
@Nome da visualizzare("Metodo di test che sottrae un valore intero da un altro.")
pubblicovuototestSottrai(){
assertEquals(6, Calcolatrice.sottrarre(9, 3));
}
@Test
@Nome da visualizzare("Metodo di test che moltiplica due valori interi")
pubblicovuotoprova Moltiplica(){
assertEquals(10, Calcolatrice.moltiplicare(5, 2));
}
@Test
@Nome da visualizzare("Metodo di test che divide un valore intero per un altro")
pubblicovuotoprovaDividi(){
assertEquals(2, Calcolatrice.dividere(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.
@Dopotutto
pubblicostaticovuotopowerOff Calcolatrice(){
System.out.println("La calcolatrice è spenta");
}L'aggiunta del metodo annotato @AfterAll alla classe CalculatorTest esistente stampa il seguente output sulla console:
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.
@Dopo ogni
pubblicovuotoritornoRisultati(){
System.out.println("I risultati sono pronti");
}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.
