Testing Mastery: JUnit, Mockito & Integration Tests · Lektion

Grundlegende JUnit-5-Annotations

Erkunden Sie wichtige JUnit-5-Annotations wie @Test, @BeforeEach und @AfterEach sowie deren praktische Anwendung.

Grundlegende JUnit-5-Annotations ist eine kostenlose Testing Mastery: JUnit, Mockito & Integration Tests-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Testing Mastery: JUnit, Mockito & Integration Tests-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Testing Mastery: JUnit, Mockito & Integration Tests-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

What are JUnit Annotations?

In JUnit 5, annotations are markers that tell the runner how to run your tests — defining test methods, setup, and cleanup.

Marking Tests with @Test

The core annotation is @Test. Put it above any method and JUnit runs it as a test, reporting pass or fail.

Your First Test Method

Here’s @Test in action: a method that asserts 1 + 1 equals 2. (Assertions like assertEquals are coming up next lesson.)

package com.coddykit;

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

class SimpleTest {

    @Test
    void additionTest() {
        int result = 1 + 1;
        assertEquals(2, result, "1 + 1 should be 2");
    }
}

Setup Before Each Test: @BeforeEach

@BeforeEach runs before every test method, giving each one a fresh, known state — so your tests stay independent and reliable.

@BeforeEach in Practice

Here @BeforeEach resets a message before each test runs, so both tests start from the same clean state.

package com.coddykit;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertTrue;

class BeforeEachTest {

    String message;

    @BeforeEach
    void setup() {
        message = "Hello CoddyKit!";
        System.out.println("Setup called."); // For illustration
    }

    @Test
    void testMessageStartsWithHello() {
        assertTrue(message.startsWith("Hello"));
    }

    @Test
    void testMessageLength() {
        assertTrue(message.length() > 5);
    }
}

Cleanup After Each Test: @AfterEach

@AfterEach runs after every test method — perfect for closing files, releasing connections, or resetting state so tests don’t bleed into each other.

@AfterEach in Action

Here @AfterEach tears down state after each test, clearing the log so the next test starts clean.

package com.coddykit;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertTrue;

class AfterEachTest {

    StringBuilder log;

    @BeforeEach
    void setup() {
        log = new StringBuilder("Test started. ");
    }

    @Test
    void testLogAppendOne() {
        log.append("Action 1. ");
        assertTrue(log.toString().contains("Action 1"));
    }

    @Test
    void testLogAppendTwo() {
        log.append("Action 2. ");
        assertTrue(log.toString().contains("Action 2"));
    }

    @AfterEach
    void teardown() {
        System.out.println("Log after test: " + log.toString());
        log = null; // Simulate cleanup
    }
}

Understanding the Test Flow

The lifecycle for each test is fixed: @BeforeEach, then the @Test method, then @AfterEach — repeating per test to guarantee isolation.

Order of Execution

Arrange the following actions in the correct order as JUnit executes them for each @Test method.

Recap: Essential JUnit Annotations

You’ve learned the essentials: @Test marks a test, @BeforeEach sets up, and @AfterEach cleans up. Assertions are up next.

Häufig gestellte Fragen

Ist die Lektion „Grundlegende JUnit-5-Annotations“ kostenlos?

Ja — der vollständige Text von „Grundlegende JUnit-5-Annotations“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Testing Mastery: JUnit, Mockito & Integration Tests-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Testing Mastery: JUnit, Mockito & Integration Tests-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Grundlegende JUnit-5-Annotations“?

Erkunden Sie wichtige JUnit-5-Annotations wie @Test, @BeforeEach und @AfterEach sowie deren praktische Anwendung. Du übst Testing Mastery: JUnit, Mockito & Integration Tests mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Testing Mastery: JUnit, Mockito & Integration Tests zu starten?

Keine Vorkenntnisse erforderlich. Testing Mastery: JUnit, Mockito & Integration Tests auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Grundlegende JUnit-5-Annotations“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Testing Mastery: JUnit, Mockito & Integration Tests-Lektion Code schreiben und ausführen?

Ja. Jede Testing Mastery: JUnit, Mockito & Integration Tests-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

Einführung in Unit-Tests
Grundlegende JUnit-5-Annotations
JUnit-Assertions und Testausführung
Tests mit @DisplayName und Verschachtelung organisieren

← Zurück zu Testing Mastery: JUnit, Mockito & Integration Tests