Skip to main content

JUnit

Ankur in JUnit

Master JUnit 5: A Deep Dive into @TestInstance, @TestMethodOrder, and @Timeout

If your JUnit tests rely on clumsy static setup, break the moment they are reordered, or occasionally freeze your CI/CD pipeline, you are likely fighting the default test engine. JUnit 5 (Jupiter) introduced a suite of powerful annotations to solve these exact architectural bottlenecks. In this guide, we’ll explore three game-changers: @TestInstance, @TestMethodOrder, and @Timeout, and how to use them to build a professional-grade, enterprise-ready automation framework. 1. @TestInstance: Redefining the Test Lifecycle By default, JUnit creates a new instance of your test class for every single @Test method. This is known as Lifecycle.PER_METHOD. While this ensures perfect test isolation, it forces one major constraint: @BeforeAll and @AfterAll methods must be static. The Problem: Static Constraints and Overhead In a standard lifecycle, you are restricted to static fields for global setup. This becomes a headache when using Dependency Injection (like Spring’s @Autowired) or when your setup logic requires access to instance-level variables. Furthermore, if your test class has a heavy constructor or deep initialization, recreating it dozens of times for every test significantly slows down your build speed.

1 min read
Ankur in JUnit

Master JUnit 5 @RegisterExtension: The Power of Programmatic Extensions

TL;DR: Use @RegisterExtension when your JUnit 5 extension needs runtime configuration, state access, or dynamic initialization—especially in integration tests. Testing in Java has evolved far beyond simple assertions. As developers, we often face scenarios where standard declarative testing doesn't cut it. You might need to initialize a database with a dynamic port, configure a web server based on specific test parameters, or inject dependencies that are only known at runtime. This is where JUnit 5 @RegisterExtension shines. In this guide, we’ll explore how to move beyond the static @ExtendWith annotation and embrace the flexibility of programmatic extension registration. What is @RegisterExtension? In JUnit 5, extensions allow you to hook into the test lifecycle (before all, before each, after each, etc.). While @ExtendWith is the standard way to register these extensions declaratively, @RegisterExtension allows you to register them programmatically via fields in your test class. Why use @RegisterExtension over @ExtendWith? The primary advantage is initialization flexibility. Because you are declaring the extension as a field, you can:

1 min read
Ankur in JUnit

JUnit @ExtendWith Explained (JUnit 5 and 6): Write Your First Extension

What JUnit @ExtendWith does, where it goes (class, method, parameter), how it differs from @RegisterExtension and ServiceLoader, the order extensions run in, and what changed in JUnit 6. Write a timing extension, a ParameterResolver and an exception handler, all run on JUnit 6.1.3 and 5.14.4.

1 min read
Ankur in JUnit

Mastering JUnit 5 @TestTemplate: The Ultimate Guide for Reusable Testing

Have you ever duplicated an entire test class just to run it once with H2, once with PostgreSQL, and once with a mock? Copy–paste works—until it doesn’t. Maintenance explodes, and your original test intent gets buried under a mountain of boilerplate. Testing is the backbone of high-quality software, but as our codebases grow, so does the redundancy in our test suites. While @ParameterizedTest is the go-to for data-driven testing, JUnit 5 offers a more powerful, architectural tool for these scenarios: @TestTemplate. In this guide, we’ll dive deep into how to use @TestTemplate to build flexible, reusable test logic that scales with your application. What is JUnit 5 @TestTemplate? At its core, @TestTemplate is not a test case itself. Instead, it is a blueprint or a container for dynamic test execution. Unlike a standard @Test which runs once, a @TestTemplate is designed to be invoked multiple times based on a set of Invocation Contexts provided by a registered provider. Think of it as a skeleton that gets "fleshed out" by different configurations at runtime.

1 min read
Ankur in JUnit

Mastering JUnit 5 @TestFactory: Dynamic Testing Beyond Parameterized Tests

