JUnit 5 Release Notes

When configured with --details verbose, the ConsoleLauncher no longer throws a MissingFormatArgumentException if a test method display name contains String format specifiers such as %c.

Assertions.assertAll() is now thread-safe — for example, it can now be used with a parallel Stream.

The OS.SOLARIS enum constant used with @EnabledOnOs and @DisabledOnOs is now also detected as the current operating system if the os.name JVM system property contains "SunOs".

Assertions.assertLinesMatch() no longer throws a NullPointerException after evaluating a fast-forward match if there are more expected lines after the fast-forward match than remain in the actual results. This bug only manifested itself if the expected list size was equal to or greater than the actual list size.

Multidimensional arrays may now be supplied to @ParameterizedTest methods from factory methods configured via @MethodSource.

Threads created for running tests in parallel now use the same thread context class loader (TCCL) that was set when creating the underlying executor service. This resolves ClassNotFoundException issues that only occur in parallel execution mode when a custom TCCL is in place.

When executing tests in parallel, lifecycle methods and callbacks called after a @TestFactory method are now always executed after the dynamic tests returned by the method.

Exceptions thrown during initialization of static @RegisterExtension fields now cause the test class to fail instead of being silently swallowed.

An OutOfMemoryError regression introduced in JUnit 5.3.0 has been fixed.

The OpenTest4J dependency has been updated to 1.1.1 to fix a serialization incompatibility between 1.0.0 and 1.1.0 that caused failure messages to be discarded when used from Gradle and potentially other tools and IDEs.

Invocations of assertThrows() that are passed a method reference for an overloaded method with a void return type once again compile.

In order to revert the aforementioned breaking change, variants of assertThrows() introduced in JUnit 5.3.0 that accept ThrowingSupplier arguments have been removed.

The full stacktrace is now printed to the console when running the ConsoleLauncher in --details verbose mode.

ReflectionUtils.findNestedClasses() and ReflectionSupport.findNestedClasses() no longer allow a NoClassDefFoundError to propagate if a nested class or nested interface has an invalid class file. Instead, the error will now be swallowed and logged at WARNING level.

All DiscoverySelector implementations (e.g., PackageSelector, ClassSelector, MethodSelector, etc.) now implement equals() and hashCode() for proper behavior when stored in collections.

ClassSource has been revised so that equals() and hashCode() are now properly based on the required class name instead of the optional Class reference. In addition, the non-blank precondition for a class name is now enforced.

The junit-platform-gradle-plugin has been discontinued and is no longer released as part of JUnit 5. Please use Gradle’s native support for running tests on the JUnit Platform (requires Gradle 4.6 or higher) instead.

The JUnit Platform Surefire Provider (junit-platform-surefire-provider) is now deprecated in favor of the native support for the JUnit Platform provided by Maven Surefire 2.22.0 and later versions.

The JUnit Platform Launcher now enforces that only TestEngine implementations published by the JUnit Team may use the junit- prefix for their TestEngine IDs.

The findAnnotation() methods in AnnotationSupport and AnnotationUtils no longer cache annotation lookups. Note, however, that the algorithm remains otherwise unmodified and is therefore semantically identical to the previous behavior.

Reusable support for parallel test execution for test engines that extend HierarchicalTestEngine.

Experimental support for capturing output printed to System.out and System.err during test execution.

New UriSource.from(URI) static factory method that allows a TestSource to be created from a URI. If the URI references a file or directory in the local filesystem, a FileSource or DirectorySource will be created; otherwise, an instance of the default UriSource implementation will be created.

New MethodSource.from(Class, Method) static factory method for creating a MethodSource from a specific class and method. This method should be used in favor of MethodSource.from(Method) when the test method is inherited from a superclass or present as an interface default method.

A ClasspathResourceSource can now be created from a URI via the new from(URI) static factory method if the URI uses the classpath scheme.

New overloaded variant of isAnnotated() in AnnotationSupport that accepts Optional<? extends AnnotatedElement> instead of AnnotatedElement.

New LauncherConfig and associated builder for configuring the LauncherFactory. Specifically, auto-registration of test engines and test execution listeners can now be disabled, and additional engines and listeners can be registered programmatically.

New --fail-if-no-tests command-line option for the ConsoleLauncher.

