Stop mentioning "old" JUnit versions in Javadoc and User Guide

Closes #4878

Author: sbrannen

documentation/src/docs/asciidoc/user-guide/api-evolution.adoc

@@ -31,7 +31,7 @@ following values.
                      incompatible way for *at least* the next minor release of the current
                      major version. If scheduled for removal, it will be demoted to `DEPRECATED` first.
 | `STABLE`         | Intended for features that will not be changed in a backwards-
-                     incompatible way in the current major version (`5.*`).
+                     incompatible way in the current major version (`6.*`).
 |===
 
 If the `@API` annotation is present on a type, it is considered to be applicable for all

documentation/src/docs/asciidoc/user-guide/appendix.adoc

@@ -4,8 +4,7 @@
 [[reproducible-builds]]
 === Reproducible Builds
 
-Starting with version 5.7, JUnit aims for its non-javadoc JARs to be
-https://reproducible-builds.org/[reproducible].
+JUnit aims for its non-javadoc JARs to be https://reproducible-builds.org/[reproducible].
 
 Under identical build conditions, such as Java version, repeated builds should provide the
 same output byte-for-byte.

documentation/src/docs/asciidoc/user-guide/extensions.adoc

@@ -25,9 +25,9 @@ Java's <<extensions-registration-automatic,`ServiceLoader`>> mechanism.
 Developers can register one or more extensions _declaratively_ by annotating a test
 interface, test class, test method, or custom _<<writing-tests-meta-annotations,composed
 annotation>>_ with `@ExtendWith(...)` and supplying class references for the extensions to
-register. As of JUnit Jupiter 5.8, `@ExtendWith` may also be declared on fields or on
-parameters in test class constructors, in test methods, and in `@BeforeAll`, `@AfterAll`,
-`@BeforeEach`, and `@AfterEach` lifecycle methods.
+register. `@ExtendWith` may also be declared on fields or on parameters in test class
+constructors, in test methods, and in `@BeforeAll`, `@AfterAll`, `@BeforeEach`, and
+`@AfterEach` lifecycle methods.
 
 For example, to register a `WebServerExtension` for a particular test method, you would
 annotate the test method as follows. We assume the `WebServerExtension` starts a local web
@@ -864,15 +864,20 @@ inner contexts may also be limited. Consult the corresponding Javadoc for detail
 methods available for storing and retrieving values via the `{ExtensionContext_Store}`.
 
 [[extensions-keeping-state-autocloseable-support]]
+[NOTE]
 .Resource management via `_AutoCloseable_`
-NOTE: An extension context store is bound to its extension context lifecycle. When an
-extension context lifecycle ends it closes its associated store. As of JUnit 5.13,
-all stored values that are instances of `AutoCloseable` are notified by an invocation of
+====
+An extension context store is bound to its extension context lifecycle. When an extension
+context lifecycle ends it closes its associated store.
+
+All stored values that are instances of `AutoCloseable` are notified by an invocation of
 their `close()` method in the inverse order they were added in (unless the
 `junit.jupiter.extensions.store.close.autocloseable.enabled`
-<<running-tests-config-params, configuration parameter>> is set to `false`). Older
-versions only supported `CloseableResource`, which is deprecated but still available for
-backward compatibility.
+<<running-tests-config-params, configuration parameter>> is set to `false`).
+
+Versions prior to 5.13 only supported `CloseableResource`, which is deprecated but still
+available for backward compatibility.
+====
 
 An example implementation of `AutoCloseable` is shown below, using an `HttpServer`
 resource.
@@ -905,10 +910,9 @@ include::{testDir}/example/HttpServerDemo.java[tags=user_guide]
 [TIP]
 .Migration Note for Resource Cleanup
 ====
-
-Starting with JUnit Jupiter 5.13, the framework automatically closes resources stored in
-the `ExtensionContext.Store` that implement `AutoCloseable`. In earlier versions, only
-resources implementing `Store.CloseableResource` were automatically closed.
+The framework automatically closes resources stored in the `ExtensionContext.Store` that
+implement `AutoCloseable`. In versions prior to 5.13, only resources implementing
+`Store.CloseableResource` were automatically closed.
 
 If you're developing an extension that needs to support both JUnit Jupiter 5.13+ and
 earlier versions and your extension stores resources that need to be cleaned up, you

