JUnit-Lernprogramm: Einrichten, Schreiben und Ausführen von Java-Komponententests

Verstehen Sie die Grundlagen und skalieren Sie Ihre Unit-Test-Praxis wie ein Profi mit diesem Tutorial.

Möchten Sie die Grundlagen überspringen und erfahren, wie Sie die Generierung von Unit-Tests mithilfe von KI automatisieren und so in weniger als 5 Minuten eine Codeabdeckung von 60 % oder mehr erreichen? Dann schauen Sie sich Jtest an >>

Wichtige Erkenntnisse

• JUnit ist der De-facto-Teststandard für Java. JUnit ist das am weitesten verbreitete Framework zum Schreiben und Ausführen automatisierter Unit-Tests, mit dem Fehler frühzeitig in der Entwicklung erkannt werden können.
• Das JUnit-Framework ist ausgereift und entwickelt sich ständig weiter. JUnit wird ständig weiterentwickelt, um den Bedürfnissen von Java-Entwicklern gerecht zu werden, und enthält viele Funktionen, die alle Aspekte einer robusten Unit-Testing-Praxis unterstützen.
• Die Einrichtung ist einfach. JUnit ist in gängigen IDEs wie Eclipse und IntelliJ vorkonfiguriert, während Build-Systeme wie Maven und Gradle mit wenigen Konfigurationszeilen so eingestellt werden können, dass sie JUnit verwenden, unabhängig von der verwendeten Version.
• JUnit-Tests folgen einem strukturierten Muster. Das JUnit-Framework bietet eine einfache API zur Testdefinition, während das Given-When-Then-Format eine nützliche Strukturierung des Testcodes ermöglicht.
• JUnit-Tests können überall ausgeführt werden. Tests können direkt in der IDE ausgeführt werden, um während der Entwicklung schnelles Feedback zu erhalten, oder über Maven- oder Gradle-Befehle, CI/CD-Pipelines und die Kommandozeile zur automatisierten Ausführung.
• Mocking-Frameworks lassen sich problemlos integrieren. Wenn der zu testende Code von externen Systemen oder komplexen Objekten abhängt, können Mocking-Frameworks wie Mockito verwendet werden, um den Code durch die Simulation von Abhängigkeiten zu isolieren und so fokussierte, zuverlässige Unit-Tests ohne Seiteneffekte zu ermöglichen.
• KI beschleunigt JUnit-Tests im großen Maßstab. Parasoft Jtest generiert automatisch Testfälle, Mocks und Assertions direkt in der IDE oder in Pull-Request-Workflows und hilft Teams so, eine signifikante Codeabdeckung zu erreichen und gleichzeitig den Aufwand für die Erstellung und Wartung von Tests um mehr als 50 % zu reduzieren.

Was ist JUnit-Testing?

JUnit ist das beliebteste Framework für Java-Komponententests. Ein Open-Source-Framework, das zum Schreiben und Ausführen wiederholbarer automatisierter Tests verwendet wird.

JUnit hat sich durch die Kombination leistungsstarker, durchdachter und nahtlos zusammenarbeitender Funktionen als De-facto-Standard für Java-Unit-Tests etabliert. Es war das erste entwickelte Unit-Test-Framework und ist dank seiner besonderen Eigenschaften und kontinuierlichen Weiterentwicklung bis heute die bevorzugte Wahl für Java-Entwickler weltweit.

Was sind die wichtigsten Merkmale von JUnit und die wesentlichen Unterschiede zwischen den Versionen?

Wie alles andere hat sich auch das JUnit-Testframework im Laufe der Zeit weiterentwickelt.

JUnit 4.0 wurde 2006 veröffentlicht, 5.0 im Jahr 2017 und 6.0 im September 2025.

Stand Februar 2026 ist die aktuellste Version 6.0.2.

• JUnit 5.x wurde auf eine modulare Architektur umgestellt und viele der früheren Einschränkungen von JUnit wurden behoben.
• JUnit 6.x ist eine sanftere Iteration, die den JUnit 5-Ansatz beibehält, aber das Framework weiter modernisiert und vereinfacht hat.
• JUnit 4 und 5 Beide erfreuen sich nach wie vor hoher Nutzung, doch die Zukunft gehört wahrscheinlich JUnit 6.

Hier sind einige der wichtigsten Aspekte und Funktionen von JUnit sowie die Unterschiede zwischen den Versionen:

Zusammenarbeit für umfassende Tests

Diese Funktionen ergänzen sich synergistisch und bilden ein vollständiges, erweiterbares Framework, das professionelle Softwareentwicklungspraktiken unterstützt.

