Menu

Che cos'è un dispositivo di prova JUnit: tutorial con esempi di JUnit 4

  • Principale
  • Altro
  • Che cos'è un dispositivo di prova JUnit: tutorial con esempi di JUnit 4

what is junit test fixture

Prova Il Nostro Strumento Per Eliminare I Problemi

Questo tutorial spiegherà quando, perché e come utilizzare JUnit Test Fixture con semplici esempi di JUnit Test Fixture per una facile comprensione del concetto:

Impareremo -

  1. Quando e perché abbiamo la necessità di utilizzare Test Fixture?
  2. Qual è l'approccio per utilizzarlo nel nostro codice per il test JUnit?
  3. Un paio di esempi per comprendere il termine 'Test Fixture' in parallelo con un vantaggio sulle annotazioni del ciclo di vita di JUnit 4 come @Before, @After, @BeforeClass, @AfterClass e @Test.

=> Controlla TUTTI i tutorial di JUnit qui.

Junit Test Fixture

Cosa imparerai:

Dispositivo di prova JUnit

Quando sono presenti più casi di test in una classe JUnit, potrebbero esserci uno o più oggetti comuni utilizzati da tutti i casi di test. In questo caso, potrebbero esserci funzioni specifiche che potrebbero essere comuni in tutti i casi di test.

Ciò non significa che gli oggetti di test debbano essere condivisi da tutti i casi di test. La modifica all'oggetto effettuata in un test non deve essere condivisa tra tutti i test poiché questi test sono indipendenti e possono essere eseguiti in un ordine diverso secondo la loro priorità impostata.

programma per copiare i dvd sul computer

La comprensione olistica di termine 'Test Fixture' è uno stato fisso in un codice o una serie di passaggi fissi in un codice che viene utilizzato come precondizione e pochi altri gruppi di passaggi utilizzati come postcondizione per tutti i test.

Quindi, in altre parole, stiamo identificando quei set di istruzioni che si ripeteranno per tutti i test e quindi proviamo a impostare un ambiente fisso per l'esecuzione dei nostri metodi di test.

Il scopo di utilizzare Test Fixture significa eliminare la duplicazione del codice comune per tutti i casi di test.

sito web che ti permette di scaricare i video di YouTube

Proviamo a capire l'implementazione pratica del dispositivo di test in un test JUnit.

metodo setUp ()

  • Esistono test che richiedono l'inizializzazione di determinati oggetti (stringa, numero intero o ArrayList o qualsiasi altro oggetto). Puoi creare un metodo public void setUp () in cui è possibile dichiarare le variabili di istanza per gli oggetti comuni. Posiziona questo metodo setUp () sotto l'annotazione @Prima . Con l'annotazione @Before, il framework eseguirà il metodo setUp () prima dell'esecuzione di ogni test case.
  • Il metodo setUp () può essere utilizzato anche nel caso in cui si desideri avviare un browser con un URL specifico come primo passo si esegue un test case che segue l'accesso all'applicazione con credenziali predefinite.

metodo tearDown ()

  • Se hai assegnato risorse esterne in un test, dovresti ricordarti di liberare anche le risorse. Il metodo teardown () potrebbe essere aggiunto per la pulizia degli oggetti dopo che l'esecuzione del test case è stata completata. In modo simile al metodo setUp (), aggiungi un metodo public void teardown () sotto @Dopo annotazione. Il framework JUnit assicura che dopo l'esecuzione di ogni test case, il metodo in @After venga sicuramente eseguito. Gli oggetti usati nel test devono essere impostati su NULL nel metodo teardown () in modo che i rifiuti dei test vengano raccolti.
  • Un altro buon candidato per la pulizia degli oggetti è uccidere un browser in azione dopo il completamento del test case e liberare la memoria distruggendo gli oggetti usati.
  • I nomi dei metodi setUp () e tearDown () sono solo un nome definito dall'utente. Puoi impostare qualsiasi nome di metodo che desideri. Sono solo le annotazioni utilizzate con il metodo che decidono la sequenza dell'esecuzione dei test.

Esempi di dispositivi di prova JUnit

In questa sezione, esamineremo due esempi del test JUnit 4 e proveremo a capire come utilizzare l'approccio dei Test Fixtures nel nostro codice insieme alla sequenza di diverse annotazioni del ciclo di vita @Before, @After, @BeforeClass, @AfterClass, e @Test.

Naturalmente, ci sarà un tutorial separato sulle annotazioni che chiarirà cosa sono e come funziona ciascuna annotazione. A partire da ora, restiamo fedeli alla comprensione dell'utilizzo dell'apparecchiatura di prova nel codice.

JUnit 4 Test - Esempio 1

