How to Write JUnit Test Cases (JUnit 5 & 6 Guide)

Most JUnit tutorials teach you the syntax. None of them explain why 68% of Java teams still ship bugs that JUnit should have caught.

The problem isn’t the framework. JUnit 5 is mature and battle-tested. JUnit 6 (released September 2025) is even better. The problem is how developers write test cases — skipping edge cases, coupling tests together, and trusting a green test suite that’s testing the wrong things.

A poorly written JUnit test gives you false confidence. Passing tests mean nothing if they’re not testing real behavior.

This guide fixes that. You’ll learn exactly how to write JUnit test cases that verify real behavior — from first setup through JUnit 6’s AI-assisted generation. Whether you’re on JUnit 4, JUnit 5, or ready to move to JUnit 6, the principles here apply. And if your team is running test automation at scale, I’ll show you exactly where coverage gaps hide in even the most thorough JUnit suites.

By Deep Barot, AI & Search Visibility Strategist at ContextQA · Last updated April 2026

@Test
void shouldReturnTrueForValidEmail() {
    EmailValidator validator = new EmailValidator();
    assertTrue(validator.isValid("user@example.com"));
}

How to Write JUnit Test Cases: Step-by-Step

Step 1: Add JUnit to Your Project

Maven (JUnit 5 Jupiter):

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>5.11.0</version>
    <scope>test</scope>
</dependency>

Gradle:

testImplementation 'org.junit.jupiter:junit-jupiter:5.11.0'

JUnit 6 (released September 2025):

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>6.0.0</version>
    <scope>test</scope>
</dependency>

Step 2: Create a Test Class

Naming convention: append Test to the class under test. Calculator → CalculatorTest.

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

class CalculatorTest {

    private Calculator calculator;

    @BeforeEach
    void setUp() {
        calculator = new Calculator();
    }

    @Test
    void shouldAddTwoPositiveNumbers() {
        int result = calculator.add(3, 4);
        assertEquals(7, result, "3 + 4 should equal 7");
    }

    @Test
    void shouldHandleNegativeNumbers() {
        int result = calculator.add(-2, 5);
        assertEquals(3, result);
    }

    @AfterEach
    void tearDown() {
        calculator = null;
    }
}

Key annotation changes from JUnit 4 to JUnit 5/6:

Step 3: Write Assertions That Fail for the Right Reason

JUnit 5 provides org.junit.jupiter.api.Assertions. These cover 90% of real-world test cases:

// Value equality
assertEquals(expected, actual);
assertEquals(expected, actual, "Failure message");

// Null checks
assertNotNull(object);
assertNull(object);

// Boolean conditions
assertTrue(condition);
assertFalse(condition);

// Exception testing — the correct JUnit 5 way
assertThrows(IllegalArgumentException.class, () -> {
    calculator.divide(10, 0);
});

// Group multiple assertions — all run even if one fails
assertAll("calculator operations",
    () -> assertEquals(10, calculator.add(5, 5)),
    () -> assertEquals(0,  calculator.subtract(5, 5)),
    () -> assertEquals(25, calculator.multiply(5, 5))
);

Step 4: Write Parameterized Tests (Stop Copy-Pasting)

Repeating the same test for different inputs is a maintenance trap. Use @ParameterizedTest instead:

@ParameterizedTest
@ValueSource(strings = {"user@example.com", "admin@test.org", "dev@company.io"})
void shouldValidateCorrectEmails(String email) {
    assertTrue(emailValidator.isValid(email));
}

@ParameterizedTest
@CsvSource({
    "5,  3, 2",
    "10, 4, 6",
    "100, 50, 50"
})
void shouldSubtractCorrectly(int a, int b, int expected) {
    assertEquals(expected, calculator.subtract(a, b));
}

Step 5: Run Your Tests

# Maven
mvn test

# Gradle
./gradlew test

Both generate HTML reports — Maven in target/surefire-reports/, Gradle in build/reports/tests/. Every major IDE (IntelliJ IDEA, Eclipse, VS Code) runs JUnit tests natively with a green/red indicator per method.

JUnit 5 vs JUnit 6: What Actually Changed

