Name

JUnit 4.5

Homepage

http://www.junit.org
Download from Sourceforge

Lizenz

Common Public Licence (CPL)

Untersuchte Version

JUnit 4.5 vom 08.08.2008

Letzter Untersuchungszeitpunkt

25.10.2010

Kurzbeschreibung

JUnit wurde zum Testen von Java-Programmen entwickelt. Mit dem Tool lassen sich automatisierte Unit-Tests einzelner Klassen, Methoden oder Testsuiten (Zusammenfassungen mehrerer Tests) durchführen. JUnit liefert bei seinen Tests zwei Ergebnisse: Test fehlerfrei durchlaufen (grün), Test mit Fehler abgebrochen (rot).
In der aktuellen Version 4.5 wurden viele interne Funktionalitäten verbessert, so wurde z.B. der "JUnit4ClassRunner" durch den "BlockJUnit4Runner" abgelöst. Eine Liste mit allen Patchnotes ist hier zu finden.

Fazit

JUnit bietet eine sehr gute Möglichkeit Java-Programme zu testen. Das Werkzeug ist sehr mächtig und bietet umfangreiche Test- und Automatisierungsszenarien. Für unerfahrene Nutzer ist es am Anfang eher schwierig sich in die Testmechanismen einzuarbeiten. Da JUnit sehr verbreitet und oft genutzt wird, findet man gute und hilfreiche Literatur im Internet, welche das Einarbeiten sehr erleichtert. Die aktuellste Version von JUnit ist 4.5 und wird stetig weiterentwickelt.

Einsatzgebiete

JUnit wird im Java Umfeld von Entwicklern genutzt, die das Innenleben einer Klasse kennen, um Unit-, Komponenten- und White-Box-Tests zu schreiben.

Einsatzumgebungen

Plugin für Eclipse oder als Standalone-Anwendung

Installation

Zur Installation von JUnit muss das heruntergeladene Zip-File in einem beliebigen Ordner entpackt werden. In diesem Ordner befindet sich eine JAR-Datei (junit-4.5.jar), diese Datei muss in die Pfadvariable des Systems integriert werden.

Diese Schritte reichen aus, um JUnit auf einem System zu installieren. Um die Installation zu testen kann folgender Befehl in einer Konsole eingegeben werden java org.junit.runner.JUnitCore org.junit.tests.AllTests
. Mit diesem Aufruf werden mitgelieferte JUnit-Tests ausgeführt um zu zeigen, dass JUnit korrekt installiert wurde. Diese Tests sollten alle korrekt durchlaufen. Zusätzlich besteht die Möglichkeit, JUnit in Eclipse zu verwenden, wie JUnit in Eclipse genutzt werden kann, wird im nächsten Abschnitt beschrieben.


Einbinden in Eclipse:

Ein neues Java-Projekt erstellen oder ein schon bestehendes öffnen bzw. auswählen. Auf "Project" --> "Properties" klicken, "Java Build Path", "Libraries" auswählen, und auf "Add External JARs" klicken. Jetzt zu "junit-4.5.jar" navigieren und auswählen. Okay drücken. Anschließend kann eine neue JUnit-Testklasse erstellt werden.

Dokumentation

Im Ordner von JUnit befinden sich zwei weitere Ordner, die als Dokumentation von JUnit genutzt werden können. Im Ordner "javadoc" befindet sich die generierte Dokumentation aus den Quelldateien, welche Hinweise über einzelne Klassen, Objekte und Methoden gibt. Im Ordner "doc" befinden sich weitere Ordner, die eine entsprechende Dokumentation enthalten über FAQ, Cookbook und über den Aufbau von Tests. Weitere Informationen, Hinweise und Tipps befinden sich auf der Webseite von JUnit.

Wartung der Projektseite

Die Projektseite von JUnit ist sehr gut strukturiert und besitzt einen übersichtlichen Aufbau. Die Seite gewährt einen schnellen Einblick in die Funktionalität von JUnit. Die Webseite wird stetig weiterentwickelt und mit neuem Inhalt aktualisiert.

Nutzergruppen und Support

