JUnit. It introduces several powerful features and enhancements that make it easier to write, organize, and run tests. Understanding these advanced features can help you create more robust and maintainable test suites.

What is JUnit 5?

JUnit 5 is a major update to the JUnit framework, designed to be more flexible and modular. It consists of three main components:

1. JUnit Platform: The foundation for launching testing frameworks on the JVM.
2. JUnit Jupiter: The new programming model and extension model for writing tests.
3. JUnit Vintage: Provides support for running JUnit 3 and JUnit 4 tests on the JUnit 5 platform.

Key Features of JUnit 5

1. Display Names: Annotate tests with custom display names for better readability.
2. Nested Tests: Organize tests hierarchically to reflect the structure of the tested code.
3. Dynamic Tests: Create tests dynamically at runtime.
4. Tagging and Filtering: Group tests using tags and filter them during execution.
5. Assertions and Assumptions: Enhanced support for assertions and assumptions to control test execution flow.

Example: Using Advanced Features of JUnit 5

1. Custom Display Names:

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

@DisplayName("Calculator Tests")
class CalculatorTest {

    @Test
    @DisplayName("Addition Test")
    void testAddition() {
        assertEquals(2, 1   1, "1   1 should equal 2");
    }
}

1. Nested Tests:

import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;

class OuterTest {

    @Nested
    class InnerTest {
        @Test
        void innerTest() {
            // Test logic here
        }
    }
}

1. Dynamic Tests:

import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.TestFactory;
import java.util.stream.Stream;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.DynamicTest.dynamicTest;

class DynamicTestsDemo {

    @TestFactory
    Stream dynamicTests() {
        return Stream.of(1, 2, 3, 4, 5)
                .map(number -> dynamicTest("Test number "   number, () -> assertTrue(number > 0)));
    }
}

1. Tagging and Filtering:

import org.junit.jupiter.api.Tag;
import org.junit.jupiter.api.Test;

class TaggingTest {

    @Test
    @Tag("fast")
    void fastTest() {
        // Fast test logic here
    }

    @Test
    @Tag("slow")
    void slowTest() {
        // Slow test logic here
    }
}

1. Assertions and Assumptions:

import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assumptions.assumeTrue;

class AssertionsDemo {

    @Test
    void testException() {
        assertThrows(IllegalArgumentException.class, () -> {
            throw new IllegalArgumentException("Exception message");
        });
    }

    @Test
    void testAssumption() {
        assumeTrue(5 > 1);
        // Test logic here
    }
}

Conclusion

JUnit 5 brings a wealth of new features and improvements that make it a powerful tool for modern Java testing. By leveraging these advanced capabilities, you can create more organized, flexible, and maintainable test suites, ensuring your code is robust and reliable.