JUnit Tutorial sulle annotazioni con esempio: cosa sono @Test e @After

Cosa è JUnit Annotazioni?

JUnit annotazioni sono una forma speciale di metadati sintattici che possono essere aggiunti a Java codice sorgente per una migliore leggibilità e struttura del codice. Variabili, parametri, pacchetti, metodi e classi possono essere annotati. Le annotazioni sono state introdotte in JUnit 4, che fa Java codice più leggibile e semplice. Questa è la grande differenza tra JUnit 3 e JUnit 4: JUnit 4 è basato sulle annotazioni.

Con una conoscenza pratica di queste annotazioni, si può facilmente imparare e implementare un JUnit test. Di seguito è riportato l'importante e utilizzato di frequente JUnit elenco delle annotazioni, con il JUnit 5 (Giove) equivalente accanto a ciascuno:

JUnit Esempio di annotazioni

Creiamo una classe che copra importanti JUnit annotazioni con semplici istruzioni print ed eseguilo con una classe test runner:

Passo 1) Considera quanto segue Java classe dotata di vari metodi associati alle annotazioni sopra elencate:

Esempio di annotazioni Junit.java

package guru99.junit;		

import static org.junit.Assert.assertEquals;				
import static org.junit.Assert.assertFalse;				

import java.util.ArrayList;		

import org.junit.After;		
import org.junit.AfterClass;		
import org.junit.Before;		
import org.junit.BeforeClass;		
import org.junit.Ignore;		
import org.junit.Test;		

public class JunitAnnotationsExample {				

    private ArrayList<String> list;					

    @BeforeClass		
    public static void m1() {							
        System.out.println("Using @BeforeClass , executed before all test cases ");					
    }		

    @Before		
    public void m2() {					
        list = new ArrayList<String>();					
        System.out.println("Using @Before annotations ,executed before each test cases ");					
    }		

    @AfterClass		
    public static void m3() {							
        System.out.println("Using @AfterClass ,executed after all test cases");					
    }		

    @After		
    public void m4() {					
        list.clear();			
        System.out.println("Using @After ,executed after each test cases");					
    }		

    @Test		
    public void m5() {					
        list.add("test");					
        assertFalse(list.isEmpty());			
        assertEquals(1, list.size());			
    }		

    @Ignore		
    public void m6() {					
        System.out.println("Using @Ignore , this execution is ignored");					
    }		

    @Test(timeout = 10)			
    public void m7() {					
        System.out.println("Using @Test(timeout),it can be used to enforce timeout in JUnit4 test case");					
    }		

    @Test(expected = NoSuchMethodException.class)					
    public void m8() {					
        System.out.println("Using @Test(expected) ,it will check for specified exception during its execution");					

    }		

}		

Passo 2) Creiamo una classe di esecuzione test per eseguire il test sopra descritto:

TestRunner.java

package guru99.junit;		

import org.junit.runner.JUnitCore;		
import org.junit.runner.Result;		
import org.junit.runner.notification.Failure;		

public class TestRunner {				
			public static void main(String[] args) {									
      Result result = JUnitCore.runClasses(JunitAnnotationsExample.class);					
			for (Failure failure : result.getFailures()) {							
         System.out.println(failure.toString());					
      }		
      System.out.println("Result=="+result.wasSuccessful());							
   }		
}      	

Risultato atteso

• Tutti i casi di test verranno eseguiti uno alla volta e tutte le istruzioni di stampa saranno visibili sulla console.
• Come discusso nella tabella precedente, @Before e @BeforeClass in JUnit [ I metodi m2() e m1() ] verranno eseguiti rispettivamente prima di ogni caso di test e prima di tutti i casi di test.
• Allo stesso modo @After e @AfterClass in JUnit I metodi m4() e m3() verranno eseguiti rispettivamente dopo ogni caso di test e dopo tutti i casi di test. Il metodo m6() (@Ignore) verrà interpretato come l'ignorare il test.

Analizziamo i casi di test utilizzati nel precedente Java lezione nel dettaglio:

1. Si consideri il metodo m5() come indicato di seguito:

	@Test		
    public void m5() {					
        list.add("test");					
        assertFalse(list.isEmpty());			
        assertEquals(1, list.size());			
    }		

Nel metodo sopra descritto, poiché stai aggiungendo una stringa alla variabile "list":

• lista.èVuoto() restituirà falso.
• assertFalse(list.isEmpty()) deve restituire vero.
• Di conseguenza, il caso di prova lo farà passare.

