{"id":103,"date":"2023-12-21T20:24:41","date_gmt":"2023-12-21T19:24:41","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=103"},"modified":"2024-01-08T09:12:34","modified_gmt":"2024-01-08T08:12:34","slug":"unit-testing-in-java-mit-junit-5","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=103","title":{"rendered":"Unit-Testing in Java mit JUnit 5"},"content":{"rendered":"\n

Was ist Unit-Testing?<\/h2>\n\n\n\n

Unit-Testing ist eine Methode des Softwaretests, bei der einzelne Einheiten oder Komponenten einer Software unabh\u00e4ngig voneinander \u00fcberpr\u00fcft werden, um sicherzustellen, dass sie gem\u00e4\u00df den Spezifikationen funktionieren. Diese Einheiten k\u00f6nnen Funktionen, Methoden oder Klassen sein, die den kleinsten ausf\u00fchrbaren Code darstellen. Ziel des Unit-Testings ist es, sicherzustellen, dass jede Einheit ordnungsgem\u00e4\u00df funktioniert und dass \u00c4nderungen an einer Einheit keine unerw\u00fcnschten Auswirkungen auf andere Teile des Codes haben.<\/p>\n\n\n\n

Unit-Tests sind unverzichtbar, um die Qualit\u00e4t und Zuverl\u00e4ssigkeit von Software zu gew\u00e4hrleisten. Sie erm\u00f6glichen es Entwicklern, Fehler fr\u00fchzeitig zu erkennen und zu beheben, bevor sie sich auf andere Teile des Codes auswirken oder in die Produktion gelangen.<\/p>\n\n\n\n

JUnit 5: Ein \u00dcberblick<\/h2>\n\n\n\n

JUnit ist ein weit verbreitetes Framework f\u00fcr das Unit-Testing in der Java-Programmierung. Mit JUnit k\u00f6nnen Entwickler Testf\u00e4lle schreiben und automatisch ausf\u00fchren, um sicherzustellen, dass ihre Code-Einheiten korrekt funktionieren. JUnit 5 ist die neueste Version dieses Frameworks und bietet viele Verbesserungen und neue Funktionen im Vergleich zu fr\u00fcheren Versionen.<\/p>\n\n\n\n

Die wichtigsten Merkmale von JUnit 5 sind:<\/p>\n\n\n\n

1. Modulare Architektur:<\/h3>\n\n\n\n

JUnit 5 wurde mit einer modularen Architektur entwickelt, die es erm\u00f6glicht, nur die ben\u00f6tigten Teile des Frameworks zu verwenden. Dies erh\u00f6ht die Flexibilit\u00e4t und erleichtert die Integration mit anderen Tools und Bibliotheken.<\/p>\n\n\n\n

2. Erweiterte Annotations:<\/h3>\n\n\n\n

JUnit 5 bietet eine erweiterte und verbesserte Annotation-Syntax, mit der Entwickler Testf\u00e4lle und Testmethoden kennzeichnen k\u00f6nnen. Dies macht den Code leserlicher und wartungsfreundlicher.<\/p>\n\n\n\n

3. Parameterisierte Tests:<\/h3>\n\n\n\n

JUnit 5 unterst\u00fctzt parameterisierte Tests, bei denen Sie denselben Testfall mit verschiedenen Eingabewerten ausf\u00fchren k\u00f6nnen. Dies erleichtert die \u00dcberpr\u00fcfung von verschiedenen Szenarien.<\/p>\n\n\n\n

4. Erweiterbare Architektur:<\/h3>\n\n\n\n

Entwickler k\u00f6nnen eigene Erweiterungen und Plugins f\u00fcr JUnit 5 erstellen, um spezifische Anforderungen zu erf\u00fcllen oder benutzerdefinierte Funktionalit\u00e4ten hinzuzuf\u00fcgen.<\/p>\n\n\n\n

Installation von JUnit 5<\/h2>\n\n\n\n

Bevor Sie mit JUnit 5 Unit-Tests schreiben k\u00f6nnen, m\u00fcssen Sie sicherstellen, dass Sie JUnit 5 in Ihrem Projekt installiert haben. Dies kann auf verschiedene Arten erfolgen, abh\u00e4ngig von Ihrem Build-Tool (z.B. Maven oder Gradle) und Ihrer Entwicklungsumgebung (z.B. Eclipse oder IntelliJ IDEA).<\/p>\n\n\n\n

Maven<\/h3>\n\n\n\n

Wenn Sie Maven verwenden, k\u00f6nnen Sie JUnit 5 zu Ihren Abh\u00e4ngigkeiten in der pom.xml<\/code>-Datei Ihres Projekts hinzuf\u00fcgen:<\/p>\n\n\n

<dependencies<\/span>><\/span>\n    <dependency<\/span>><\/span>\n        <groupId<\/span>><\/span>org.junit.jupiter<\/groupId<\/span>><\/span>\n        <artifactId<\/span>><\/span>junit-jupiter-api<\/artifactId<\/span>><\/span>\n        <version<\/span>><\/span>5.7.2<\/version<\/span>><\/span> <!-- Aktuelle Version \u00fcberpr\u00fcfen --><\/span>\n        <scope<\/span>><\/span>test<\/scope<\/span>><\/span>\n    <\/dependency<\/span>><\/span>\n<\/dependencies<\/span>><\/span><\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
Stellen Sie sicher, dass Sie die aktuelle Version von JUnit 5 verwenden, indem Sie die Versionsnummer in der pom.xml<\/code>-Datei aktualisieren.<\/p>\n\n\n\n
Gradle<\/h3>\n\n\n\n
Wenn Sie Gradle verwenden, k\u00f6nnen Sie JUnit 5 in Ihrer build.gradle<\/code>-Datei hinzuf\u00fcgen:<\/p>\n\n\n
dependencies {\n    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.7.2'<\/span> \/\/ Aktuelle Version \u00fcberpr\u00fcfen<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
F\u00fchren Sie nach dem Hinzuf\u00fcgen der Abh\u00e4ngigkeit einen Build Ihres Projekts durch, um JUnit 5 herunterzuladen und zu installieren.<\/p>\n\n\n\n
Entwicklungsumgebung<\/h3>\n\n\n\n
In den meisten Entwicklungsumgebungen wie Eclipse oder IntelliJ IDEA ist JUnit 5 bereits integriert. Sie m\u00fcssen lediglich sicherstellen, dass Sie die entsprechenden Bibliotheken korrekt konfiguriert haben, um JUnit 5 in Ihren Tests verwenden zu k\u00f6nnen.<\/p>\n\n\n\n
Schreiben von Unit-Tests mit JUnit 5<\/h2>\n\n\n\n
Nach der Installation von JUnit 5 k\u00f6nnen Sie damit beginnen, Unit-Tests f\u00fcr Ihre Java-Code-Einheiten zu schreiben. Dies erfolgt in drei Schritten: das Annotieren von Testf\u00e4llen, das Erstellen von Testmethoden und das Ausf\u00fchren der Tests.<\/p>\n\n\n\n
1. Annotieren von Testf\u00e4llen<\/h3>\n\n\n\n
Um einen Testfall zu erstellen, kennzeichnen Sie eine Klasse mit der @Test<\/code>-Annotation von JUnit 5. Ein Testfall ist eine Sammlung von Testmethoden, die verschiedene Aspekte der zu testenden Einheit abdecken.<\/p>\n\n\n
import<\/span> org.junit.jupiter.api.Test;\n\npublic class<\/span> MeinTestfall<\/span> <\/span>{\n\n    @Test\n    public void<\/span> testErfolgreicheBerechnung() {\n        \/\/ Hier schreiben Sie Ihren Testcode<\/span>\n    }\n\n    @Test\n    public void<\/span> testFehlerhafteBerechnung() {\n        \/\/ Hier schreiben Sie Ihren Testcode<\/span>\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
2. Erstellen von Testmethoden<\/h3>\n\n\n\n
Nachdem Sie Ihren Testfall erstellt haben, k\u00f6nnen Sie Testmethoden in dieser Klasse hinzuf\u00fcgen. Diese Methoden sollten mit der @Test<\/code>-Annotation gekennzeichnet sein und den Code enthalten, der Ihre zu testende Einheit \u00fcberpr\u00fcft. Hier ist ein einfaches Beispiel:<\/p>\n\n\n
import<\/span> org.junit.jupiter.api.Test;\nimport<\/span> static<\/span> org.junit.jupiter.api.Assertions.*;\n\npublic class<\/span> MeinTestfall<\/span> <\/span>{\n\n    @Test\n    public void<\/span> testAddition() {\n        \/\/ Arrange<\/span>\n        int a = 5<\/span>;\n        int b = 3<\/span>;\n\n        \/\/ Act<\/span>\n        int sum = a + b;\n\n        \/\/ Assert<\/span>\n        assertEquals(8<\/span>, sum);\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel testen wir die Addition zweier Zahlen. Wir arrangieren (Arrange) die Eingabewerte, f\u00fchren die Berechnung durch (Act) und \u00fcberpr\u00fcfen das erwartete Ergebnis (Assert) mit der assertEquals<\/code><\/p>\n\n\n\n
-Methode von JUnit 5.<\/p>\n\n\n\n
3. Ausf\u00fchren der Tests<\/h3>\n\n\n\n
Nachdem Sie Ihre Testf\u00e4lle und -methoden erstellt haben, k\u00f6nnen Sie die Tests ausf\u00fchren. In den meisten Entwicklungsumgebungen k\u00f6nnen Sie dies einfach tun, indem Sie auf die Schaltfl\u00e4che „Tests ausf\u00fchren“ oder „Testen“ klicken. JUnit 5 f\u00fchrt dann automatisch alle Testmethoden in Ihren Testf\u00e4llen aus und gibt das Ergebnis zur\u00fcck.<\/p>\n\n\n\n
Assert-Methoden in JUnit 5<\/h2>\n\n\n\n
JUnit 5 bietet eine Vielzahl von Assert-Methoden, die Sie verwenden k\u00f6nnen, um Ihre Testergebnisse zu \u00fcberpr\u00fcfen. Hier sind einige h\u00e4ufig verwendete Assert-Methoden:<\/p>\n\n\n\n
    \n
  • assertEquals(expected, actual)<\/code>: \u00dcberpr\u00fcft, ob actual<\/code> gleich expected<\/code> ist.<\/li>\n\n\n\n
  • assertNotEquals(expected, actual)<\/code>: \u00dcberpr\u00fcft, ob actual<\/code> nicht gleich expected<\/code> ist.<\/li>\n\n\n\n
  • assertTrue(condition)<\/code>: \u00dcberpr\u00fcft, ob condition<\/code> wahr ist.<\/li>\n\n\n\n
  • assertFalse(condition)<\/code>: \u00dcberpr\u00fcft, ob condition<\/code> falsch ist.<\/li>\n\n\n\n
  • assertNull(object)<\/code>: \u00dcberpr\u00fcft, ob object<\/code> null ist.<\/li>\n\n\n\n
  • assertNotNull(object)<\/code>: \u00dcberpr\u00fcft, ob object<\/code> nicht null ist.<\/li>\n\n\n\n
  • assertArrayEquals(expectedArray, actualArray)<\/code>: \u00dcberpr\u00fcft, ob die Arrays expectedArray<\/code> und actualArray<\/code> gleich sind.<\/li>\n<\/ul>\n\n\n\n
    Sie k\u00f6nnen auch benutzerdefinierte Assertionen erstellen, indem Sie eigene Bedingungen und Fehlermeldungen definieren.<\/p>\n\n\n\n
    Parameterisierte Tests<\/h2>\n\n\n\n
    JUnit 5 erm\u00f6glicht es Ihnen, parameterisierte Tests zu erstellen, bei denen Sie denselben Testfall mit verschiedenen Eingabewerten ausf\u00fchren k\u00f6nnen. Dies ist besonders n\u00fctzlich, wenn Sie denselben Code mit verschiedenen Daten \u00fcberpr\u00fcfen m\u00f6chten. Um parameterisierte Tests in JUnit 5 zu erstellen, verwenden Sie die @ParameterizedTest<\/code>-Annotation.<\/p>\n\n\n\n
    Hier ist ein einfaches Beispiel f\u00fcr einen parameterisierten Test:<\/p>\n\n\n
    import<\/span> org.junit.jupiter.params.ParameterizedTest;\nimport<\/span> org.junit.jupiter.params.provider.ValueSource;\nimport<\/span> static<\/span> org.junit.jupiter.api.Assertions.*;\n\npublic class<\/span> ParameterisierteTests<\/span> <\/span>{\n\n    @ParameterizedTest\n    @ValueSource(ints = {1<\/span>, 2<\/span>, 3<\/span>, 4<\/span>, 5<\/span>})\n    public void<\/span> testIsGeradeZahl(int zahl) {\n        assertTrue(zahl % 2<\/span> == 0<\/span>);\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    In diesem Beispiel f\u00fchren wir denselben Test f\u00fcr verschiedene Eingabewerte (1, 2, 3, 4, 5) aus und \u00fcberpr\u00fcfen, ob es sich um gerade Zahlen handelt.<\/p>\n\n\n\n
    Ausnahmen testen<\/h2>\n\n\n\n
    Manchmal ist es notwendig, zu \u00fcberpr\u00fcfen, ob eine Methode eine erwartete Ausnahme wirft. JUnit 5 bietet die assertThrows<\/code>-Methode, um dies zu erm\u00f6glichen.<\/p>\n\n\n\n
    Hier ist ein Beispiel:<\/p>\n\n\n
    import<\/span> org.junit.jupiter.api.Test;\nimport<\/span> static<\/span> org.junit.jupiter.api.Assertions.*;\n\npublic class<\/span> AusnahmeTests<\/span> <\/span>{\n\n    @Test\n    public void<\/span> testDivisionDurchNull() {\n        assertThrows(ArithmeticException.class, () -> {\n            int result = 5<\/span> \/ 0<\/span>; \/\/ Division durch Null<\/span>\n        });\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
    In diesem Beispiel testen wir, ob die Division durch Null eine ArithmeticException<\/code> ausl\u00f6st. Die assertThrows<\/code>-Methode erwartet den erwarteten Ausnahmetyp und den Lambda-Ausdruck, der den Code enth\u00e4lt, der die Ausnahme ausl\u00f6st.<\/p>\n\n\n\n
    Testlebenszyklus in JUnit 5<\/h2>\n\n\n\n
    JUnit 5 definiert einen klaren Lebenszyklus f\u00fcr Tests, der aus verschiedenen Phasen besteht:<\/p>\n\n\n\n
      \n
    1. @BeforeAll<\/code>: Diese Methode wird einmal vor dem Start aller Tests in einer Klasse ausgef\u00fchrt.<\/li>\n\n\n\n
    2. @BeforeEach<\/code>: Diese Methode wird vor jeder Testmethode in einer Klasse ausgef\u00fchrt.<\/li>\n\n\n\n
    3. @Test<\/code>: Dies ist die eigentliche Testmethode, die den Code f\u00fcr die \u00dcberpr\u00fcfung enth\u00e4lt.<\/li>\n\n\n\n
    4. @AfterEach<\/code>: Diese Methode wird nach jeder Testmethode in einer Klasse ausgef\u00fchrt.<\/li>\n\n\n\n
    5. @AfterAll<\/code>: Diese Methode wird einmal nach dem Abschluss aller Tests in einer Klasse ausgef\u00fchrt.<\/li>\n<\/ol>\n\n\n\n
      Sie k\u00f6nnen diese Annotationen verwenden, um bestimmte Aktionen vor oder nach Ihren Tests auszuf\u00fchren, z. B. das Initialisieren von Ressourcen oder das Aufr\u00e4umen nach den Tests.<\/p>\n\n\n\n
      Test-Tagging und -Filtering<\/h2>\n\n\n\n
      JUnit 5 bietet die M\u00f6glichkeit, Tests mit Tags zu versehen und diese Tags zu verwenden, um Tests auszuw\u00e4hlen oder auszuschlie\u00dfen. Dies ist besonders n\u00fctzlich, wenn Sie Tests in verschiedenen Kategorien organisieren oder bestimmte Tests in verschiedenen Umgebungen ausf\u00fchren m\u00f6chten.<\/p>\n\n\n\n
      Hier ist ein Beispiel f\u00fcr das Tagging von Tests:<\/p>\n\n\n
      import<\/span> org.junit.jupiter.api.Test;\nimport<\/span> org.junit.jupiter.api.Tag;\nimport<\/span> static<\/span> org.junit.jupiter.api.Assertions.*;\n\n@Tag(\"integration\"<\/span>)\npublic class<\/span> Integrationstests<\/span> <\/span>{\n\n    @Test\n    public void<\/span> testIntegrationTest1() {\n        \/\/ Testcode f\u00fcr Integrationstest 1<\/span>\n    }\n\n    @Test\n    public void<\/span> testIntegrationTest2() {\n        \/\/ Testcode f\u00fcr Integrationstest 2<\/span>\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
      Sie k\u00f6nnen dann JUnit 5-Filter verwenden, um Tests basierend auf Tags auszuw\u00e4hlen oder auszuschlie\u00dfen.<\/p>\n\n\n\n
      Zusammenfassung und Best Practices<\/h2>\n\n\n\n
      Unit-Testing ist eine entscheidende Praxis in der Softwareentwicklung, um die Qualit\u00e4t und Zuverl\u00e4ssigkeit Ihres Codes sicherzustellen. JUnit 5 ist ein leistungsf\u00e4higes Framework, das die Erstellung und Ausf\u00fchrung von Unit-Tests in Java erleichtert.<\/p>\n\n\n\n
      Hier sind einige bew\u00e4hrte Praktiken f\u00fcr das Unit-Testing mit JUnit 5:<\/p>\n\n\n\n
        \n
      • Schreiben Sie Tests fr\u00fchzeitig: Beginnen Sie bereits w\u00e4hrend der Entwicklung damit, Tests zu schreiben, um fr\u00fchzeitig Fehler zu erkennen.<\/li>\n\n\n\n
      • Halten Sie Tests unabh\u00e4ngig: Stellen Sie sicher, dass Tests unabh\u00e4ngig voneinander ausgef\u00fchrt werden k\u00f6nnen, ohne auf den Zustand anderer Tests zu angewiesen zu sein.<\/li>\n\n\n\n
      • Nutzen Sie parameterisierte Tests: Verwenden Sie parameterisierte Tests, um denselben Testfall mit verschiedenen Eingabewerten auszuf\u00fchren.<\/li>\n\n\n\n
      • \u00dcberpr\u00fcfen Sie Ausnahmen: Testen Sie, ob Ihre Methoden die erwarteten Ausnahmen ausl\u00f6sen.<\/li>\n\n\n\n
      • Verwenden Sie Tags und Filtering: Verwenden Sie Tags, um Tests zu organisieren und Filter zu erstellen, um Tests auszuw\u00e4hlen oder auszuschlie\u00dfen.<\/li>\n<\/ul>\n\n\n\n
        Mit JUnit 5 und diesen bew\u00e4hrten Praktiken k\u00f6nnen Sie sicherstellen, dass Ihr Java-Code fehlerfrei und zuverl\u00e4ssig ist und somit die Qualit\u00e4t Ihrer Software verbessern.<\/p>\n","protected":false},"excerpt":{"rendered":"
        Was ist Unit-Testing? Unit-Testing ist eine Methode des Softwaretests, bei der einzelne Einheiten oder Komponenten einer Software unabh\u00e4ngig voneinander \u00fcberpr\u00fcft werden, um sicherzustellen, dass sie gem\u00e4\u00df den Spezifikationen funktionieren. Diese Einheiten k\u00f6nnen Funktionen, Methoden oder Klassen sein, die den kleinsten ausf\u00fchrbaren Code darstellen. Ziel des Unit-Testings ist es, sicherzustellen, dass jede Einheit ordnungsgem\u00e4\u00df funktioniert und […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-103","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/103","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=103"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/103\/revisions"}],"predecessor-version":[{"id":105,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/103\/revisions\/105"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=103"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=103"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=103"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}