documentation/src/docs/asciidoc/user-guide/migration-from-junit4.adoc

@@ -199,9 +199,9 @@ tests to JUnit Jupiter.
   - Note that you may continue to use assertion methods from `org.junit.Assert` or any
     other assertion library such as {AssertJ}, {Hamcrest}, {Truth}, etc.
 * Assumptions reside in `org.junit.jupiter.api.Assumptions`.
-  - Note that JUnit Jupiter 5.4 and later versions support methods from JUnit 4's
-    `org.junit.Assume` class for assumptions. Specifically, JUnit Jupiter supports JUnit
-    4's `AssumptionViolatedException` to signal that a test should be aborted instead of
+  - Note that JUnit Jupiter supports methods from JUnit 4's `org.junit.Assume` class for
+    assumptions. Specifically, JUnit Jupiter supports JUnit 4's
+    `AssumptionViolatedException` to signal that a test should be aborted instead of
     marked as a failure.
 * `@Before` and `@After` no longer exist; use `@BeforeEach` and `@AfterEach` instead.
 * `@BeforeClass` and `@AfterClass` no longer exist; use `@BeforeAll` and `@AfterAll`

documentation/src/docs/asciidoc/user-guide/overview.adoc

@@ -11,11 +11,10 @@ This document is also available as a link:{userGuidePdfFileName}[PDF download].
 endif::linkToPdf[]
 endif::backend-html5[]
 
-[[overview-what-is-junit-5]]
+[[overview-what-is-junit]]
 === What is JUnit?
 
-Unlike previous versions of JUnit, JUnit 5 and later is composed of several different
-modules from three different sub-projects.
+JUnit is composed of several different modules from three different sub-projects.
 
 **JUnit {version} = _JUnit Platform_ + _JUnit Jupiter_ + _JUnit Vintage_**
 

documentation/src/docs/asciidoc/user-guide/running-tests.adoc

@@ -559,7 +559,7 @@ the task and can serve as a starting point.
 ===== Basic Usage
 
 The following example demonstrates how to configure the `junitlauncher` task to select a
-single test class (i.e., `org.myapp.test.MyFirstJUnit5Test`).
+single test class (i.e., `com.example.project.CalculatorTests`).
 
 [source,xml,indent=0]
 ----
@@ -572,7 +572,7 @@ single test class (i.e., `org.myapp.test.MyFirstJUnit5Test`).
 
 	<junitlauncher>
 		<classpath refid="test.classpath" />
-		<test name="org.myapp.test.MyFirstJUnit5Test" />
+		<test name="com.example.project.CalculatorTests" />
 	</junitlauncher>
 ----
 

documentation/src/docs/asciidoc/user-guide/writing-tests.adoc

@@ -346,7 +346,7 @@ table lists the default display name generators available in Jupiter.
 |===
 | DisplayNameGenerator   | Behavior
 
-| `Standard`            | Matches the standard display name generation behavior in place since JUnit Jupiter 5.0 was released.
+| `Standard`            | Matches the standard display name generation behavior in place since JUnit Jupiter was introduced.
 | `Simple`              | Extends the functionality of `Standard` by removing trailing parentheses for methods with no parameters.
 | `ReplaceUnderscores`  | Replaces underscores with spaces.
 | `IndicativeSentences` | Generates complete sentences by concatenating the names of the test and the enclosing classes.
