JUnit è il framework di unit test più popolare in Java. È esplicitamente consigliato per gli unit test. JUnit non richiede un server per testare l'applicazione web, il che rende veloce il processo di test.
Il framework JUnit consente anche la generazione rapida e semplice di casi di test e dati di test. Il pacchetto org.Junit è costituito da molte interfacce e classi per i test JUnit come Test, Assert, After, Before, ecc.
Cos'è il dispositivo di prova
Prima di capire cos'è un dispositivo di prova, studiamo il codice di seguito
Questo codice è progettato per eseguire due casi di test su un file semplice.
public class OutputFileTest {output di file privati;output = nuovo file (…);output.delete ();public void testFile1 () {// Codice per verificare il caso di test 1}output.delete ();output = nuovo file (…);public void testFile2 () {// Codice per verificare il caso di test 2}output.delete ();}
Pochi problemi qui
- Il codice non è leggibile
- Il codice non è facile da mantenere.
- Quando la suite di test è complessa, il codice potrebbe contenere problemi logici.
Confronta lo stesso codice usando JUnit
classe pubblica OutputFileTest{output di file privati;@Before public void createOutputFile (){output = nuovo file (…);}@Dopo public void deleteOutputFile (){output.delete ();}@Test public void testFile1 (){// codice per l'obiettivo del test case}@Test public void testFile2 (){// codice per l'obiettivo del test case}}
Il codice è molto più leggibile e gestibile. La struttura del codice sopra è un dispositivo di prova.
Un dispositivo di test è un contesto in cui viene eseguito un caso di test. In genere, i dispositivi di prova includono:
- Oggetti o risorse disponibili per qualsiasi test case.
- Attività richieste che rendano disponibili questi oggetti / risorse.
- Queste attività sono
- allocazione ( configurazione )
- disallocazione ( smontaggio ).
Configurazione e smontaggio
- Di solito, ci sono alcune attività ripetute che devono essere eseguite prima di ogni caso di test. Esempio: creare una connessione al database.
- Allo stesso modo, alla fine di ogni caso di test, potrebbero esserci alcune attività ripetute. Esempio: per ripulire una volta terminata l'esecuzione del test.
- JUnit fornisce annotazioni che aiutano nella configurazione e nello smontaggio. Assicura che le risorse vengano rilasciate e che il sistema di test sia pronto per il prossimo test case.
Queste annotazioni sono discusse di seguito-
Impostare
L' annotazione @Before viene utilizzata su un metodo contenente codice Java da eseguire prima di ogni test case. cioè viene eseguito prima di ogni esecuzione del test.
Smontaggio (indipendentemente dal verdetto)
L' annotazione @After viene utilizzata su un metodo contenente codice java da eseguire dopo ogni caso di test. Questi metodi verranno eseguiti anche se vengono generate eccezioni nel test case o in caso di errori di asserzione.
Nota:
- È consentito avere un numero qualsiasi di annotazioni sopra elencate.
- Tutti i metodi annotati con @Before verranno eseguiti prima di ogni test case, ma possono essere eseguiti in qualsiasi ordine.
- È possibile ereditare i metodi @Before e @After da una super classe, l'esecuzione è la seguente: È un processo di esecuzione standard in JUnit.
- Esegui i metodi @Before nella superclasse
- Esegui i metodi @Before in questa classe
- Esegui un metodo @Test in questa classe
- Esegui i metodi @After in questa classe
- Esegui i metodi @After nella superclasse
Esempio: creazione di una classe con file come dispositivo di prova
classe pubblica OutputFileTest{output di file privati;@Before public void createOutputFile (){output = nuovo file (…);}@Dopo public void deleteOutputFile (){output.delete ();}@Test public void testFile1 (){// codice per l'obiettivo del test case}@Test public void testFile2 (){// codice per l'obiettivo del test case}}
Nell'esempio sopra la catena di esecuzione sarà la seguente:
- createOutputFile ()
- testFile1 ()
- deleteOutputFile ()
- createOutputFile ()
- testFile2 ()
- deleteOutputFile ()
Presupposto: testFile1 () viene eseguito prima di testFile2 (), il che non è garantito.
Configurazione unica
- È possibile eseguire un metodo solo una volta per l'intera classe di test prima che venga eseguito uno qualsiasi dei test e prima di qualsiasi metodo @Before .
- Le "impostazioni una volta sola" sono utili per avviare i server, aprire le comunicazioni, ecc. Chiudere e riaprire le risorse per ogni test richiede molto tempo.
- Questo può essere fatto usando l' annotazione @BeforeClass
@BeforeClass public static void Method_Name () {// codice di configurazione della classe qui}
Smontare una volta sola
- Simile alla configurazione una sola volta, è disponibile anche un metodo di pulizia una sola volta. Viene eseguito dopo che tutti i metodi del test case e le annotazioni @After sono stati eseguiti.
- È utile per arrestare i server, chiudere i collegamenti di comunicazione, ecc.
- Questo può essere fatto utilizzando l' annotazione @AfterClass
@AfterClass public static void Method_Name (){// codice di pulizia della classe qui}
JUnit Test Suites
Se vogliamo eseguire più test in un ordine specificato, può essere fatto combinando tutti i test in un unico posto. Questo posto è chiamato come le suite di test. Ulteriori dettagli su come eseguire le suite di test e su come vengono utilizzate in JUnit saranno trattati in questo tutorial.
Junit Test Runner
JUnit fornisce uno strumento per l'esecuzione dei tuoi casi di test.
- La classe JUnitCore viene utilizzata per eseguire questi test.
- Un metodo chiamato runClasses fornito da org.junit.runner.JUnitCore, viene utilizzato per eseguire una o più classi di test.
- Il tipo restituito di questo metodo è l' oggetto Result ( org.junit.runner.Result ), utilizzato per accedere alle informazioni sui test. Vedere il seguente esempio di codice per maggiore chiarezza.
public class Test {public static void main (String [] args) {Risultato risultato = JUnitCore.runClasses (CreateAndSetName.class);for (Failure failure: result.getFailures ()) {System.out.println (failure.toString ());}System.out.println (result.wasSuccessful ());}}
Nel codice precedente l'oggetto "risultato" viene elaborato per ottenere errori e risultati positivi dei casi di test che stiamo eseguendo.
Primo programma JUnit
Una buona conoscenza di SDLC, programmazione java e basi del processo di test del software aiuta a comprendere il programma JUnit.
Comprendiamo gli Unit Testing usando un esempio dal vivo. Dobbiamo creare una classe di test con un metodo di test annotato con @Test come indicato di seguito:
MyFirstClassTest.java
pacchetto guru99.JUnit;import statico org.JUnit.Assert. *;import org.JUnit.Test;classe pubblica MyFirstClassTest {@Testpublic void myFirstMethod () {String str = "JUnit funziona bene";assertEquals ("JUnit funziona bene", str);}}
TestRunner.java
Per eseguire il nostro metodo di test (sopra), dobbiamo creare un test runner. Nel test runner dobbiamo aggiungere la classe di test come parametro nel metodo runclasses () di JUnitCore. Restituirà il risultato del test, a seconda che il test sia stato superato o meno.
Per maggiori dettagli su questo vedere il codice qui sotto:
pacchetto 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) {Risultato risultato = JUnitCore.runClasses (MyFirstClassTest.class);for (Failure failure: result.getFailures ()) {System.out.println (failure.toString ());}System.out.println ("Result ==" + result.wasSuccessful ());}}
Produzione
Una volta che TestRunner.java esegue i nostri metodi di test, otteniamo l'output come non riuscito o superato. Di seguito è riportata la spiegazione dell'output:
- In questo esempio, dopo aver eseguito MyFirstClassTest.java , il test viene superato e il risultato è in verde.
- Se avesse fallito, avrebbe dovuto mostrare il risultato come rosso e il guasto può essere osservato nella traccia del guasto. Vedi sotto JUnit gui:
Riepilogo :
- JUnit è un framework che supporta diverse annotazioni per identificare un metodo che contiene un test.
- JUnit fornisce un'annotazione chiamata @Test, che dice a JUnit che il metodo public void in cui viene utilizzato può essere eseguito come test case.
- Un dispositivo di test è un contesto in cui viene eseguito un caso di test
- Per eseguire più test in un ordine specificato, è possibile combinare tutti i test in un unico punto. Questo posto è chiamato come le suite di test.
- JUnit fornisce uno strumento per l'esecuzione dei test in cui possiamo eseguire i nostri casi di test denominati Test Runner.