Scrittura ed esecuzione di verifiche JUnit

In questa sezione, la struttura di verifica JUnit verrà utilizzata per scrivere ed eseguire verifiche. Per iniziare ad utilizzare JUnit, è possibile consultare il manuale JUnit Cookbook.

Scrittura di verifiche

Creare un progetto "JUnitTest" Adesso è possibile scrivere la prima verifica. La verifica viene implementata in una sottoclasse TestCase. È possibile eseguire questa operazione utilizzando la procedura guidata Classe standard o la procedura guidata specifica Caso di prova:

  1. Aprire la nuova procedura guidata (File > Nuovo > Caso di prova JUnit).
  2. Viene aperta una finestra in cui si richiede di aggiungere la libreria junit al percorso classi. Selezionare .
  3. Immettere "TestFailure" come nome della classe di verifica:

    Procedura guidata Creazione casi di prova - pagina 1

  4. Fare clic su Fine per creare la classe di verifica.

Aggiungere un metodo di verifica che rientra nella classe TestFailure. Per immettere rapidamente un metodo di verifica, è possibile utilizzare il modello test. Per effettuare questa operazione, inserire il cursore nella dichiarazione della classe. Immettere "test" seguito da Ctrl + Spazio per attivare l'assistente al codice e selezionare il modello "test". Modificare il nome del metodo creato in testFailure e richiamare il metodo fail().

public void testFailure() throws Exception {
    fail();
}

Si è ora pronti ad eseguire la prima verifica.

Esecuzione di verifiche

Per eseguire TestFailure, attivare il menu a discesa Esegui nella barra degli strumenti e selezionare Esegui come > Test JUnit. È possibile esaminare i risultati della verifica nella vista JUnit. Questa vista mostra l'avanzamento e lo stato di esecuzione della verifica:

Verifica non riuscita

Questa vista viene presentata nella prospettiva corrente ogni volta che si avvia l'esecuzione di una verifica. Un utile espediente per la vista JUnit è quello di ancorare la vista come una vista ad accesso rapido. La vista JUnit presenta due schede, una contiene un elenco di errori e l'altra contiene la suite di verifica completa sotto forma di struttura ad albero. È possibile spostarsi da un errore all'origine corrispondente facendo doppio clic sulla riga corrispondente nella traccia dell'errore.

Ancorare la vista JUnit come una vista ad accesso rapido, rimuovere l'istruzione fail() nel metodo testFailure() in modo da far passare la verifica e rieseguire di nuovo la verifica. È possibile eseguire di nuovo una verifica facendo clic sul pulsante Esegui di nuovo nella barra degli strumenti della vista o è possibile eseguire di nuovo il programma avviato attivando il menu a discesa Esegui. Questa volta la verifica dovrebbe riuscire. Quando la verifica riesce, la vista JUnit non viene visualizzata, ma l'indicatore di esito positivo viene visualizzato nell'icona della vista JUnit e la riga di stato mostra i risultati della verifica. Come promemoria di una nuova esecuzione delle verifiche, l'icona della vista presenta un "*" ogni volta che il contenuto dello spazio di lavoro viene modificato dopo l'esecuzione.

Verifica riuscita - La verifica è riuscita
La verifica è riuscita ma lo spazio di lavoro è stato modificato - La verifica è riuscita ma il contenuto dello spazio di lavoro è stato modificato dall'ultima esecuzione.

Oltre ad un caso di prova come descritto sopra, è possibile:

Personalizzazione della configurazione di una verifica

Quando si desidera trasferire i parametri o personalizzare le impostazioni dell'esecuzione di una verifica, si apre la finestra di dialogo della configurazione di avvio. Selezionare Esegui... nel menu a discesa Esegui della barra degli strumenti:

Configurazione di avvio JUnit

In questa finestra di dialogo è possibile specificare la verifica da eseguire, i relativi argomenti, il percorso classi di runtime e l'ambiente di runtime Java.

Debug di un errore di verifica

Nel caso di un errore in fase di verifica eseguire il debug nel modo seguente:

  1. Fare doppio clic sulla voce in errore dalla scheda Errori nella vista JUnit per aprire il file corrispondente nell'editor.
  2. Impostare un punto di interruzione all'inizio del metodo da verificare.
  3. Selezionare il caso di prova ed eseguire  Debug come>Test JUnit dal menu a discesa Debug .

Una configurazione di avvio di JUnit presenta un'opzione "attiva". Se la macchina virtuale Java supporta la "sostituzione del codice attivo", è possibile correggere il codice ed eseguire di nuovo la verifica senza riavviare la verifica completa. Per abilitare questa opzione, selezionare la casella di controllo Mantieni JUnit in esecuzione dopo l'esecuzione di una verifica al momento del debug nella configurazione di avvio di JUnit.

Creazione di una suite di verifica

La procedura guidata TestSuite di JUnit consente la creazione di una suite di verifica. È possibile selezionare l'insieme di classi che devono appartenere a una suite.

  1. Aprire la nuova procedura guidata.
  2. Selezionare Java > JUnit > Suite di verifica JUnit e fare clic su Avanti.
  3. Immettere un nome per la classe della suite di verifica (per convenzione, si utilizza "AllTests" che viene visualizzato per impostazione predefinita).

    Procedura guidata Suite di verifica

  4. Selezionare le classi da includere nella suite. Attualmente si dispone di un'unica classe di verifica, ma è possibile aggiungere altre classi alla suite successivamente.

È possibile aggiungere o rimuovere classi di verifica dalla suite di verifica in due modi:

Nota: la procedura guidata inserisce due indicatori,//$JUnit-BEGIN$ e //$JUnit-END$, nella classe della suite di verifica creata, che consentono alla procedura guidata di aggiornare le classi della suite di verifica esistenti. Non si consiglia di modificare il codice tra gli indicatori.