Poiché hai aggiunto una sola stringa all'elenco, la dimensione è uno.

• lista.dimensione() deve restituire il valore intero "1".
• So assertEquals(1, list.size()) deve restituire vero.
• Di conseguenza, il caso di prova lo farà passare.

2. Si consideri il metodo m7() come indicato di seguito:

@Test(timeout = 10)		
    public void m7() {					
        System.out.println("Using @Test(timeout),it can be used to enforce timeout in JUnit4 test case");					
    }		

Come discusso sopra, @Test(timeout = 10) viene utilizzato per imporre un timeout nel caso di test. Il valore è espresso in millisecondi, quindi m7() deve terminare entro 10 ms.

3. Si consideri il metodo m8() come indicato di seguito:

@Test(expected = NoSuchMethodException.class)				
    public void m8() {					
        System.out.println("Using @Test(expected) ,it will check for specified exception during its execution");					
    
    }		

Come discusso sopra, @Test(previsto) Verrà verificata la presenza dell'eccezione specificata durante l'esecuzione, quindi il metodo m8() genererà "No Such Method Exception". Di conseguenza, il test verrà eseguito con un'eccezione.

Nota di accuratezza: m8() stampa solo una riga, quindi l'eccezione dichiarata non viene mai effettivamente lanciata e JUnit 4 segnala che il test è fallito. Allineare il tipo previsto con quello effettivamente generato dal metodo. JUnit 5 scrive questo con assertThrows.

Poiché tutti i casi di test vengono superati, ciò si traduce in un'esecuzione corretta del test.

Risultato attuale

Poiché nell'esempio precedente sono presenti tre casi di test, tutti i casi di test verranno eseguiti uno alla volta. Vedi lo screenshot della console qui sotto:

Vedi sotto le istruzioni print che possono essere visualizzate sulla console:

Utilizzando @BeforeClass , eseguito prima di tutti i casi di test

Utilizzando le annotazioni @Before, eseguite prima di ogni caso di test

Utilizzando @After, eseguito dopo ogni caso di test

Utilizzando le annotazioni @Before, eseguite prima di ogni caso di test

Utilizzando @Test(timeout), può essere utilizzato per imporre il timeout JUnit4 casi di prova

Utilizzando @After, eseguito dopo ogni caso di test

Utilizzando le annotazioni @Before, eseguite prima di ogni caso di test

Utilizzando @Test(expected), controllerà l'eccezione specificata durante la sua esecuzione

Utilizzando @After, eseguito dopo ogni caso di test

Utilizzando @AfterClass, eseguito dopo tutti i casi di test

JUnit Asserisci classe

Le annotazioni determinano quando un metodo viene eseguito; i metodi assert decidono se ha esito positivo.

Questa classe fornisce una serie di metodi di asserzione utili per scrivere un caso di test. Se tutte le istruzioni di asserzione vengono superate, i risultati del test sono positivi. Se una qualsiasi istruzione di asserzione fallisce, i risultati del test sono negativi. Il dedicato JUnit affermare Il tutorial illustra ciascun metodo in dettaglio.

Come avete visto in precedenza, la tabella seguente descrive i principali metodi Assert e la loro descrizione:

JUnit Classe Casi di test

Per eseguire più test, la classe TestCase è disponibile in junit.framework pacchetto. L'annotazione @Test dice JUnit che questo metodo pubblico void (un caso di test in questo caso) a cui è collegato possa essere eseguito come caso di test.

Nota sulla versione: Caso di prova, Risultato del test and Suite di prova appartenere all'eredità junit.framework pacchetto da JUnit 3. Vengono ancora distribuiti all'interno dell'artefatto JUnit 4.x, ma i test basati su annotazioni non estendono TestCase.

La tabella seguente mostra alcuni metodi importanti disponibili nel junit.framework.TestCase classe:

JUnit Classe TestResult

Quando esegui un test, restituisce un risultato (sotto forma di Risultato del test oggetto). Questo oggetto TestResult può essere utilizzato per analizzare l'oggetto risultante. Il risultato del test può essere positivo o negativo.

Consulta la tabella seguente per i metodi importanti utilizzati nella classe junit.framework.TestResult:

JUnit Classe della suite di prova

Se si desidera eseguire più test in un ordine specificato, è possibile farlo combinando tutti i test in un unico posto. Questo posto è chiamato suite di test e il JUnit suite di test Il tutorial illustra un esempio completo.

Vedi la tabella sottostante per i metodi importanti utilizzati nel junit.framework.TestSuite classe:

DOMANDE FREQUENTI