Menu

Elenco delle annotazioni JUnit: JUnit 4 Vs JUnit 5

list junit annotations

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial spiega tutto sulle annotazioni JUnit insieme a un confronto delle annotazioni in JUnit 4 e JUnit 5:

Abbiamo imparato i diversi modi per eseguire i casi di test JUnit e abbiamo visto come creare ed eseguire una suite di test nel nostro tutorial precedente.

In questo tutorial, conosceremo l'aspetto principale di JUnit che viene chiamato Annotazioni. A partire da JUnit 4, le annotazioni sono presenti e rendono JUnit molto semplice, più vantaggioso e molto più intuitivo da usare.

Annotazioni è un'API Java che consente a JVM di riconoscere il tipo di metodo definito nella classe di test. Sono presenti 'annotazioni di richiamo dei cicli di vita' che vengono utilizzate di frequente.

=> Visita qui per imparare JUnit da zero.

Annotazioni JUnit

Cosa imparerai:

Annotazioni JUnit - JUnit 4 vs JUnit 5

L'esecuzione di un test attraversa diverse fasi del ciclo di vita come indicato di seguito:

  • Prima di iniziare un test, ci sono alcune attività da svolgere all'inizio di una classe.
  • Alcune altre attività da eseguire prima che un testcase inizi l'esecuzione.
  • Alcune attività che devono essere eseguite dopo l'esecuzione del test e
  • Alcune attività al termine dell'esecuzione di tutti i test in una classe.

Al fine di accertare che queste attività vengano eseguite durante ogni fase del ciclo di vita di Java, è necessario che siano presenti alcuni metodi o funzioni definiti dall'utente definiti come ' metodi di call-back del ciclo di vita .

Il comportamento di questi metodi di call-back del ciclo di vita è determinato dal built-in ' annotazioni di richiamata del ciclo di vita ' utilizzato in JUnit.

Esempio: Proviamo a renderlo ancora più semplice collegando questi metodi e annotazioni di callback del ciclo di vita a un esempio di testare un distributore automatico di caffè.

  1. Un metodo machineReady () che verifica la disponibilità di acqua, latte e caffè in grani prima dell'accensione della macchina potrebbe essere necessario.
  2. Un altro metodo startMachine () che accende la macchina, inserisce un nuovo bicchiere di carta nella macchina potrebbe essere necessario.
  3. Un caso di prova che verifica il ' Acqua calda ()' opzione.
  4. Un altro caso di prova che controlla il ' Cappuccino ()' opzione.
  5. Un altro caso di prova che controlla il ' ExpressoCoffee ()' opzione.
  6. Un altro metodo ' throwCup () ”Che getta le tazze usate nel cestino.
  7. Un metodo a livello di classe ' throwTrashandSwitchOff () ”Getta il liquido di scarto traboccante dal vassoio nella bacinella e spegne la macchina.

Quindi, nell'esempio sopra, ecco come segue il ciclo di vita del test:

  • startMachine () verrà eseguito prima di ogni caso di test - Acqua calda (), Cappuccino () e ExpressoCoffee () viene eseguito.
  • Ciascuno di questo testcase segue anche il metodo throwCup ().
  • I metodi machineReady () e throwTrashandSwitchOff () sono metodi a livello di classe che vengono eseguiti solo una volta per una classe. Il metodo machineReady () viene eseguito una volta mentre la classe avvia l'esecuzione. Il metodo throwTrashandSwitchOff () viene eseguito una volta dopo che tutti i casi di test completano l'esecuzione.

Ora, sorge la domanda che questi sono solo metodi Java, quindi:

test funzionali e test non funzionali
  1. Come insisteremo affinché JVM venga eseguito machineReady () solo una volta a livello di classe e throwTrashandSwitchOff () alla fine dell'esecuzione della classe?
  2. Come lo faremo sapere a JVM startMachine () e throwCup () deve essere eseguito prima di eseguire ogni testcase e dopo il completamento di ogni esecuzione di testcase, rispettivamente?
  3. Come possiamo fare in modo che JVM identifichi che i metodi Acqua calda (), Cappuccino () e ExpressoCoffee () devono essere eseguiti casi di test?

