JUnit 5 Release Notes

New findAllClassesInModule() method in ReflectionSupport which enables third-party TestEngine implementations to scan for classes in modules — for example, when processing a ModuleSelector during the discovery phase.

The ParameterContext API used in ParameterResolver implementations now includes the following convenience methods for looking up annotations on parameters. Extension authors are strongly encouraged to use these methods instead of those provided in the core java.lang.reflect.Parameter API due to a bug in javac on JDK versions prior to JDK 9 which causes lookups for annotations on parameters in inner class constructors to fail consistently — for example, when resolving a parameter for a @Nested test class constructor.

Test methods selected by fully qualified method name via DiscoverySelectors.selectMethod(String), via the method or methods element of the selectors configuration for the junitPlatform Gradle plugin, or via the -select-method or -m command-line options for the ConsoleLauncher can now contain special characters — for example, for JVM languages such as Kotlin and Groovy.

Test classes selected via one of the selectClass() variants in DiscoverySelectors, via the aClass or classes element of the selectors configuration for the junitPlatform Gradle plugin, or via the -select-class or -c command-line options for the ConsoleLauncher are no longer allowed to be private. This aligns with the behavior for test classes discovered via package, class path, and module path scanning.

Null elements specified in the last column after the first row via @CsvSource for parameterized tests are now correctly converted to null instead of the empty String.

When using a tag filter to include/exclude a tag that represents a JUnit 4 category, e.g. "com.example.Integration", the Vintage Engine no longer mistakenly executes all test methods of test classes that contain at least one included test method, e.g. one that is annotated with @Category(com.example.Integration.class), regardless whether they belong to the same category.

The VintageTestEngine supports the new JUnit Platform ModuleSelector for selecting Java 9 modules.

Prior to this release, the Vintage test engine only returned a childless TestDescriptor for test classes annotated with @Ignore. However, build tools like Gradle need to show an accurate number of tests, i.e. they want to access and count the test methods of a test class regardless whether it’s ignored. The Jupiter engine already discovers skipped containers, e.g. test classes annotated with @Disabled, including their children and descendants. The Vintage engine now adopts this approach and returns a full subtree of TestDescriptors for classes annotated with @Ignore. During execution, it will only report the TestDescriptor of the test class as skipped which is consistent with how the Jupiter engine reports skipped containers.

Summary table is no longer printed via the ConsoleLauncher and Gradle plugin when details mode NONE is selected, unless there are errors.

The XML report produced by the ConsoleLauncher and Gradle plugin is no longer invalid when the exception message of a failed test contains the XML CDATA end marker ]]>.

The ConsoleLauncher, the Gradle plugin, and the Maven Surefire provider now attempt to write a valid class name into the classname attribute of <testcase/> elements in the XML reports. In addition, the name attribute of dynamic tests and test template invocations (such as repeated and parameterized tests) is now suffixed with the index of the invocation so they are distinguishable by reporting tools.

The Maven Surefire provider now includes the method parameter types when writing the name attribute of <testcase/> elements into XML reports. However, due to a limitation of Maven Surefire, instead of methodName(Type) they are written as methodName{Type}.

Non-inherited composed annotations which are meta-annotated with a given @Inherited annotation are now considered to be implicitly inherited when searching for the given meta-annotation within a class hierarchy.

The JUnit Platform Maven Surefire provider now runs all specified tests in a single test run, i.e. all registered TestExecutionListeners will receive a single TestPlan. Previously, a separate TestPlan was discovered and executed for each test class.

New SUMMARY details mode for the ConsoleLauncher and Gradle plugin which prints the table of success and failure counts at the end of test plan execution. This new mode is analogous to the previous behavior of the NONE details mode.

The Maven Surefire provider now supports the test parameter that tells Surefire to only execute a subset of test classes or methods, e.g. by specifying -Dtest=…​ on the command line (see the Surefire documentation for details).

The @Tag and @Tags annotations are now inherited within test class hierarchies.

Due to a change in the JUnit Platform’s AnnotationUtils class, non-inherited composed annotations which are meta-annotated with a given @Inherited annotation are now considered to be implicitly inherited when searching for the given meta-annotation within a class hierarchy.

Failed tests are now reported correctly with Maven Surefire for test engines that do not use MethodSource (e.g. Spek).

Tests that write to System.out or System.err, in particular via a logging framework, are now consistently reported correctly when executed with a non-zero forkCount with Maven Surefire.

The JUnit Platform Maven Surefire provider now supports the redirectTestOutputToFile Surefire feature.

The JUnit Platform Maven Surefire provider now ignores empty strings supplied via <includeTags/>, <groups/>, <excludeTags/>, and <excludedGroups/>.

Trailing spaces in a @CsvSource or @CsvFileSource input line no longer yield null values.

@EnableRuleMigrationSupport previously failed to recognize @Rule methods that returned a subtype of one of the supported TestRule types. Moreover, it mistakenly instantiated some rules declared using methods multiple times. Now, once enabled, it will instantiate all declared rules (fields and methods) exactly once and call them in the same order used by JUnit 4.

Previously, disabled test classes were eagerly instantiated when Lifecycle.PER_CLASS was used. Now, ExecutionCondition evaluation always takes place before test class instantiation.

The junit-jupiter-migrationsupport module no longer incorrectly attempts to register the JupiterTestEngine via the ServiceLoader mechanism, thereby allowing it to be used as a module on the Java 9 module-path.

Failure messages for assertTrue() and assertFalse() in the Assertions class now include details about the expected and actual boolean values.

If a parameterized test does not consume all arguments supplied to it via argument sources, the unconsumed arguments are no longer included in the display name.

ExpectedExceptionSupport from the junit-jupiter-migrationsupport module no longer swallows exceptions if the test class does not declare a JUnit 4 ExpectedException rule.

PackageNameFilters are now applied to tests selected via a ClassSelector, MethodSelector or UniqueIdSelector.