Junit confusion: use 'extends TestCase' or '@Test'?

java

test-engineering

best-practices

annotations

byAnton Shumikhin·Feb 28, 2025

Choose the @Test annotation for a contemporary, annotation-driven approach in JUnit 4 and beyond. Ditch extending TestCase, which hails from the JUnit 3 era. Annotations lead to cleaner, more modular code enabling enhanced control and flexibility.

Here's a simplified example using JUnit 5:

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

class SimpleTest {

    @Test
    void addition() {
        //Yes, we are really testing if 2+3 equals 5, hold your applause.
        assertEquals(5, 2 + 3);
    }
}

Notice the focus is on @Test to signify test methods and assertEquals for validation. No extending any class - just pure, succinct tests.

JUnit 4/5 provides enhanced flexibility

Test setup and breakdown with fewer headaches

Using @Before/@BeforeClass and @After/@AfterClass with JUnit 4 and 5 simplifies preparatory operations and cleanups around your tests. These annotations make your test code highly maintainable and intelligible.

Exception testing done elegant

With JUnit 4+, you're liberated from try/catch blocks of JUnit 3 for testing exceptions. A simple @Test(expected = Exception.class) marks the anticipated exceptions, making your tests lean yet expressive.

Convenient test skipping

Use @Ignore to skip tests. This annotation allows the test runner to ignore specified tests, ensuring your tests resume smoothly, unlike muttering apologies for commented-out codes.

Variety of test runners

The @RunWith annotation allows swapping test runners at ease, offering you a buffet of advanced runners like MockitoJUnitRunner for mock-based tests or SpringJUnit4ClassRunner for tests dealing with Spring context.

Agile grouping of tests

Group tests without breaking a sweat with @RunWith(Suite.class) and @SuiteClasses({}). These determinations help organize your tests across classes without the ceremonial dances around inheritances.

Dominate your tests with annotations

Tame the wild exceptions

With @Rule in JUnit 4, you rule over exception handling with the ExpectedException rule, enabling assertion of exception types and messages. Your tests would be clear, assertive, and a sight for the sore eyes.

Smooth sailing with the new

The voyage to JUnit 5 introduces a fresh API, designed for Java 8 and beyond. With features like friendly Lambda assertions and descriptive @DisplayName annotations, get ready to harness extensibility and customization.

Navigate at ease

Breathe life into your test methods. No more hunting through inheritance chains. Grouping and readability are the stars here! And guess who else loves annotations? Your IDEs, offering better navigation and insights.

explain-codes / Java / Junit confusion: use 'extends TestCase' or '@Test'?

Linked

How to use Mockito with JUnit 5?



What's the actual use of 'fail' in JUnit test case?



How to assert that a certain exception is thrown in JUnit tests?



Difference between @Before, @BeforeClass, @BeforeEach, and @BeforeAll



Changing names of parameterized tests