Risposta: L'unica risposta alle domande precedenti è che le annotazioni di callback del ciclo di vita fanno tutta la magia richiesta.

(Per ora, supponiamo di creare questa classe in JUnit 4)

Le annotazioni del ciclo di vita - @BeforeClass, @AfterClass, @Before, @After, e @Test sono le vere risposte alle tre domande precedenti. Siamo abbastanza sicuri che dopo aver letto i puntatori seguenti, sarai chiaro con le annotazioni di richiamo del ciclo di vita e il suo flusso di lavoro.

  • Annota il metodo machineReady () con @Prima della lezione e JVM lo farà funzionare una volta durante l'inizio della classe.
  • Annota il metodo buttare la spazzatura () con @Dopo la lezione e JVM lo farà funzionare una volta alla fine della lezione.
  • Annota il metodo startMachine () con @Prima e JVM lo eseguirà prima di ogni testcase.
  • Annota il metodo throwCup () con @Dopo e JVM lo eseguirà dopo l'esecuzione di ogni caso di test.
  • Annota ciascuno di questi metodi Acqua calda (), Cappuccino () e ExpressoCoffee () con @Test e JVM sa che questi sono i casi di test principali per l'esecuzione della classe JUnit.

Diamo rapidamente un'occhiata al file Annotazioni di richiamo del ciclo di vita di JUnit per JUnit 4 rispetto a JUnit 5

GIUGNO 4 ANNOTAZIONEGIUGNO 5 ANNOTAZIONE
@RepeatedTest1.JUnit 5 supporta l'esecuzione ripetuta del metodo di test per un certo numero di volte utilizzando l'annotazione @RepeatedTest
@Prima@BeforeEach
@Dopo@Dopo ogni
@Prima della lezione@BeforeAll
@Dopo la lezione@Dopotutto
@Test@Test

Flusso di lavoro sequenziale delle annotazioni del ciclo di vita

Di seguito è riportato il flusso di lavoro sequenziale delle annotazioni del ciclo di vita per JUnit 4:

flusso di lavoro sequenziale delle annotazioni del ciclo di vita per JUnit 4

  1. Il metodo annotato con @BeforeClass viene eseguito una volta all'inizio della classe.
  2. Il metodo annotato con @Before viene eseguito prima dell'inizio di Testcase 1.
  3. Il metodo Testcase1 annotato con @Test è il testcase della classe.
  4. Il metodo annotato con @After viene eseguito dopo che Testcase 1 ha completato l'esecuzione.
  5. Il metodo annotato con @Before viene eseguito prima dell'inizio di Testcase 2.
  6. Il metodo Testcase2 annotato con @Test è il testcase della classe.
  7. Il metodo annotato con @After viene eseguito dopo che Testcase 2 ha completato l'esecuzione.
  8. Il metodo annotato con @AfterClass viene eseguito una volta alla fine della classe dopo che entrambi i casi di test 1 e 2 sono stati eseguiti.

Il flusso di lavoro sequenziale delle annotazioni del ciclo di vita per JUnit 5 è il seguente:

flusso di lavoro sequenziale delle annotazioni del ciclo di vita per JUnit 5

  1. Il metodo annotato con @BeforeAll viene eseguito una volta all'inizio della classe.
  2. Il metodo annotato con @BeforeEach viene eseguito prima dell'inizio di Testcase 1.
  3. Il metodo Testcase1 annotato con @Test è il testcase della classe.
  4. Il metodo annotato con @AfterEach viene eseguito dopo che Testcase 1 ha completato l'esecuzione.
  5. Il metodo annotato con @BeforeEach viene eseguito prima dell'inizio di Testcase 2.
  6. Il metodo Testcase2 annotato con @Test è il testcase della classe.
  7. Il metodo annotato con @AfterEach viene eseguito dopo che Testcase 2 completa l'esecuzione.
  8. Il metodo annotato con @AfterAll viene eseguito una volta alla fine della classe dopo che entrambi i casi di test 1 e 2 sono stati eseguiti.