Eine Registrierung auf der Webseite ist möglich. Eine Mailinglist mit den Entwicklern ist auf der Seite integriert, mit einer Statusanzeige wer gerade Online ist. Es besteht die Möglichkeit, einen beliebigen Entwickler direkt per E-Mail zu kontaktieren. Zudem gibt es ein Forum in denen Fragen gestellt oder Vorschläge gemacht werden können.

Intuitive Nutzbarkeit

Die Nutzbarkeit von JUnit ist sehr gut. Um einen neuen Unit-Test anzulegen, wird eine "JUnit Testclass" angelegt und mit Testmethoden gefüllt, anschließend kann diese Klasse in Eclipse ausgeführt werden. Innerhalb von Eclipse öffnet sich ein JUnit Fenster, in dem die Testergebnisse dargestellt werden. Treten während des Testlaufs Fehler auf, werden diese übersichtlich dargestellt, um diese zu analysieren. Es ist lediglich nötig die richtige Syntax zu erlernen. Diese wird kurz und gut in der offiziellen FAQ erklärt.

Automatisierung

Automatisierungen sind über sogenannte Testsuiten, die flexibel Mengen von Tests zusammenfassen können und über die Gruppierung von Tests mit Hilfe von XML möglich.

TestSuite

Mit einer TestSuite können einzelne Testklassen zusammengefasst werden. Einzelne Tests können gemeinsam durchgeführt werden und andere nicht. Dadurch ist es möglich das Testen besser zu strukturieren. Zusammgengehörige Testfälle können gruppiert werden und durch einen Klick ausgeführt werden.

Einführendes Beispiel in TestSuites

In dem vorliegendem Beispiel werden die einzelnen Methoden (Plus, Minus, Mal, Verdopple) einer Klasse Rechner getestet. Durch das Zusammenfassen der Plus und Minus- Tests in eine eigene TestSuite(namens: PlusUndMinusTestSuite), können diese gleichzeitig mit einem Knopfdruck auf “Run” ausgeführt werden.

Weiterhin wird Mal und Verdopple in eine eigene Testsuite(namens: MalUndVerdoppleTestSuite) gepackt, somit können diese Methoden auf einmal getestet werden. Dabei ist zu beachten, dass diese Testsuite( namens: MalUndVerdoppleTestSuite) nun unabhängig von der anderen getestet werden kann. Durch das Zusammenfassen der beiden Testsuite in eine weitere übergeordnete TestSuite(names: AllesTestSuite) können alle Tests gleichzeitig ausgeführt werden.

Projekt zum Download:

Taschenrechner.zip

Die Klasse Rechner.java beinhaltet die Methoden die getestet werden sollen. (plus, minus, mal und verdopple)

 public class Rechner { 
	public  Rechner() {} 	
 	public int plus(int a, int b){
 		return a + b;
 	}
 	
 	public int minus(int a, int b){
 		return a - b;
 	}
 	
 	public int mal(int a, int b){
 		return a*b;
 	}
 	
 	public int verdopple(int a){
 		return a*2;
 	}
 }
 }
		

Für jede Methode ist eine einzelne Testklasse vorhanden. Es wird eine neue Junit-Testklasse angelegt mit dem Namen RechnerTestMal:

import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;



public class RechnerTestMal {
	
	@Before
	public void setUp(){
		Rechner r = new Rechner();
	}
	@Test
	public void testMal1() {
		Assert.assertTrue(r.mal(5,2)==10);
	}
	
	@Test
	public void testMal2() {
		Assert.assertTrue(r.mal(2,4)==8);
	}
	
	@Test
	public void testMal3() {
		Assert.assertTrue(r.mal(10,3)==30);
	}

}

Diese beinhaltet einige Tests die die Methode Mal auf Korrektheit überpfrüfen.
Die TestKlassen für die anderen Methoden werden auch angelegt:

RechnerTestPlus
RechnerTestMinus
RechnerTestVerdopple


Alle Tests einzeln auszuführen ist etwas aufwändig und unübersichtlich. Das ist wo eine TestSuite zum Einsatz kommen kann.
Die einzelnen Testklassen können nun in einer Testsuite zusammengefasst werden und somit gleichzeitig ausgeführt werden.