• Isolation und Konsistenz prüfen. Die Setup- und Teardown-Methoden gewährleisten, dass jeder Test in einem gewünschten, vordefinierten Zustand startet.
• Organisatorische Flexibilität. Test-Suites, verschachtelte Tests und die Verschlagwortung ermöglichen es, die richtigen Tests zum richtigen Zeitpunkt zu organisieren und auszuführen.
• Klarer Testausdruck. Die Kern-API stellt die Werkzeuge bereit, die zum Schreiben verständlicher und wartbarer Tests benötigt werden.
• Skalierbarkeit Funktioniert sowohl für einzelne Entwickler, die eine Handvoll Tests schreiben, als auch für Unternehmensteams, die Tausende von Tests über mehrere Module hinweg pflegen.

So richten Sie JUnit-Tests ein

Dann legen wir mal los. Hier sind die Schritte zum Einrichten von JUnit.

In den gängigeren IDEs wie Eclipse und IntelliJ ist die JUnit-Testintegration bereits standardmäßig installiert.

Wenn Sie keine IDE verwenden und sich stattdessen ausschließlich auf ein Build-System wie Maven oder Gradle verlassen, erfolgt die Konfiguration von JUnit über die Datei pom.xml bzw. build.gradle.

Wichtig zu beachten ist, dass JUnit 5 in drei Module aufgeteilt wurde, von denen eines ein älteres Modul ist, das die Ausführung von JUnit 4 und drei Tests aus JUnit 5 unterstützt.

JUnit 6 behält diese Architektur bei.

JUnit 3 wird derzeit noch sehr selten eingesetzt und ist üblicherweise nur noch in deutlich älteren Projekten zu finden.

Wie man JUnit 6 einrichtet

Aufgrund des modularen Aufbaus von JUnit 6 wird eine Stückliste (POM) zum Importieren aller JUnit-Module und -Abhängigkeiten verwendet. Werden nur bestimmte Module benötigt, können stattdessen einzelne Gruppen oder Artefakte angegeben werden.

Fügen Sie pom.xml Folgendes hinzu, um Javen JUnit 6 zu Maven hinzuzufügen:

<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.junit</groupId>
			<artifactId>junit-bom</artifactId>
			<version>6.0.2</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>
<dependencies>
	<dependency>
		<groupId>org.junit</groupId>
		<artifactId>junit-bom</artifactId>
		<version>6.0.2</version>
		<scope>test</scope>
	</dependency>
</dependencies>

Fügen Sie für Gradle Folgendes zur Datei build.gradle hinzu:

dependencies {
	testImplementation platform("org.junit:junit-bom:6.0.2")
	testImplementation "org.junit.jupiter:junit-jupiter-api"
	testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine"
	testRuntimeOnly "org.junit.platform:junit-platform-launcher"
}
test {
	useJUnitPlatform()
}

Wie man JUnit 5 einrichtet

Aufgrund des modularen Aufbaus von JUnit 5 wird eine Stückliste (POM) zum Importieren aller JUnit-Module und -Abhängigkeiten verwendet. Werden nur bestimmte Module benötigt, können stattdessen einzelne Gruppen oder Artefakte angegeben werden.

JUnit 5 wird auf die gleiche Weise konfiguriert wie JUnit 6:

<dependencyManagement>
	<dependencies>
		<dependency>
			<groupId>org.junit</groupId>
			<artifactId>junit-bom</artifactId>
			<version>5.14.2</version>
			<type>pom</type>
			<scope>import</scope>
		</dependency>
	</dependencies>
</dependencyManagement>
<dependencies>
	<dependency>
		<groupId>org.junit</groupId>
		<artifactId>junit-bom</artifactId>
		<version>5.14.2</version>
		<scope>test</scope>
	</dependency>
</dependencies>

Fügen Sie für Gradle Folgendes zur Datei build.gradle hinzu:

dependencies {
	testImplementation platform("org.junit:junit-bom:5.14.2")
	testImplementation "org.junit.jupiter:junit-jupiter-api"
	testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine"
	testRuntimeOnly "org.junit.platform:junit-platform-launcher"
}
test {
	useJUnitPlatform()
}

Wie man JUnit 4 einrichtet

Um JUnit 4 zu Maven hinzuzufügen, fügen Sie Folgendes zu pom.xml hinzu.

<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.13.2</version>
	<scope>test</scope>
</dependency>

Fügen Sie für gradle Folgendes zur build.gradle hinzu:

dependencies {
	testImplementation 'junit:junit:4.13.2'
}
test {
	useJUnit()
}