In questo esempio, avremo i dispositivi di test nella classe con tre casi di test. Il metodo setUp () con l'annotazione @Before e il metodo tearDown () con l'annotazione @After.

Codice:

package demo.tests; import static org.junit.Assert.*; import org.junit.After; import org.junit.Before; import org.junit.Test; public class JUnitProgram { @Before public void setUp() { System.out.println('_______________________________________________________ '); System.out.println('This is the setUp() method that runs before each testcase'); } @Test public void test_JUnit1() { System.out.println('This is the testcase test_JUnit1() in this class'); } @Test public void test_JUnit2() { System.out.println('This is the testcase test_JUnit2() in this class'); } @Test public void test_JUnit3() { System.out.println('This is the testcase test_JUnit3() in this class'); } @After public void tearDown() { System.out.println('This is the tearDown() method that runs after each testcase'); System.out.println('_______________________________________________________ '); } }

La finestra della console risultante sarà come mostrato di seguito:

finestra della console risultante

La finestra della console rende ovvio che prima di ogni esecuzione di test, viene eseguito il metodo setUp () e, al termine di ogni test, viene eseguito il metodo tearDown ().

Pertanto, la sequenza di esecuzione per l'annotazione per ogni metodo di test è:

  1. @Prima
  2. @Test
  3. @Dopo

Ricorda che i test, anche se qui, sono stati eseguiti in ordine sequenziale, ad esempio test_JUnit1 (), test_JUnit2 (), test_JUnit3 (), non esiste una sequenza definita per il test, quindi possono essere eseguiti in qualsiasi ordine. Ogni test è isolato dall'altro test.

JUnit 4 Test - Esempio 2

Qui, vediamo rapidamente come possiamo avere un metodo che viene eseguito una volta per la prima volta in una classe e un altro metodo che viene eseguito una volta dopo che tutti i test sono stati eseguiti per la classe.

Codice:

package demo.tests; import static org.junit.Assert.*; import org.junit.After; import org.junit.Before; import org.junit.Test; public class JUnitProgram { @BeforeClass public static void preClass() { System.out.println('This is the preClass() method that runs one time before the class'); } @Before public void setUp() { System.out.println('_______________________________________________________ '); System.out.println('This is the setUp() method that runs before each testcase'); } @Test public void test_JUnit1() { System.out.println('This is the testcase test_JUnit1() in this class'); } @Test public void test_JUnit2() { System.out.println('This is the testcase test_JUnit2() in this class'); } @Test public void test_JUnit3() { System.out.println('This is the testcase test_JUnit3() in this class'); } @After public void tearDown() { System.out.println('This is the tearDown() method that runs after each testcase'); System.out.println('_______________________________________________________ '); } @AfterClass public static void postClass() { System.out.println('This is the postClass() method that runs one time after the class'); } }

Abbiamo aggiunto il metodo preClass () sotto l'annotazione @BeforeClass. Questo metodo viene eseguito solo una volta per una classe prima dell'esecuzione del test. Viene eseguito anche prima dell'esecuzione del metodo in @Before.

Il metodo postClass () sotto l'annotazione @AfterClass viene eseguito una volta alla fine quando tutti i test, incluso il test sotto @After, vengono eseguiti e completati.

La sequenza della prova di funzionamento è la seguente:

  1. @Prima della lezione
  2. @Prima
  3. @Test
  4. @Dopo
  5. @Dopo la lezione

I metodi in @BeforeClass e @AfterClass sono comunemente condivisi dalla classe, motivo per cui se i metodi non vengono dichiarati come statico poi dà un errore di inizializzazione all'esecuzione del test.

la migliore app per scaricare musica mp3 per Android

Vedi lo screenshot qui sotto, dove non abbiamo impostato il metodo preClass () sotto l'annotazione @BeforeClass come statico e quindi il test ha errato durante l'esecuzione.

È possibile che il risultato mostri un errore di inizializzazione che potrebbe essere eliminato contrassegnando il metodo come statico. Lo stesso vale per il metodo postClass () sotto l'annotazione @AfterClass.

Errore di inizializzazione

Conclusione

Abbiamo cercato di definire un contesto sulle buone pratiche di programmazione da seguire implementando il Dispositivo di prova approccio e una comprensione di base dell'utilizzo e della sequenza di esecuzione per le annotazioni del ciclo di vita.

Nel nostro prossimo tutorial, impareremo a conoscere il diversi modi di eseguire i test JUnit in Eclipse. Quindi resta sintonizzato sulla serie mentre progrediamo con aspetti più interessanti di JUnit.

=> Controlla qui per vedere i tutorial di formazione dalla A alla Z di JUnit qui.

Lettura consigliata

^