In diesem Beispiel wird die TestKlasse RechnerTestMal.java, RechnerTestVerdopple.java in einer Suite zusammengefasst und RechnerTestPlus.java , RechnerTestMinus.java in eine zweite.
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

@RunWith(Suite.class)
@SuiteClasses({RechnerTestMal.class, RechnerTestVerdopple.class})
public class malUndVerdoppleTestSuite {
}

Die @SuiteClass({RechnerTestMal.class, RechnerTestVerdopple.class})-Annotation legt fest,dass alle Testklassen(die in der Klammer stehen) ausgeführt werden, wenn die Annotation @RunWith(Suite.class) davor steht. Beide Annotationen werden vor der Klassensignatur geschrieben.

Die Testsuite kann nun wie eine normale Testklasse ausgeführt werden. Alle Tests der einzelnen mit SuiteClass angebeben Klassen werden jetzt durchlaufen.

Die Erstellung der zweiten Suite mit dem Namen der Klasse: plusUndMinusTestSuite.java folgt dem gleichen Prinzip. Dort werden die TestKlassen RechnerTestPlus.java, RechnerTestMinus.java zusammengefasst.

Bild zur TestSuite

Es ist auch möglich eine übergeordnete TestSuite zu erstellen die aus andere Testsuites besteht.

Die Testsuite AllesTestSuite.java besteht aus den beiden oben erstellten TestSuites

malUndVerdoppleTestSuite, plusUndMinusTestSuite


  

import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

@RunWith(Suite.class)
@SuiteClasses({malUndVerdoppleTestSuite.class, plusUndMinusTestSuite.class})
public class AllesTestSuite {
}


Wird AllesTestSuite.java ausgeführt, werden alle im Beispiel erstellten Tests ausgeführt.
ANT
Die Automatisierung von JUnit mit Hilfe von Ant lässt sich leicht umsetzen. Ant bietet von zu Haus aus schon eine optionale Task, um aus Ant einen JUnit-Vorgang zu steuern. Zusätzlich bietet es viele Möglichkeiten, um die Testabläufe zu verfeinern. Die Ergebnisse der Tests können in unterschiedlichen Formaten, wie normaler Flietext, XML etc. gespeichert werden. Zudem wird auch die Funktionalität unterstützt, dass bei einem fehlerhaften Testfall, der Build-Prozess unterbrochen wird. Für weitere Funktionalitäten sei auf die Ant-Dokumentation verwiesen.
Die Ausführung mehrere einzelner Testfälle wird durch die Angabe von Batchtest unter Ant automatisiert. Dazu können sogenannte Filesets definiert werden, die eine Menge von Testfällen auswählt und automatisiert startet. Für jeden Test kann dann wiederum ein Report in Form von z.B. Flietext erzeugt werden. Als weitere Ergänzung soll noch kurz JUnitReport angesprochen werden. Diese Task-Eigenschaft von ANT ermöglicht es, verschiedene XML-Reports zu einem Dokument zu verschmelzen, um einen Gesamtüberblick der Testfälle zu erlangen. Für nähere Informationen sei wieder auf die Ant-Dokumentation verwiesen. Somit bietet Ant in Kombination mit JUnit ein gutes Umfeld um die JUnit-Testfälle automatisiert ablaufen zu lassen.
Eine Beispielautomatisierung ist hier zu finden.

Maven

Die Automatisierung von JUnit Testfällen mit Hilfe von Maven ist möglich. Maven bietet von zu Haus aus schon eine Unterstützung von JUnit an. Dazu werden bestehende Maven-Plugins in die Konfigurationsdatei pom.xml eingebunden. Die Reports der Ausführungen werden unter dem Target-Ordner im Verzeichnis surefire-reports gespeichert und können somit zu einem späteren Zeitpunkt analysiert werden. Die Ausführung von einzelnen Tests, wie auch die Ausführung von ganzen Suiten ist durch das Maven Plugin möglich.
Ein einfaches Automatisierungsbeispiel ist hier zu finden.

Vergleich Ant und Maven