Falls Sie JUnit für JUnit-Tests manuell zum Klassenpfad hinzufügen müssen, müssen Sie die JAR-Datei(en) direkt referenzieren. Dies ist jedoch normalerweise nicht erforderlich. JUnit 4, 5 und 6 bieten die JAR-Datei(en) zum direkten Download an. Für JUnit 5 und 6 benötigen Sie eine Fat-JAR-Datei (auch Uber-JAR genannt), wie hier beschrieben.

Welche Komponenten umfasst ein JUnit-Test?

Nachdem wir uns kurz mit der JUnit-Konfiguration befasst haben, widmen wir uns nun der eigentlichen Erstellung und Ausführung dieser Tests. Um die Erstellung von JUnit-Tests zu veranschaulichen, beginnen wir mit einem einfachen Beispiel. Im folgenden JUnit-Testbeispiel sehen wir eine einfache Methode ( links ), die Fahrenheit in Celsius umrechnet, und einen JUnit-Test ( rechts ), der diese Methode testet. Ich habe die wichtigsten Teile des JUnit-Tests nummeriert und werde jeden Teil im Folgenden detailliert erläutern.

 

Importe und Abhängigkeiten in JUnit

Die Teile 1 und 2 im obigen Screenshot zeigen die Importe der JUnit-Klassen und -Methoden, die im Unit-Test verwendet werden. Die Importe können als einzelne Klassen oder Methoden angegeben werden, üblicherweise werden jedoch ganze Pakete mit Sternchen (*) angegeben. Beide Varianten funktionieren – die Granularität der Importe ist Geschmackssache.

Wie man eine JUnit-Testklasse definiert

Teil 3 definiert den Beginn unserer Testklasse. Wichtig ist hierbei die Namenskonvention: KlassennameTest . Diese Konvention ist zwar nicht zwingend erforderlich, aber die gängigste Art, JUnit-Klassen zu benennen, da der Name prägnant den Zweck der Unit-Test-Klasse und die zu testende Klasse beschreibt.

JUnit-Annotationen und ihre Verwendung

In Teil 4 lernen wir unsere erste JUnit-spezifische Syntax kennen: die @Test-Annotation. Annotationen sind beim Erstellen von JUnit-Tests extrem wichtig. Sie dienen dem JUnit-Framework dazu, die relevanten Teile des Unit-Tests zu identifizieren. In unserem Beispiel weist die @Test-Annotation JUnit an, die öffentliche void-Methode, an die sie angehängt ist, als Testfall auszuführen.

Es gibt noch viele weitere Annotationen, aber einige der gebräuchlichsten für JUnit 5 und 6 sind die folgenden.

• Die @BeforeEach-Anweisung kennzeichnet eine Methode, die vor jeder Testmethode in der Klasse ausgeführt werden soll. Sie wird typischerweise verwendet, um den Zustand zu aktualisieren oder zurückzusetzen, der für die korrekte Ausführung der Testmethoden erforderlich ist.
• @AfterEach kennzeichnet eine Methode, die nach jeder Testmethode in der Klasse ausgeführt werden soll. Sie kann verwendet werden, um Variablen zurückzusetzen, temporäre Dateien zu löschen usw.
• @Disabled gibt an, dass eine Testmethode nicht ausgeführt werden soll.
• @BeforeAll kennzeichnet eine Methode, die einmalig vor dem Ausführen von Testmethoden ausgeführt werden soll.
• @AfterAll kennzeichnet eine Methode, die einmalig ausgeführt werden soll, nachdem alle Testmethoden ausgeführt wurden.

Benennung von Testmethoden in JUnit

Beachten Sie für Teil 5 erneut die Namenskonvention testMethodName , wobei methodName der Name der zu testenden Methode in der zu testenden Klasse ist. Diese Namenskonvention ist üblich, aber nicht zwingend erforderlich. Manchmal wird dem Namen eine zusätzliche Beschreibung hinzugefügt, um das spezifische Verhalten zu beschreiben, das der Test überprüft.

Der Abschnitt „Gegeben“ und wie man einen Test einrichtet

In Teil 6, dem Abschnitt „ Gegeben “, erstellen wir eine neue Instanz der zu testenden Klasse und initialisieren sie entsprechend. Dies ist notwendig, da die Testmethode die zu testende Methode aufrufen muss. In unserem Beispiel ist außer der Instanziierung der Klasse keine weitere Initialisierung erforderlich. In vielen Fällen sind jedoch zusätzliche Vorbereitungen notwendig, wie beispielsweise die Initialisierung von Objekten für den Konstruktor oder der Aufruf von Methoden zur Konfiguration des Zustands der zu testenden Klasse.