Elaborazione su ogni annotazione

In questa sezione, approfondiamo e comprendiamo in dettaglio ciò che fa ciascuno dei cicli di vita che richiama l'annotazione:

@Before (JUnit 4) / @ BeforeEach (JUnit 5):

  • Il metodo annotato viene eseguito prima dell'esecuzione di ogni metodo di test nella classe di test.
  • Questa annotazione può essere utilizzata quando si desidera impostare le risorse o i dati del test subito prima dell'inizio di ogni test.
  • Per esempio, se ci sono 5 Testcase in una classe di test JUnit, il metodo annotato con @ Before / @ BeforeEach viene eseguito 5 volte prima di ciascuna esecuzione del test case.

@After (JUnit 4) / @ AfterEach (JUnit 5):

  • Il metodo annotato viene eseguito dopo l'esecuzione di ogni metodo di test nella classe di test.
  • Questa annotazione può essere utilizzata quando si desidera rilasciare le risorse utilizzate o i dati di test dopo l'esecuzione di ogni caso di test.
  • Per esempio, se ci sono 5 casi di test in una classe di test JUnit, il metodo annotato con @ After / @ AfterEach viene eseguito 5 volte dopo l'esecuzione dei casi di test.

@BeforeClass (JUnit 4) / @ BeforeAll (JUnit 5):

  • Il metodo annotato viene eseguito prima che tutti i metodi di test in una classe di test vengano eseguiti.
  • Questa annotazione può essere utilizzata quando si desidera impostare risorse o testare i dati a livello di classe.
  • Poiché questo metodo è annotato con @ BeforeClass / @ BeforeAll viene eseguito solo una volta per una classe di test e la copia del metodo viene condivisa tra la classe e il metodo deve essere dichiarato statico.
  • Per esempio, se ci sono 5 Testcase in una classe di test JUnit, il metodo annotato con @ BeforeClass / @ BeforeAll viene eseguito una volta per classe di test prima dell'avvio di qualsiasi testcase.

@AfterClass (JUnit 4) / @ AfterAll (JUnit 5):

  • Il metodo annotato viene eseguito dopo l'esecuzione di tutti i metodi di test in una classe di test.
  • Questa annotazione può essere utilizzata quando si desidera rilasciare le risorse utilizzate o testare i dati a livello di classe.
  • Poiché questo metodo è annotato con @ AfterClass / @ AfterAll viene eseguito solo una volta per una classe di test e la copia del metodo viene condivisa in tutta la classe, il metodo deve essere dichiarato statico.
  • Per esempio, se ci sono 5 Testcase in una classe di test JUnit, il metodo annotato con @ AfterClass / @ AfterAll viene eseguito una volta per classe di test dopo che tutti i casi di test completano l'esecuzione.

@Test (JUnit 4 e JUnit 5):

  • L'annotazione @Test è comune per JUnit 4 e JUnit 5. I metodi annotati rappresentano i casi di test nella classe.
  • Potrebbero esserci più metodi, ciascuno annotato con @Test in una classe JUnit. Ciò implica che una classe può avere più casi di test.
  • Ci sono diversi attributi o parametri da testare che potrebbero essere passati. È possibile aggiungere un timeout forzato per uno scenario di test o aggiungere un'eccezione. Questo verrà trattato in dettaglio in un tutorial separato.
  • Il metodo annotato non può essere privato o statico e non può restituire alcun valore.
  • Il metodo @Test deve essere dichiarato come pubblico in JUnit 4 mentre Junit 5 consente un testcase definito senza il modificatore di accesso 'pubblico' in quanto considera 'nessun modificatore di accesso' come 'pubblico' per impostazione predefinita.

Esempio di test JUNIT di base

Un fondamento GIU 4 esempio per le annotazioni @BeforeClass, @Before, @Test, @After e @AfterClass è stato mostrato attraverso il codice con la sua spiegazione nel nostro precedente tutorial su 'Test Fixtures'.