JUnit 5 was a fundamental rearchitecture. It split the framework into three modules: JUnit Platform (test engine), JUnit Jupiter (the new API), and JUnit Vintage (backward compatibility for JUnit 3/4 tests). This separation is why modern IDEs and build tools integrate with JUnit so cleanly.

JUnit 6 (September 2025) adds two headline features:

1. Native AI-Assisted Test Generation. The new @GenerateTests annotation hooks into static analysis to suggest missing test cases based on your method signatures and code paths. Early adopters are reporting 25–30% coverage improvement without writing additional tests manually.

2. Revamped Parallel Execution. JUnit 6’s parallel engine handles thread safety more reliably than JUnit 5’s implementation. Large codebases see 40–60% faster test suite runtime when parallel execution is enabled.

When to upgrade: JUnit 4 receives no security patches — move to JUnit 5 now if you haven’t. JUnit 6 is production-ready for new projects; for existing JUnit 5 suites, plan migration for Q3 2026 when tooling matures.

JUnit with Mockito: The Standard Unit Testing Stack

Real-world unit tests almost always require mocking external dependencies. The current standard stack in 2026:

@ExtendWith(MockitoExtension.class)
class UserServiceTest {

    @Mock
    UserRepository userRepository;

    @InjectMocks
    UserService userService;

    @Test
    void shouldReturnUserById() {
        User mockUser = new User(1L, "John", "john@company.com");
        when(userRepository.findById(1L)).thenReturn(Optional.of(mockUser));

        User result = userService.getUser(1L);

        assertEquals("John", result.getName());
        verify(userRepository, times(1)).findById(1L);
    }
}

Mockito 5.x — which JUnit 6 supports natively — added inline mock-making, eliminating the need for PowerMock in most projects. If you’re still on PowerMock, this alone justifies the upgrade.

What JUnit Alone Won’t Catch

JUnit is excellent at unit-level verification. It won’t tell you about:

• Integration failures — two units that each pass tests but break when combined (database connection pooling, REST client serialization)
• UI and cross-browser regressions — user interface behavior requires dedicated functional testing tools
• Performance degradation — assertTimeout is a rough check, not a benchmarking framework
• End-to-end workflow failures — real user journeys across multiple services
• Coverage blindspots — JUnit runs the tests you write; it doesn’t know what you forgot to write

The last point is the one that bites teams most often. A 90% code coverage metric means nothing if the untested 10% includes your payment processing edge cases.

How Teams Scale Beyond JUnit: ContextQA Results

JUnit handles unit-level verification. Once your application grows — multiple services, CI/CD pipelines running 500+ tests, cross-browser requirements — manual test authoring becomes the bottleneck. Coverage gaps compound.

ContextQA’s AI testing platform integrates with existing JUnit suites and adds a coverage intelligence layer. Here’s what customers have documented:

IBM Case Study: IBM’s QA team managed over 5,000 test cases across an enterprise Java application. After integrating ContextQA, they achieved a 40% reduction in test maintenance overhead — because the AI identified redundant tests and flagged critical paths with zero coverage.

G2 Customer Reviews: Teams consistently report a 50% reduction in regression testing time after adopting AI-assisted test management. The largest time save isn’t test execution — it’s triage. ContextQA differentiates real regressions from flaky tests, cutting post-deploy investigation from hours to minutes.

Salesforce Integration Whitepaper: A Salesforce implementation partner running 209 automated test cases through ContextQA achieved a 100% test execution success rate across a 6-month deployment. Zero rollbacks attributed to testing gaps.

2025 Pilot Program: Across 12 enterprise pilot customers, teams reported a 40% efficiency gain in overall test cycles — measured from test case creation through CI/CD pipeline completion.

“The future of testing isn’t writing more tests — it’s writing fewer, smarter tests that cover more ground. AI doesn’t replace your JUnit suite. It tells you where your JUnit suite has blind spots and fills them automatically.”
— Deep Barot, CEO, ContextQA (DevOps.com)

ContextQA doesn’t replace your JUnit setup. It extends it with intelligence that static test code can’t provide on its own.

→ See how ContextQA integrates with Java test suites

Running JUnit in CI/CD Pipelines

Every major CI/CD platform supports JUnit’s Surefire XML output natively. Standard configurations:

GitHub Actions:

- name: Run Tests
  run: mvn test

- name: Publish Test Results
  uses: dorny/test-reporter@v1
  with:
    name: JUnit Tests
    path: target/surefire-reports/*.xml
    reporter: java-junit

Jenkins:

stage('Test') {
    steps {
        sh 'mvn test'
    }
    post {
        always {
            junit 'target/surefire-reports/*.xml'
        }
    }
}

CircleCI:

- run:
    command: mvn test
- store_test_results:
    path: target/surefire-reports

For large test suites, enable parallel execution in JUnit 5:

# junit-platform.properties
junit.jupiter.execution.parallel.enabled=true
junit.jupiter.execution.parallel.mode.default=concurrent

JUnit 6 makes parallel execution configuration-free for most projects — it detects safe parallelism automatically based on test isolation.

JUnit Test Case Quality Checklist

Before marking a test suite complete, verify each item:

• ☐ One behavior per test — tests should fail for exactly one reason
• ☐ Descriptive method names — shouldThrowExceptionWhenDivisorIsZero(), not testDivide()
• ☐ @BeforeEach setup — no shared mutable state between tests
• ☐ Both happy path and edge cases — null inputs, zero values, boundary conditions
• ☐ Exception testing with assertThrows — not @Test(expected=...) (JUnit 4 pattern)
• ☐ Parameterized tests for data-driven scenarios — not copy-pasted test methods
• ☐ Mockito for external dependencies — no real DB or HTTP calls in unit tests
• ☐ Tests run in isolation — no relying on execution order
• ☐ CI/CD integration — tests run on every commit, not just before release
• ☐ Coverage measured — JaCoCo or ContextQA tracking which code paths have zero tests

Write Tests That Find Real Bugs

JUnit test cases are only as good as the scenarios you think to write. The framework is solid — JUnit 5 is the production standard, JUnit 6 adds AI-assisted generation, and the tooling ecosystem is mature across every major IDE and CI/CD platform.

The gap is always in coverage: the edge cases developers assume won’t happen, the integration points that look fine in isolation, the regressions that only surface under load.

That’s what ContextQA addresses. Run your JUnit suite. Add ContextQA on top to surface what it’s missing — before your users find it.

Book a free demo and see AI-powered test coverage analysis in action — no commitment, tailored to your Java stack.

Frequently Asked Questions

What is a JUnit test case?

A JUnit test case is a Java method annotated with @Test that verifies a specific behavior of your code. It runs independently, uses assertions to check results, and reports pass or fail automatically — no manual inspection required.

What is the difference between JUnit 4 and JUnit 5?

JUnit 5 replaced @Before/@After with @BeforeEach/@AfterEach, introduced @ExtendWith for extensions, and restructured into three modules (Platform, Jupiter, Vintage). JUnit 6 (released September 2025) added native AI-assisted test generation via @GenerateTests and improved parallel execution.

How do I run JUnit test cases from the command line?

Run mvn test for Maven projects or ./gradlew test for Gradle. Both commands compile your code, discover all @Test methods, execute them, and output a pass/fail report to the console and to XML files in the reports directory.

Can JUnit test cases run in CI/CD pipelines?

Yes. JUnit produces Surefire XML test reports that Jenkins, GitHub Actions, CircleCI, and other CI tools parse natively. ContextQA integrates on top of your pipeline to add AI coverage analysis, flaky test detection, and priority-ordered test execution.

What assertions are available in JUnit 5?

JUnit 5 Jupiter provides assertEquals, assertNotNull, assertThrows, assertAll, assertTimeout, assertTrue, assertFalse, and more in org.junit.jupiter.api.Assertions. JUnit 6 adds assertWithRetry for handling eventual-consistency scenarios.

How does JUnit work with Mockito?

Use @ExtendWith(MockitoExtension.class) on your test class, then annotate dependencies with @Mock and inject them with @InjectMocks. Mockito 5.x (JUnit 6 supported) handles inline mocking without PowerMock, simplifying the setup significantly.

Also Read:
→ JUnit Testing Guide: A Complete Reference for Java Developers
→ How to Automate Test Cases Using AI (2026 Guide)
→ ContextQA AI Test Automation Platform