Der Abschnitt „Wann“ und wie die zu testende Methode aufgerufen wird

In Teil 7, dem „ When“ -Abschnitt des Tests, werden die Variablen initialisiert, die beim Aufruf der zu testenden Methode übergeben werden müssen. Anschließend wird die Testmethode aufgerufen (Teil 8). Die Variablen sollten sinnvolle Werte erhalten, damit der Test die relevanten Teile der Testmethode ausführt. Beachten Sie, dass Variablen, die Objekte sind, instanziiert oder simuliert werden können.

Erfassen Sie die Ausgabe der zu testenden Methode.

In Teil 8 sollte, falls die zu testende Methode einen Wert zurückgibt, dieser in einer Variablen gespeichert werden, damit sein Wert überprüft werden kann.

Der "Dann"-Abschnitt und die Verwendung von Assertions zur Überprüfung von Testergebnissen

Unit-Tests sind nur dann sinnvoll, wenn sie Assertions enthalten, die überprüfen, ob die getestete Methode den korrekten Wert zurückgibt und/oder den Zustand anderer Objekte wie erwartet anpasst. Ohne Assertions, wie in Teil 9 gezeigt, findet keine Verifizierung statt. Ihr Test ist bestenfalls ein Smoke-Test, der nur dann Feedback liefert, wenn eine Ausnahme ausgelöst wird.

Die JUnit-Assertionsmethoden, die in JUnit 5 und 6 in der Klasse `org.junit.jupiter.api.Assertions` und in JUnit 4 in der Klasse `org.junit.Assert` enthalten sind, werden häufig verwendet, um den Status von Testfällen (bestanden/nicht bestanden) zu ermitteln. Nur fehlgeschlagene Assertions werden vom JUnit-Framework gemeldet. Ähnlich wie bei Annotationen gibt es zahlreiche Assertionsoptionen.

In unserem obigen Beispiel-JUnit verwenden wir die Methode assertEquals (erwartet, aktuell, Delta). Das erste Argument ist:

• Das erwartetes Ergebnis, die der Testautor definiert.
• Das tatsächliche Leistung, was der Rückgabewert der aufgerufenen Methode ist
• Das Delta, die eine akzeptable Abweichung zwischen erwarteten und tatsächlichen Werten zulässt. Dieses Delta ist spezifisch für die Tatsache, dass wir den Wert eines Double-Typs validieren.

So führen Sie eine JUnit aus

Wähle dein eigenes Abenteuer! Hier betrachten wir drei Möglichkeiten, JUnits auszuführen:

• Direkt von der Kommandozeile
• Aus der IDE (Eclipse und IntelliJ)
• Verwendung von Build-Systemen (Maven und Gradle)

So führen Sie eine JUnit über die IDE aus

Eclipse

Suchen Sie im Paket-Explorer Ihren JUnit-Test. Klicken Sie mit der rechten Maustaste und wählen Sie Ausführen als > JUnit-Test. Dadurch werden Ihre Test- und Berichtsergebnisse in der JUnit Eclipse-Ansicht ausgeführt.

IntelliJ

Das Ausführen eines Tests in IntelliJ ähnelt Eclipse. Suchen Sie im Projektfenster Ihren Test, klicken Sie mit der rechten Maustaste, und wählen Sie „Testname“ ausführen aus. Wie bei Eclipse öffnet sich ein JUnit-Fenster mit den Ergebnissen des Tests.

Wie man einen JUnit-Test aus dem Maven-Buildsystem ausführt

Maven

Maven vereinfacht das Ausführen von Unit-Tests. Stellen Sie sicher, dass Sie sich im richtigen Verzeichnis Ihrer Konsole befinden und die pom.xml-Datei Ihres Projekts korrekt konfiguriert ist. Anschließend können Sie Ihre JUnit-Tests mit folgendem Befehl ausführen.

So führen Sie die gesamte Testsuite aus:

mvn test

So führen Sie einen oder mehrere einzelne/spezifische Tests durch:

mvn -D test=TestName test

Wie man einen JUnit-Test aus dem Gradle-Build-System ausführt

Gradle hat, ähnlich wie Maven, das Ausführen von Tests vereinfacht.

So führen Sie die gesamte Testsuite aus:

gradlew test

So führen Sie einen oder mehrere einzelne/spezifische Tests durch:

gradlew -D test.single=testName test