The ConsoleLauncher now uses the picocli library under the hood to parse the command line and generate usage help.

When using @TestInstance(Lifecycle.PER_CLASS) semantics, registered AfterAllCallback extensions are no longer invoked if an exception is thrown by the test class constructor. Consequently, AfterAllCallback extensions are now only invoked if BeforeAllCallback extensions are invoked.

Exceptions thrown in @After and @AfterAll lifecycle methods now take precedence over violated assumptions (i.e. TestAbortedExceptions) in test or prior lifecycle methods.

The MethodSource for an inherited @Test method now correctly references the current test class instead of the class or interface in which the @Test method is declared. This allows build tools such as Maven Surefire to properly include inherited @Test methods when executing a single test class or specific test classes based on filters — for example, via mvn test -Dtest=SubclassTests).

Test discovery no longer halts prematurely if a nested class or nested interface in a test class has an invalid class file.

Certain categories of errors encountered during the test discovery phase no longer cause JUnit Jupiter to prematurely abort the entire discovery process.

The junit-jupiter-params JAR file was missing the required Kotlin metadata for the getAs<Class>(index) Kotlin extension method. The underlying packaging issue has been solved, and the extension method has been renamed to get<Class>(index) as originally intended in 5.3.0-M1.

TestInstanceFactory extensions are properly inherited within @Nested test class hierarchies.

@Nested test classes can no longer override TestInstanceFactory extensions registered on an enclosing class. This aligns with the behavior for TestInstanceFactory extensions registered within a conventional test class hierarchy.

Experimental support for parallel test execution. By default, tests are still executed sequentially, but parallelism can be enabled using a configuration parameter (please refer to the User Guide for examples and configuration options).

New assertThrows methods in Assertions provide a more specific failure message if the supplied lambda expression or method reference returns a result instead of throwing an exception.

Generation of a detailed failure message for a failed assertion no longer fails if the toString() implementation of an object supplied to the assertion throws an exception. Instead, the object with the broken toString() implementation will be referenced via a default String representation based on the object’s fully qualified class name and system hash code, separated by an @ symbol.

Although it is highly discouraged, it is now possible to extend the org.junit.jupiter.api.Assertions and org.junit.jupiter.api.Assumptions classes for special use cases.

New publishEntry(String) method in TestReporter that makes it easier to publish a report entry based solely on a value without requiring that a key be specified (as is required by the existing publishEntry() variants).

New support for the IBM AIX operating system in @EnabledOnOs and @DisabledOnOs.

The dynamic test API has been promoted from experimental to maintained status. This affects the @TestFactory annotation as well as the DynamicTest, DynamicContainer, and DynamicNode types in the org.junit.jupiter.api package.

New support for supplying a custom test source URI when creating a dynamic container or test.

New {displayName} placeholder for the name attribute in @ParameterizedTest that allows developers to include the display name of the @ParameterizedTest method in a custom display name for invocations of that parameterized test.

Generation of the display name for a @ParameterizedTest no longer fails if the toString() implementation of an argument for the parameterized test throws an exception. Instead, the object with the broken toString() implementation will be referenced via a default String representation based on the object’s fully qualified class name and system hash code, separated by an @ symbol.

Implicit argument conversion for parameterized tests can now convert strings such as "java.lang.Integer", "long", and "byte[]" to Class instances.

New arguments() static factory method in the Arguments interface that serves as an alias for Arguments.of(). arguments() is intended to be used via import static.

New get<Class>(index) Kotlin extension method to make ArgumentsAccessor friendlier to use from Kotlin.

ArgumentConverters and ArgumentsAggregators registered using @ConvertWith and @AggregateWith, respectively, are now only instantiated once per @ParameterizedTest instead of once for each invocation.

Performance improvements for executing parameterized tests, particularly when the method declares more than a few parameters.

New TestInstanceFactory extension API that enables custom creation of test class instances.

The MethodSource for an inherited @Test method now correctly references the current test class instead of the class or interface in which the @Test method is declared. This allows build tools such as Maven Surefire to properly include inherited @Test methods when executing a single test class or specific test classes based on filters — for example, via mvn test -Dtest=SubclassTests).

The VintageTestEngine now uses the simple name of a test class as the display name instead of the fully qualified class name. This aligns with the behavior of the JupiterTestEngine.