JUnit 5: advanced features?

Question

Accepted Answer

**JUnit 5** — a modern testing framework with support for **parameterized tests, extensions, and nested tests**. **Simple analogy:** JUnit 4 is like an old TV (only on/off). JUnit 5 is like a Smart TV — plays video, connects apps, voice control. JUnit 5 gives you a modular architecture (JUnit Platform + JUnit Jupiter + JUnit Vintage), where you pick exactly the features you need and plug in extensions like apps. **Why it matters:** Modern Java projects require testing features beyond simple `@Test` methods — parameterized inputs, custom lifecycle hooks, dynamic test generation, and test grouping. JUnit 5 provides all of these out of the box, reducing boilerplate and making test suites more expressive and maintainable. **Parameterized tests:** ```java @ParameterizedTest @ValueSource(strings = {"racecar", "radar", "level"}) void shouldDetectPalindromes(String word) { assertTrue(isPalindrome(word)); } @ParameterizedTest @CsvSource({ "1, 1, 2", "2, 3, 5", "0, 0, 0" }) void shouldAdd(int a, int b, int expected) { assertEquals(expected, calculator.add(a, b)); } @ParameterizedTest @MethodSource("userProvider") void shouldValidateUsers(User user) { assertTrue(validator.isValid(user)); } static Stream userProvider() { return Stream.of( new User("Alice", "a@b.com"), new User("Bob", "b@b.com") ); } @ParameterizedTest @CsvFileSource(resources = "/test-data.csv", numLinesToSkip = 1) void shouldParseCsvData(String input, String expected) { assertEquals(expected, parser.parse(input)); } @ParameterizedTest @EnumSource(ChronoUnit.class) void shouldWorkWithAllTimeUnits(ChronoUnit unit) { assertNotNull(unit); } ``` **Nested tests:** ```java class CalculatorTest { @Nested class Addition { @Test void positiveNumbers() { assertEquals(5, calc.add(2, 3)); } @Test void negativeNumbers() { assertEquals(-5, calc.add(-2, -3)); } } @Nested class Division { @Test void byZero() { assertThrows(ArithmeticException.class, () -> calc.divide(1, 0)); } } } ``` **Extensions (lifecycle hooks):** ```java public class DatabaseExtension implements BeforeAllCallback, AfterAllCallback, BeforeEachCallback, AfterEachCallback { @Override public void beforeAll(ExtensionContext ctx) { startDatabase(); } @Override public void afterAll(ExtensionContext ctx) { stopDatabase(); } @Override public void beforeEach(ExtensionContext ctx) { truncateTables(); } @Override public void afterEach(ExtensionContext ctx) { logTestResult(ctx); } } @ExtendWith(DatabaseExtension.class) @Testclass public class UserRepositoryTest { ... } ``` **Tags (filtering):** ```java @Tag("slow") @Test void longRunningTest() { } # Run: mvn test -Dgroups="!slow" ``` **Dynamic tests (runtime-generated):** ```java @TestFactory Stream dynamicShoppingCartTests() { ShoppingCart cart = new ShoppingCart(); return Stream.of( dynamicTest("Add item increases size", () -> { cart.add(new Item("Widget", 9.99)); assertEquals(1, cart.size()); }), dynamicTest("Remove item decreases size", () -> { cart.remove(0); assertEquals(0, cart.size()); }) ); } ``` **Common mistakes:** - **Forgetting `@ExtendWith`** — custom extensions are silently ignored without it. - **Mixing JUnit 4 and JUnit 5 imports** — `org.junit.jupiter.api.Test` is JUnit 5, `org.junit.Test` is JUnit 4. Mixing them in the same class leads to confusing behavior. - **Not using `@DisplayName`** — test output reads `test1()`, `test2()` instead of meaningful descriptions. - **Ignoring assertion messages** — always add a message to `assertEquals(expected, actual, "description")` for clearer failure reports.

Java: JUnit 5: advanced features?