In the world of Java unit testing, we are mostly accustomed to the standard @Test annotation. These are static tests—their structure and logic are set in stone the moment you compile your code. But anyone who has tried to test rule engines, data migrations, or complex validation pipelines knows the pain: either you duplicate dozens of nearly identical tests or force-fit everything into a parameterized test that eventually becomes unreadable. What if you need to generate hundreds of test cases based on a JSON file, a database result set, or complex runtime logic? Enter Dynamic Testing with JUnit 5. In this comprehensive guide, we’ll explore the @TestFactory annotation, how it differs from traditional testing models, and how to leverage it to make your test suites more flexible, maintainable, and powerful. What is a Dynamic Test? Standard JUnit tests are "fixed." When you write a method annotated with @Test, JUnit knows exactly how many tests exist before the execution starts. A DynamicTest, however, is a test generated during runtime by a factory method. Think of it as the difference between a static HTML page and a React application. One is hardcoded; the other builds its UI based on the data it receives. Dynamic tests allow you to programmatically create a series of tests based on a data source, a list of objects, or even a continuous stream of events.

2 min read
Ankur in JUnit

JUnit 5 with Gradle & Maven: From Setup to Professional Testing

In the modern Java ecosystem, developer productivity is often measured by the speed and reliability of the feedback loop. As a Java developer, two tools you’ll inevitably encounter are Gradle (or Maven) for building your projects and JUnit for testing them. JUnit 5, the latest generation of this popular testing framework, isn't just an incremental update; it’s a complete modular overhaul designed to support modern Java features (like Lambdas) and provide a more robust extension model. Integrating it into your build lifecycle is a fundamental skill. This guide will walk you through the architecture, configuration, and execution of JUnit 5 tests, ensuring your setup is optimized for high-performance development. ⚡ Quick Start: TL;DR Setup If you’re in a hurry or just need a quick reference, here are the essential steps for your build files: Gradle (Groovy) Add Dependencies: junit-jupiter-api (compile) and junit-jupiter-engine (runtime). Enable Platform: Add useJUnitPlatform() inside the test { ... } block. Maven Add Dependency: Include the junit-jupiter aggregator artifact. Plugin Check: Ensure maven-surefire-plugin is version 2.22.0 or higher. A Deep Dive into the JUnit 5 Architecture To configure your build tool correctly, you must first understand that JUnit 5 is a modular framework composed of three main sub-projects. Unlike JUnit 4, which was a monolithic library, JUnit 5 separates concerns to allow for better integration with IDEs and build tools. 1. JUnit Platform This is the core foundation. It defines the TestEngine API, which tools like IntelliJ IDEA, Gradle, and Maven use to discover and launch tests.

2 min read
Ankur in JUnit

The Complete Guide to JUnit 5 @ParameterizedTest: Write Smarter, Faster, and Cleaner Java Tests

Every official way to feed a @ParameterizedTest, built and run against a real JUnit 6.1.3 module: @ValueSource through @ArgumentsSource, how display names actually compile to a MessageFormat pattern, two real anti-patterns caught failing on purpose, and three genuine bugs found by rebuilding this guide's original examples from scratch instead of copying them forward.

2 min read
Ankur in Java

Organising and Displaying JUnit Tests: @DisplayName, @Nested, @Tag (JUnit 5 → JUnit 6)

A beginner-first, fully verified guide to @DisplayName, DisplayNameGenerator, @Nested, and @Tag in JUnit — every code example and console transcript comes from a real Maven module built and run against JUnit 6.1.3, the current GA release verified against Maven Central. Covers what changed for these three annotations between JUnit 5 and JUnit 6, including a real behaviour change (deterministic @Nested ordering) that most migration guides mention only in passing.

2 min read
Ankur in JUnit

JUnit Conditional Test Execution (JUnit 5 → 6)

Run tests only where they belong. Every conditional-execution example from my 2025 article, re-run on JUnit 6.1.3 and JDK 25 with the real skip reasons, what changed from JUnit 5, and where the old text was wrong.

2 min read