JUnit is een open source unit-testraamwerk van derden. Het project werd eind 1995 gestart door Kent Beck en Erich Gamma. Het wekte al snel interesse in de gemeenschap van ontwikkelaars die zich met name bezighouden met testgestuurde ontwikkeling. JUnit werd aanvankelijk geïntroduceerd bij Smalltalk, maar werd later overgezet naar Java, dat dit snel oppikte als een de-facto standaard voor unit-testing. De populariteit van JUnit groeide in die mate dat, om tegemoet te komen aan de behoeften van vele andere hedendaagse talen zoals C#, Perl, Python, PHP, Ruby, Visual Basic, C++, enzovoort, een generiek xUnit-framework werd ontwikkeld waarin de letter 'x' wordt vervangen door de eerste letter van de taal, zoals JUnit voor Java, RUnit voor Ruby, enzovoort. Dit artikel geeft een overzicht van dit raamwerk zoals gebruikt door de de-facto standaard van Java unit testing.
Testoverzicht
Testen is een belangrijke fase in de levenscyclus van een applicatieontwikkeling. Het belangrijkste doel van testen is om een programma te evalueren op basis van vereiste specificaties. Het doel is om bepaalde testgevallen te creëren die fouten, hiaten, eventuele discrepanties of onverwachte resultaten zoveel mogelijk aan het licht brengen. Aan dit eenvoudige concept zijn enkele uitgebreide processen verbonden. Maar om het kort te zeggen, het gebeurt op drie niveaus. Wanneer het testen op zeer granulair of individueel componentniveau wordt gedaan, wordt dit Unit Testing genoemd.; wanneer ze worden gecombineerd om de interfaces tussen componenten te vergelijken met een softwareontwerp, wordt dit Integratietesten genoemd.; en tot slot, wanneer het volledige systeem is geïntegreerd en er wordt getest of het systeem als geheel aan de gespecificeerde vereisten voldoet, wordt dit Systeemtesten genoemd. .
Eenheid testen
In een notendop, het uitvoeren van een unit-test is een manier om het gedrag van een afzonderlijke code-eenheid te onderzoeken. In Java, een code-eenheid kan een methode of een klasse of zelfs een module betekenen, afhankelijk van de context. Als het bijvoorbeeld een methode is, ligt de focus van de test op het evalueren van de juiste objectreferentie die de methode mag aanroepen, type parameters en acceptabele waarden, primitieve waardebereiken, retourtype en waarde, enzovoort. Het idee is om de methode zo te grillen dat deze robuust genoeg kan worden gemaakt om het probleem gracieus aan te pakken en de problemen die buiten het bereik vallen, buiten het contract te gooien.
Daarom vormt unit-testing de basisbouwsteen van elke programma-evaluatie. In feite voert elke programmeur een soort unit-test uit terwijl men code schrijft om de uitkomst van de code te controleren met enkele dummy-gegevens/cases. Eenheidstest is dus een formele status die aan die geïsoleerde verzameling tests wordt gegeven. Het is uiterst belangrijk dat een code de strengheid van verschillende testfasen doorloopt. Het testen van eenheden is, naast het belang ervan, ook heel gewoon. Mensen zoals Kent Beck en Erich Gamma bedachten om er een raamwerk voor te creëren, zodat programmeurs een gestructureerde omgeving krijgen en veel van deze taken kunnen automatiseren. Daar is tenslotte een kader voor. Meestal biedt het een coherente programmastructuur die herbruikbaar en deelbaar is tussen applicaties. Een programmeur kan ze opnemen in een bestaande applicatie en ze uitbreiden volgens zijn specifieke behoefte.
Een snel voorbeeld
Een eenvoudige code voor het testen van eenheden om de enkele methode in Temperatuur te onderzoeken class zonder JUnit-framework is als volgt:
package org.mano.unittest.examples;
public class Circle {
double area(double radius) {
returnMath.PI* radius * radius;
}
}
Laten we nu de code schrijven om het gebied te testen methode.
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)");
}
}
}
Dit is een rudimentair voorbeeld, maar het geeft je een idee over hoe unit-testing kan worden uitgevoerd zonder een raamwerk te gebruiken.
JUnit-testraamwerk
Het gebruik van JUnit-framework voor unit-testen heeft verschillende voordelen. Het biedt talrijke annotaties die het gemakkelijk maken om testcodes in Java te schrijven en uit te voeren:
- In de eerste plaats scheidt het de zorg van unit-testing van de daadwerkelijke projectcode door iemand in staat te stellen een testklasse-instantie en klasse-laders te maken voor elke unit-test. Deze "immuniseren" de bestaande code tegen onnodige bijwerkingen van testen.
- De annotaties geleverd door JUnit, zoals @Before, @After, @BeforeClass, @AfterClass -methoden hebben voor zowel resource-initialisatie als resourceterugwinning.
- Er is een grote verscheidenheid aan assert-methoden om het resultaat van een test te verifiëren.
- In de loop der jaren werd JUnit zo populair dat talloze Java-tools, zoals Ant en Maven; en populaire IDE's, zoals Eclipse , NetBeans , IntelliJ IDEE , en dergelijke, wordt geleverd met ingebouwde integratie van JUnit.
Om het JUnit Test Framework in een Java-project te gebruiken, moet men een JUnit JAR-bestand toevoegen aan het pad van de projectklasse. Dit is expliciet vereist als de IDE niet is geïntegreerd met de JUnit-bibliotheek. Het proces is eenvoudig. Download het JAR-bestand en voeg het toe aan het pad van de projectklasse.
Hier zijn enkele belangrijke links naar het JUnit-framework.
- Officiële JUnit-site
- JUnit Java-API
- JUnit-gebruikershandleiding
- JUnit-broncode in GitHub
In tegenstelling tot JUnit 4 en zijn voorgangers, bracht JUnit 5 enkele belangrijke veranderingen met zich mee. Afgezien van veel nieuwe functies die zijn toegevoegd, zoals lambda-ondersteuning, nieuwe annotaties en injectie van testmethodeparameters, heeft de kernarchitectuur een aantal belangrijke wijzigingen ondergaan. JUnit 5 is nu een samengestelde architectuur van drie verschillende modules:JUnit Jupiter, JUnit Vintage en JUnit Platform. De ontwikkelaars van testcases hoeven zich echter geen zorgen te maken over de fijne kneepjes van wijzigingen. De veranderingen betekenen vooral betere toolondersteuning, consistentie en schonere API's. Bovenal is het volledig achterwaarts compatibel met JUnit 4. Dus ook daar geen zorgen. Raadpleeg de JUnit 5 gebruikershandleiding voor meer details.
Een snel voorbeeld
Hier is een heel eenvoudig voorbeeld om een glimp op te vangen van hoe unit-tests kunnen worden uitgevoerd met het JUnit-framework. We gebruiken de Medewerker class voor de eenheidstest en maak een testklasse om een idee te geven van de werking ervan. Het voorbeeld is rudimentair in de mate van het schrijven van een 'Hello World'-programma. Real-world testcases, of zelfs een goed voorbeeld van unit-test, vereisen een goede hoeveelheid code. Misschien proberen we dat in een ander artikel.
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();
}
}
Merk op dat de klasse Werknemer onveranderlijk is met slechts twee velden die door de constructor zijn ingesteld. Omdat alleen de constructormethode het testen waard is, testen we die alleen.
De testklasse heet EmployeeTest volgens afspraak. De annotatie @Test stelt JUnit in staat een methode aan te wijzen als testmethode. Er zijn verschillende assert-methoden in de Assert klas. Hier hebben we alleen asserEquals . gebruikt .
Er zijn veel manieren om een in JUnit geschreven test uit te voeren. Nadat de testgevallen zijn uitgevoerd, wordt doorgaans een samenvatting afgedrukt. Het kan echter variëren, afhankelijk van hoe de test wordt uitgevoerd. Het kan door IDE's zoals Eclipse of IntelliJ lopen, of tools zoals Maven, Gradle, enzovoort. Soms is de enige informatie die na de test wordt ontvangen, dat deze is mislukt of geslaagd.
Conclusie
Er zijn verschillende andere kaders voor unit testing. JUnit is een populair raamwerk voor het testen van eenheden in de Java-gemeenschap. Testen als systeemengineeringfase brengt veel meer proces met zich mee. Unit-testen is er slechts een onderdeel van en, interessant genoeg, veel play-tests die door de ontwikkelaar worden uitgevoerd, kunnen unit-testen worden genoemd. JUnit voegt daar als testraamwerk waarde aan toe. De annotaties en de API's van JUnit automatiseren veel taken en maken het leven van de unit-testontwikkelaars een stuk eenvoudiger.