JUnit è un framework di unit test open source di terze parti. Il progetto è stato avviato da Kent Beck ed Erich Gamma alla fine del 1995. Ha rapidamente suscitato interesse nella comunità di sviluppatori che si occupano in particolare di sviluppo basato su test. JUnit è stato inizialmente introdotto in Smalltalk, ma in seguito è stato portato su Java, che lo ha rapidamente adottato come standard de facto di unit test. La popolarità di JUnit è cresciuta a tal punto che, per soddisfare le esigenze di molti altri linguaggi contemporanei come C#, Perl, Python, PHP, Ruby, Visual Basic, C++ e così via, è stato sviluppato un framework xUnit generico in cui la lettera 'x' è sostituita dalla prima lettera del linguaggio, come JUnit per Java, RUnit per Ruby e così via. Questo articolo fornisce una panoramica di questo framework utilizzato dallo standard di fatto dei test di unità Java.
Panoramica dei test
Il test è una fase importante nel ciclo di vita dello sviluppo di un'applicazione. Lo scopo principale del test è valutare un programma sulla base delle specifiche richieste. L'obiettivo è creare determinati casi di test che facciano emergere errori, lacune, eventuali discrepanze o risultati imprevisti, per quanto possibile. Questo semplice concetto ha alcuni processi elaborati ad esso associati. Ma, per dirla in breve, è fatto a tre livelli. Quando il test viene eseguito a livello di componenti molto granulari o individuali, viene chiamato Unit Testing; quando vengono combinati per verificare le interfacce tra i componenti rispetto a un progetto software, si parla di Test di integrazione; e infine, quando l'intero sistema è integrato e viene eseguito il test per verificare che il sistema nel suo insieme soddisfi i requisiti specificati, si parla di Test del sistema .
Test di unità
In poche parole, eseguire uno unit test è un modo per esaminare il comportamento di una distinta unità di codice. In Java, un'unità di codice può significare un metodo o una classe o anche un modulo, a seconda del contesto. Se si tratta di un metodo, ad esempio, l'obiettivo del test è valutare il riferimento all'oggetto corretto consentito per invocare il metodo, il tipo di parametri e valori accettabili, gli intervalli di valori primitivi, il tipo e il valore restituiti e così via. L'idea è di grigliare il metodo in modo che possa essere reso sufficientemente robusto da gestire con grazia il suo problema e gettare quelli che sono oltre il suo scopo oltre all'adempiere al suo contratto.
Pertanto, il test unitario costituisce l'elemento costitutivo di base di qualsiasi valutazione del programma. In effetti, ogni programmatore esegue una sorta di unit test mentre si scrive il codice per verificare l'esito del codice con alcuni dati/casi fittizi. Il test unitario è quindi uno status formale dato a quella raccolta isolata di test. È estremamente importante che un codice passi attraverso il rigore di varie fasi di test. Lo unit test, oltre alla sua importanza, è anche molto comune. Persone come Kent Beck ed Erich Gamma hanno pensato di creare un framework in modo che i programmatori ottengano un ambiente strutturato e possano automatizzare molte di queste attività. Dopotutto, è a questo che serve un framework. In genere, fornisce una struttura del programma coerente che è riutilizzabile e condivisibile tra le applicazioni. Un programmatore può incorporarli in un'applicazione esistente ed estenderli in base alle sue esigenze specifiche.
Un rapido esempio
Un semplice codice di unit test per esaminare il metodo singolo in Temperatura la classe senza utilizzare il framework JUnit è la seguente:
package org.mano.unittest.examples;
public class Circle {
double area(double radius) {
returnMath.PI* radius * radius;
}
}
Ora scriviamo il codice per testare l'unità area metodo.
package org.mano.unittest.examples;
public class CircleTest {
public int errCounter= 0;
public void testCircleArea() {
Circle circle = new Circle();
double area = circle.area(12);
if (area < 452 && area > 453) {
throw new IllegalStateException("Wrong calculation!: "
+ area);
}
}
public static void main(String[] args) {
TestCircle test = new TestCircle();
try {
test.testCircleArea();
} catch (Throwable e) {
test.errCounter++;
e.printStackTrace();
}
if (test.errCounter> 0) {
throw new IllegalStateException("There were "
+ test.errCounter+ " error(s)");
}
}
}
Questo è un esempio rudimentale, ma ti dà un'idea di come eseguire gli unit test senza utilizzare alcun framework.
Quadro di test JUnit
L'uso del framework JUnit per i test unitari presenta diversi vantaggi. Fornisce numerose annotazioni che semplificano la scrittura e l'esecuzione di codici di prova in Java:
- In primo luogo, separa la preoccupazione dello unit test dal codice del progetto effettivo, consentendo di creare un'istanza di classe di test e caricatori di classi per ogni test di unità. Questi "immuno" il codice esistente dagli effetti collaterali non necessari dei test.
- Le annotazioni fornite da JUnit, come @Before, @After, @BeforeClass, @AfterClass —dispone di metodi sia per l'inizializzazione delle risorse che per il recupero delle risorse.
- Esiste un'ampia varietà di metodi di asserzione per verificare il risultato di un test.
- Nel corso degli anni, JUnit è diventato così popolare che numerosi strumenti Java, come Ant e Maven; e IDE popolari, come Eclipse , NetBean , IntelliJ IDEA , e simili, viene fornito con l'integrazione integrata di JUnit.
Per utilizzare JUnit Test Framework in un progetto Java, è necessario aggiungere un file JAR JUnit nel percorso della classe del progetto. Ciò è esplicitamente richiesto se l'IDE non è integrato con la libreria JUnit. Il processo è semplice. Scarica il file JAR e aggiungilo al percorso della classe del progetto.
Ecco alcuni link importanti al framework JUnit.
- Sito ufficiale JUnit
- API Java di JUnit
- Manuale utente di JUnit
- Codice sorgente JUnit in GitHub
A differenza di JUnit 4 e dei suoi predecessori, JUnit 5 ha apportato alcune modifiche significative. Oltre a molte nuove funzionalità aggiunte, come il supporto lambda, nuove annotazioni e iniezione di parametri del metodo di test, l'architettura di base ha subito alcune modifiche significative. JUnit 5 è ora un'architettura composita di tre diversi moduli:JUnit Jupiter, JUnit Vintage e JUnit Platform. Gli sviluppatori del test case, tuttavia, non devono preoccuparsi della complessità delle modifiche. Le modifiche significano principalmente un migliore supporto degli strumenti, coerenza e API più pulite. Soprattutto, è completamente retrocompatibile con JUnit 4. Quindi, nessun problema neanche lì. Fare riferimento alla guida per l'utente di JUnit 5 per maggiori dettagli.
Un rapido esempio
Ecco un esempio molto semplice per dare un'occhiata a come eseguire i test unitari con il framework JUnit. Usiamo il Dipendente class per lo unit test e creare una classe di test per dare un'idea del suo funzionamento. L'esempio è rudimentale nella misura in cui si scrive un programma "Hello World". I casi di test del mondo reale, o anche un esempio decente di unit test, richiedono una buona quantità di codice. Forse lo proveremo in qualche altro articolo.
package org.mano.unittest.examples;
public class Employee {
private final String name;
private final double basicPay;
public Employee(String name, double basicPay) {
this.name=name;
this.basicPay=basicPay;
}
public String getName() {
return name;
}
public double getBasicPay() {
return basicPay;
}
}
package org.mano.unittest.examples;
import org.junit.Test;
import static org.junit.Assert.*;
public class EmployeeTest {
@Test
public void constructorInitTest(){
Employee emp=new Employee("Odin", 2300);
assertEquals("Odin", emp.getName());
assertEquals(2300, emp.getBasicPay(), 0.001);
}
}
package org.mano.unittest.examples;
public class EmployeeTestMain {
public static void main(String[] args){
EmployeeTest et=new EmployeeTest();
et.constructorInitTest();
}
}
Osservare che la classe Employee è immutabile con solo due campi impostati dal costruttore. Poiché vale la pena testare solo il metodo del costruttore, testeremo solo quello.
La classe di test è denominata EmployeeTest come da convenzione. L'annotazione @Test consente a JUnit di designare un metodo come metodo di prova. Ci sono una varietà di metodi di asserzione in Assert classe. Qui abbiamo usato solo assertEquals .
Esistono molti modi per eseguire un test scritto in JUnit. In genere, dopo l'esecuzione dei test case, viene stampato un riepilogo. Tuttavia, potrebbe variare a seconda di come viene eseguito il test. Può essere eseguito tramite IDE come Eclipse o IntelliJ o strumenti come Maven, Gradle e così via. A volte, l'unica informazione ricevuta dopo il test è che ha fallito o superato.
Conclusione
Esistono molti altri framework per il test unitario. JUnit è un framework di unit test popolare nella comunità Java. Il test come fase di ingegneria del sistema ha molti più processi coinvolti. Il test di unità è solo una parte di esso e, cosa interessante, molti test di gioco eseguiti dallo sviluppatore possono essere definiti test di unità. JUnit, come framework di test, aggiunge valore ad esso. Le annotazioni e le API fornite da JUnit automatizzano molte attività e rendono la vita molto più semplice agli sviluppatori di unit test.