Hinweis: Maven und Gradle sind ihre eigenen Bestien. Was hier gezeigt wird, ist minimal, um die Grundlagen abzudecken. Schauen Sie sich ihre Dokumentation an, wenn Sie mehr erfahren möchten.

So führen Sie einen JUnit-Test über die Kommandozeile aus

Um ein JUnit direkt von der Kommandozeile aus auszuführen, benötigen Sie ein paar Dinge:

• JDK auf Ihrem Weg
• Die entsprechende(n) JUnit-JAR-Datei(en)
• Die Quell- und Testklassen

Am einfachsten lässt sich dies in JUnit 5 und 6 mit dem JUnit Console Launcher wie folgt bewerkstelligen.

java -jar /path/to/junit-platform-console-standalone-<version>.jar execute -cp /path/to/source/classes -cp /path/to/test/classes <test class name>

Hinweis: Das Ausführen eines Tests über die Befehlszeile erfolgt am häufigsten über einen CI/CD-Prozess, der in einem Buildsystem wie Jenkins oder Azure DevOps ausgeführt wird.

Fortsetzung des Unit-Tests

Unser Beispiel durchlief einen einfachen Unit-Test, und das ist natürlich nur der Anfang von Unit-Tests. Komplexere zu testende Methoden rufen möglicherweise Methoden in abhängigen Klassen auf oder verbinden sich mit externen Systemen wie einer Datenbank. In solchen Fällen kann es sinnvoll sein, den Code durch Mocking zu isolieren.

Mocking hilft dabei, Codeeinheiten zu isolieren, sodass sich unsere Komponententests nur auf die spezifische zu testende Klasse/Methode konzentrieren können. Das am häufigsten zum Mocking in JUnit-Tests verwendete Framework ist Mockito.

Um mehr über Mocking zu erfahren, lesen Sie den Beitrag meines Kollegen: Wie man einen Java-Unit-Test automatisiert, einschließlich Mocking und Assertions.

Wenn Unit-Tests so wichtig sind, warum werden sie dann nicht von allen konsequent durchgeführt? Trotz ihrer Bedeutung sind Unit-Tests nicht immer einfach zu implementieren und zu pflegen. Sie erfordern fundiertes Entwicklungswissen und kontinuierlichen Aufwand, um die Test-Suites aktuell zu halten. Daher werden Unit-Tests oft vernachlässigt – bis es zu Regressionen kommt.

Aber so muss es nicht sein.

Beschleunigen Sie JUnit-Tests mit KI

Hier kommt Parasoft Jtest ins Spiel. Der KI-gestützte Unit-Test-Assistent wurde entwickelt, um das Schreiben und Pflegen von Unit-Tests deutlich zu vereinfachen. Mit wenigen Klicks können Teams, die mit 0 % Codeabdeckung starten , automatisch robuste Testsuiten generieren, die mindestens 60 % ihres Java-Codes abdecken. Ein Finanzdienstleistungsunternehmen stellte fest: „Seit der Implementierung von Parasoft Jtest konnten wir den Zeitaufwand für die Erstellung und Pflege von Unit-Tests um mehr als 50 % reduzieren.“

So kann Ihr Team Ihre Testpraxis skalieren.

• Automatische Generierung von JUnit-Testfällen für zuvor nicht entdeckten Code mithilfe der intelligenten Massentesterstellung.
• Zielerstellung für geänderten Code direkt in der IDE oder innerhalb von Pull-Request-Workflows.
• Schützen Sie Ihre Daten mit der proprietären KI von Parasoft, die vor Ort ausgeführt werden kann – kein Code oder Daten verlässt Ihre Umgebung.
• Mocks und Stubs generieren um Abhängigkeiten zu isolieren und Ihre Tests zu fokussieren. Dies spart Zeit und macht das manuelle Schreiben von Mocking-Logik überflüssig.
• Anpassen und Erweitern von Tests mit Ein-Klick-Aktionen zum Hinzufügen von Behauptungen, Parametrisieren von Testfällen und Verbessern der Wartbarkeit.
• Beschleunigen Sie die Testausführung mit eingebauten Test Impact Analysis und Live-Unit-Tests, das nur die Tests identifiziert und ausführt, die zur Validierung Ihrer letzten Codeänderungen erforderlich sind.

Wenn Ihnen das Schreiben und Warten von JUnit-Tests wie eine lästige Pflicht vorkommt, ist es Zeit, Ihren Ansatz zu modernisieren. KI-gestützte Testlösungen wie diese können die Testerstellung von einem Engpass in einen strategischen Vorteil verwandeln – und Ihnen mehr Zeit für die Entwicklung großartiger Software geben.