Im Vergleich sind beide Unterstützungen leicht in das jeweilige build-Werkzeug zu integrieren. Die Dokumentation der Tasks bzw. Plugins sind verständlich und aktuell. Jegliche Version von JUnit wurde von dem jeweiligen Werkzeug untersttzt.

Einführendes Beispiel

Als einführendes Beispiel werden verschiedene If-Bedingungen und Zahlenberechnungen getestet (Fakultät und Fibonacci Zahlen). Mit folgenden Klassen lässt sich ein einfaches Testszenario zum Analysieren und Lernen durchspielen. Zuerst wird eine Methode benötigt, die getestet werden soll. In diesem Beispiel wurde TestBeideWahr(); aus der Klasse WahrFalsch.java gewählt. Diese einfache Methode überprüft ob zwei Boolean-Werte "true" ergeben. Falls dies nicht der Fall ist, wird eine Exception geworfen.

public class WahrFalsch {

	private String erg = "";

	public void TestBeideWahr(boolean a, boolean b) throws Exception{

		if(a && b){
			erg = "beide wahr";
			System.out.println("Beide Wahr");
		}
		else{
			erg = "nicht beide wahr";
			throw new Exception("Variablen nicht identisch");
		}

	}
	...

Um die Tests durchzuführen wird eine JUnit-Klasse benötigt:

Anlegen einer neuen JUnit Test Klasse

Um die einzelnen Klassenmethoden testen zu können, müssen die dafür nötigen Objekte erzeugt werden. Die Methode public void setUp(); wird zu Anfang des Testlaufs automatisch ausgeführt und kann, unter anderem, verwendet werden um Variablen zu initialisieren oder eine Verbindung zu einer Datenbank aufzubauen.
Durch den automatischen Aufruf von public void tearDown(); am Ende jeden Testdurchlaufs, kann der Tester nicht mehr benötigte Ressourcen freigeben oder offene Datenbankverbindungen trennen.
Die Annotations "@Before" und "@After" legen fest, ob die Methoden vor oder nach einem Testlauf ausgeführt werden sollen.

	/*Wird vor jedem Testaufruf ausgeführt*/
	@Before
	public void setUp() throws Exception {

		objWF = new WahrFalsch();
		objF = new Fakultaet();
		objFib = new Fibonacci();
	}

	/*Wird nach jedem Testaufruf ausgeführt*/
	@After
	public void tearDown() throws Exception {

	}

Jeder Testfall muss in eine eigene Methode unterteilt werden. Die Annotation "@Test" kennzeichnet die Methode als einen Testcase und wird bei einem JUnit-Testlauf automatisch ausgeführt. Wirft die zu testende Methode eine Exception schlägt der Test fehl.
Falls keine Exception geworfen wurde, vergleicht assertTrue(); den zu erwartenden Wert mit dem Rückgabewert der Methode objWF.getSring();. Sind beide Werte gleich, war der Test ein Erfolg, ansonsten schlägt dieser fehl und die überprüfte Methode muss überarbeitet werden.


	// Testet ob beide Variablen wahr sind
	@Test
	public void WahrFalsch1(){
		String expected = "beide wahr";

		try{
			objWF.TestBeideWahr(true, true);
		}catch (Exception e) {
			fail("TestWahrFalsch1 fehlgeschlagen");
			e.printStackTrace();
		}

		assertEquals(expected, objWF.getString());
	}


Alternativen zu assertEquals(); können hier gefunden werden.
Nachdem die Tests geschrieben wurden, klickt man rechts auf die Testklasse und wählt "Run As" --> "JUnit Test Case" aus:

Starten einer JUnit Testklasse


Wenn der Test durchgelaufen ist wird folgende Ansicht in Eclipse sichtbar und zeigt, ob der Test korrekt durchlaufen wurde oder nicht. Die Testfälle werden dementsprechend gekennzeichnet:

Ergebnis der Testläufe

Detaillierte Beschreibung

Siehe Hilfe von JUnit, FAQ und Cookbook.

Literatur

Zur Literatur

Zurück zur Werkzeugübersicht
Zurück zur CSI-Hauptseite