Diamo un'occhiata alla base JUnit 5 Programma per dimostrare il funzionamento delle annotazioni di richiamata del ciclo di vita @BeforeAll, @BeforeEach, @Test, @AfterEach e @AfterAll.

Codice per 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'); } }

All'esecuzione del file di classe, il risultato seguente viene visualizzato nella finestra della console.

Finestra della console

Annotazioni aggiuntive - JUnit 4 vs JUnit 5

Ci sono molte annotazioni aggiuntive che vengono utilizzate per scopi specifici. Vedremo l'elenco delle annotazioni per JUnit 4 vs JUnit 5 e lo scopo che serve in breve.

Ci sarà un tutorial dettagliato su ciascuna di queste annotazioni nei nostri prossimi tutorial.

GIUGNO 4 ANNOTAZIONEGIUGNO 5 ANNOTAZIONEDescrizione in breve
@FixMethodOrder@TestMethodOrder e @Order1. Queste annotazioni consentono all'utente di scegliere l'ordine di esecuzione dei metodi all'interno di una classe di test
@Rule e @ClassRule@ExtendWith1. @Rule - L'annotazione è estesa dalla classe TestRule che aiuta ad applicare determinate regole ai casi di test.
2. Ad esempio: la creazione di una cartella temporanea prima dell'esecuzione dello scenario di test e l'eliminazione della cartella dopo l'esecuzione possono essere impostate tramite una regola.
3. @Rule è disponibile solo in JUnit 4 che può essere utilizzato in JUnit 5 Vintage, tuttavia, @ExtendWith fornisce una funzionalità più vicina per JUnit 5
4. Allo stesso modo, è possibile impostare un timeout globale utilizzando @Rule.
N / A@TestFactory1. Questa annotazione è supportata solo da JUnit 5 e aiuta la creazione di test dinamici o di runtime.
2. Restituisce un flusso di dati come raccolta e non può utilizzare le annotazioni di callback del ciclo di vita
N / A@Nidificato1.Questa annotazione è supportata solo da JUnit Jupiter
2. Ci aiuta a creare casi di test annidati.
3. Ad esempio, la Classe 1 con il caso di prova 1 potrebbe avere una Classe 2 @Nidificata con il caso di prova 2. Ciò rende il caso di prova 2 un caso di prova nidificato per il caso di prova 1. Quindi, il caso di prova 1 viene eseguito, quindi il caso di prova 2 viene eseguito.
4.Se l'annotazione @Nested non viene utilizzata, la classe nidificata non verrà eseguita.
@Categoria@Etichetta1.Questa annotazione aiuta per contrassegnare e filtrare i test
2.Puoi includere test per l'esecuzione o escluderli filtrando in base alle categorie in cui rientrano.
@RunWith (Parameterized.class)
@ Parameterized.Parameters		@ParameterizedTest e @ValueSource1. Questa annotazione viene utilizzata per eseguire più volte un metodo con variazioni dei dati di prova.
2.JUnit 4 supporta @RunWith e @Parameters mentre JUnit 5 Jupiter supporta @ParameterizedTest con @ValueSource
@Nome da visualizzare1. È possibile assegnare un nome definito dall'utente a un metodo o una classe di test a scopo di visualizzazione.
@TestInstance (LifeCycle.PER_CLASS) e @TestInstance (LifeCycle.PER_METHOD)1. JUnit 5 supporta la configurazione del ciclo di vita dei test.
2. Sia JUnit 4 che 5 seguono la richiamata predefinita per ciclo di vita del metodo, mentre è possibile eseguire anche la configurazione per classe.

Riferimenti => JUnit 4 , JUnit 5

Conclusione

  1. Abbiamo appreso delle annotazioni di callback del ciclo di vita e del flusso di lavoro sequenziale in cui vengono eseguiti i metodi di test in base alle loro annotazioni.
  2. Abbiamo imparato le annotazioni usate per JUnit 4 e le annotazioni per JUnit 5.
  3. Abbiamo anche appreso delle annotazioni aggiuntive supportate da JUnit 4 e quelle che supportano solo JUnit 5.

=> Guarda qui la semplice serie di formazione JUnit.

Lettura consigliata

^