@@ -858,11 +858,12 @@ include::{testDir}/example/ConditionalTestExecutionDemo.java[tags=user_guide_jre
 
 Since the enum constants defined in {JRE} are static for any given JUnit release, you
 might find that you need to configure a Java version that is not supported by the `JRE`
-enum. For example, as of JUnit Jupiter 5.12 the `JRE` enum defines `JAVA_25` as the
-highest supported Java version. However, you may wish to run your tests against later
-versions of Java. To support such use cases, you can specify arbitrary Java versions via
-the `versions` attributes in `@EnabledOnJre` and `@DisabledOnJre` and via the `minVersion`
-and `maxVersion` attributes in `@EnabledForJreRange` and `@DisabledForJreRange`.
+enum. For example, when JUnit Jupiter 5.12 was released the `JRE` enum defined `JAVA_25`
+as the highest supported Java version. However, you may wish to run your tests against
+later versions of Java. To support such use cases, you can specify arbitrary Java versions
+via the `versions` attributes in `@EnabledOnJre` and `@DisabledOnJre` and via the
+`minVersion` and `maxVersion` attributes in `@EnabledForJreRange` and
+`@DisabledForJreRange`.
 
 The following listing demonstrates the use of these annotations with arbitrary Java
 versions.
@@ -902,10 +903,10 @@ include::{testDir}/example/ConditionalTestExecutionDemo.java[tags=user_guide_sys
 
 [TIP]
 ====
-As of JUnit Jupiter 5.6, `{EnabledIfSystemProperty}` and `{DisabledIfSystemProperty}` are
-_repeatable annotations_. Consequently, these annotations may be declared multiple times
-on a test interface, test class, or test method. Specifically, these annotations will be
-found if they are directly present, indirectly present, or meta-present on a given element.
+`{EnabledIfSystemProperty}` and `{DisabledIfSystemProperty}` are _repeatable annotations_.
+Consequently, these annotations may be declared multiple times on a test interface, test
+class, or test method. Specifically, these annotations will be found if they are directly
+present, indirectly present, or meta-present on a given element.
 ====
 
 [[writing-tests-conditional-execution-environment-variables]]
@@ -923,11 +924,10 @@ include::{testDir}/example/ConditionalTestExecutionDemo.java[tags=user_guide_env
 
 [TIP]
 ====
-As of JUnit Jupiter 5.6, `{EnabledIfEnvironmentVariable}` and
-`{DisabledIfEnvironmentVariable}` are _repeatable annotations_. Consequently, these
-annotations may be declared multiple times on a test interface, test class, or test
-method. Specifically, these annotations will be found if they are directly present,
-indirectly present, or meta-present on a given element.
+`{EnabledIfEnvironmentVariable}` and `{DisabledIfEnvironmentVariable}` are _repeatable
+annotations_. Consequently, these annotations may be declared multiple times on a test
+interface, test class, or test method. Specifically, these annotations will be found if
+they are directly present, indirectly present, or meta-present on a given element.
 ====
 
 [[writing-tests-conditional-execution-custom]]
@@ -1472,11 +1472,11 @@ void repeatedTest() {
 }
 ----
 
-Since JUnit Jupiter 5.10, `@RepeatedTest` can be configured with a failure threshold which
-signifies the number of failures after which remaining repetitions will be automatically
-skipped. Set the `failureThreshold` attribute to a positive number less than the total
-number of repetitions in order to skip the invocations of remaining repetitions after the
-specified number of failures has been encountered.
+`@RepeatedTest` can be configured with a failure threshold which signifies the number of
+failures after which remaining repetitions will be automatically skipped. Set the
+`failureThreshold` attribute to a positive number less than the total number of
+repetitions in order to skip the invocations of remaining repetitions after the specified
+number of failures has been encountered.
 
 For example, if you are using `@RepeatedTest` to repeatedly invoke a test that you suspect
 to be _flaky_, a single failure is sufficient to demonstrate that the test is flaky, and
@@ -3276,12 +3276,11 @@ This heuristic is queried by the `disabled_on_debug` mode.
 [[writing-tests-parallel-execution]]
 === Parallel Execution
 
-By default, JUnit Jupiter tests are run sequentially in a single thread. Running tests in
-parallel -- for example, to speed up execution -- is available as an opt-in feature since
-version 5.3. To enable parallel execution, set the
-`junit.jupiter.execution.parallel.enabled` configuration parameter to `true` -- for
-example, in `junit-platform.properties` (see <<running-tests-config-params>> for other
-options).
+By default, JUnit Jupiter tests are run sequentially in a single thread; however, running
+tests in parallel -- for example, to speed up execution -- is available as an opt-in
+feature. To enable parallel execution, set the `junit.jupiter.execution.parallel.enabled`
+configuration parameter to `true` -- for example, in `junit-platform.properties` (see
+<<running-tests-config-params>> for other options).
 
 Please note that enabling this property is only the first step required to execute tests
 in parallel. If enabled, test classes and methods will still be executed sequentially by

junit-jupiter-api/src/main/java/org/junit/jupiter/api/DisplayNameGenerator.java

@@ -16,6 +16,8 @@
 import static org.apiguardian.api.API.Status.INTERNAL;
 import static org.apiguardian.api.API.Status.MAINTAINED;
 import static org.apiguardian.api.API.Status.STABLE;
+import static org.junit.jupiter.api.DisplayNameGenerator.getDisplayNameGenerator;
+import static org.junit.jupiter.api.DisplayNameGenerator.parameterTypesAsString;
 import static org.junit.platform.commons.support.AnnotationSupport.findAnnotation;
 import static org.junit.platform.commons.support.ModifierSupport.isStatic;
 import static org.junit.platform.commons.util.KotlinReflectionUtils.getKotlinSuspendingFunctionParameterTypes;
@@ -209,7 +211,7 @@ static String parameterTypesAsString(Method method) {
 	 * Standard {@code DisplayNameGenerator}.
 	 *
 	 * <p>This implementation matches the standard display name generation
-	 * behavior in place since JUnit Jupiter 5.0 was released.
+	 * behavior in place since JUnit Jupiter was introduced.
 	 */
 	class Standard implements DisplayNameGenerator {
 

junit-jupiter-api/src/main/java/org/junit/jupiter/api/condition/DisabledIfEnvironmentVariable.java

@@ -51,12 +51,11 @@
  * custom <em>composed annotation</em> that inherits the semantics of this
  * annotation.
  *
- * <p>As of JUnit Jupiter 5.6, this annotation is a {@linkplain Repeatable
- * repeatable} annotation. Consequently, this annotation may be declared multiple
- * times on an {@link java.lang.reflect.AnnotatedElement AnnotatedElement} (i.e.,
- * test interface, test class, or test method). Specifically, this annotation will
- * be found if it is directly present, indirectly present, or meta-present on a
- * given element.
+ * <p>This annotation is a {@linkplain Repeatable repeatable} annotation and may
+ * be declared multiple times on an {@link java.lang.reflect.AnnotatedElement
+ * AnnotatedElement} such as a test interface, test class, or test method.
+ * Specifically, this annotation will be found if it is directly present,
+ * indirectly present, or meta-present on a given element.
  *
  * @since 5.1
  * @see org.junit.jupiter.api.condition.EnabledIf

junit-jupiter-api/src/main/java/org/junit/jupiter/api/condition/DisabledIfSystemProperty.java

@@ -51,12 +51,11 @@
  * custom <em>composed annotation</em> that inherits the semantics of this
  * annotation.
  *
- * <p>As of JUnit Jupiter 5.6, this annotation is a {@linkplain Repeatable
- * repeatable} annotation. Consequently, this annotation may be declared multiple
- * times on an {@link java.lang.reflect.AnnotatedElement AnnotatedElement} (i.e.,
- * test interface, test class, or test method). Specifically, this annotation will
- * be found if it is directly present, indirectly present, or meta-present on a
- * given element.
+ * <p>This annotation is a {@linkplain Repeatable repeatable} annotation and may
+ * be declared multiple times on an {@link java.lang.reflect.AnnotatedElement
+ * AnnotatedElement} such as a test interface, test class, or test method.
+ * Specifically, this annotation will be found if it is directly present,
+ * indirectly present, or meta-present on a given element.
  *
  * @since 5.1
  * @see org.junit.jupiter.api.condition.EnabledIf