Support arbitrary Java versions with JRE conditions

This commit introduces support for arbitrary Java versions in the JRE
enum, @⁠EnabledOnJre, @⁠DisabledOnJre, @⁠EnabledForJreRange, and
@⁠DisabledForJreRange.

Closes: junit-team#3930
Closes: junit-team#3931

documentation/src/test/java/example/ConditionalTestExecutionDemo.java

@@ -12,6 +12,8 @@
 
 import static org.junit.jupiter.api.condition.JRE.JAVA_10;
 import static org.junit.jupiter.api.condition.JRE.JAVA_11;
+import static org.junit.jupiter.api.condition.JRE.JAVA_17;
+import static org.junit.jupiter.api.condition.JRE.JAVA_18;
 import static org.junit.jupiter.api.condition.JRE.JAVA_8;
 import static org.junit.jupiter.api.condition.JRE.JAVA_9;
 import static org.junit.jupiter.api.condition.OS.LINUX;
@@ -23,6 +25,7 @@
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.condition.DisabledForJreRange;
 import org.junit.jupiter.api.condition.DisabledIf;
@@ -38,6 +41,7 @@
 import org.junit.jupiter.api.condition.EnabledInNativeImage;
 import org.junit.jupiter.api.condition.EnabledOnJre;
 import org.junit.jupiter.api.condition.EnabledOnOs;
+import org.junit.jupiter.api.condition.JRE;
 
 class ConditionalTestExecutionDemo {
 
@@ -99,6 +103,16 @@ void notOnNewMacs() {
 	}
 	// end::user_guide_architecture[]
 
+	@Test
+	@EnabledOnJre(value = { JAVA_17, JAVA_18 }, versions = { 20, 21 })
+	void onJava17or18or20or21() {
+	}
+
+	@Test
+	@EnabledOnJre(versions = 21)
+	void onlyOnJava21() {
+	}
+
 	// tag::user_guide_jre[]
 	@Test
 	@EnabledOnJre(JAVA_8)
@@ -124,6 +138,45 @@ void fromJava9toCurrentJavaFeatureNumber() {
 		// ...
 	}
 
+	@Test
+	@EnabledForJreRange(minVersion = 10)
+	void fromJava10toCurrentJavaFeatureNumber() {
+		// ...
+	}
+
+	@Test
+	@EnabledForJreRange(minVersion = 25)
+	void fromJava25toCurrentJavaFeatureNumber() {
+		// ...
+	}
+
+	@Disabled("DEMO: intended to fail")
+	@Test
+	@EnabledForJreRange(minVersion = 99, max = JRE.JAVA_17)
+	void fromJava99toJava17() {
+		// ...
+	}
+
+	@Disabled("DEMO: intended to fail")
+	@Test
+	@EnabledForJreRange(min = JAVA_11, minVersion = 10)
+	void competingJreAndMinVersions() {
+		// ...
+	}
+
+	@Disabled("DEMO: intended to fail")
+	@Test
+	@EnabledForJreRange(max = JAVA_11, maxVersion = 10)
+	void competingJreAndMaxVersions() {
+		// ...
+	}
+
+	@Test
+	@EnabledForJreRange(minVersion = 10, maxVersion = 25)
+	void fromJava17to25() {
+		// ...
+	}
+
 	@Test
 	@EnabledForJreRange(max = JAVA_11)
 	void fromJava8To11() {

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

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2015-2025 the original author or authors.
+ *
+ * All rights reserved. This program and the accompanying materials are
+ * made available under the terms of the Eclipse Public License v2.0 which
+ * accompanies this distribution and is available at
+ *
+ * https://www.eclipse.org/legal/epl-v20.html
+ */
+
+package org.junit.jupiter.api.condition;
+
+import java.lang.annotation.Annotation;
+import java.util.function.Function;
+
+import org.junit.platform.commons.util.Preconditions;
+
+/**
+ * Abstract base class for {@link EnabledOnJreCondition} and
+ * {@link DisabledOnJreCondition}.
+ *
+ * @since 5.12
+ */
+abstract class AbstractJreCondition<A extends Annotation> extends BooleanExecutionCondition<A> {
+
+	static final String ENABLED_ON_CURRENT_JRE = //
+		"Enabled on JRE version: " + System.getProperty("java.version");
+
+	static final String DISABLED_ON_CURRENT_JRE = //
+		"Disabled on JRE version: " + System.getProperty("java.version");
+
+	private final String annotationName;
+
+	AbstractJreCondition(Class<A> annotationType, Function<A, String> customDisabledReason) {
+		super(annotationType, ENABLED_ON_CURRENT_JRE, DISABLED_ON_CURRENT_JRE, customDisabledReason);
+		this.annotationName = annotationType.getSimpleName();
+	}
+
+	protected void validateVersions(JRE[] jres, int[] versions) {
+		Preconditions.condition(jres.length > 0 || versions.length > 0,
+			() -> "You must declare at least one JRE or version in @" + this.annotationName);
+		for (JRE jre : jres) {
+			Preconditions.condition(jre != JRE.UNDEFINED,
+				() -> "JRE.UNDEFINED is not supported in @" + this.annotationName);
+		}
+		for (int version : versions) {
+			Preconditions.condition(version >= 8,
+				() -> String.format("Version [%d] in @%s must be greater than or equal to 8", version,
+					this.annotationName));
+		}
+	}
+
+}

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

@@ -23,31 +23,32 @@
 
 abstract class BooleanExecutionCondition<A extends Annotation> implements ExecutionCondition {
 
-	private final Class<A> annotationType;
+	protected final Class<A> annotationType;
 	private final String enabledReason;
 	private final String disabledReason;
 	private final Function<A, String> customDisabledReason;
 
 	BooleanExecutionCondition(Class<A> annotationType, String enabledReason, String disabledReason,
 			Function<A, String> customDisabledReason) {
+
 		this.annotationType = annotationType;
 		this.enabledReason = enabledReason;
 		this.disabledReason = disabledReason;
 		this.customDisabledReason = customDisabledReason;
 	}
 
-	abstract boolean isEnabled(A annotation);
-
 	@Override
 	public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
-		return findAnnotation(context.getElement(), annotationType) //
-				.map(annotation -> isEnabled(annotation) ? enabled(enabledReason)
-						: disabled(disabledReason, customDisabledReason.apply(annotation))) //
+		return findAnnotation(context.getElement(), this.annotationType) //
+				.map(annotation -> isEnabled(annotation) ? enabled(this.enabledReason)
+						: disabled(this.disabledReason, this.customDisabledReason.apply(annotation))) //
 				.orElseGet(this::enabledByDefault);
 	}
 
+	abstract boolean isEnabled(A annotation);
+
 	private ConditionEvaluationResult enabledByDefault() {
-		String reason = String.format("@%s is not present", annotationType.getSimpleName());
+		String reason = String.format("@%s is not present", this.annotationType.getSimpleName());
 		return enabled(reason);
 	}
 

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

@@ -10,6 +10,7 @@
 
 package org.junit.jupiter.api.condition;
 
+import static org.apiguardian.api.API.Status.EXPERIMENTAL;
 import static org.apiguardian.api.API.Status.STABLE;
 
 import java.lang.annotation.Documented;
@@ -24,7 +25,10 @@
 /**
  * {@code @DisabledForJreRange} is used to signal that the annotated test class
  * or test method is <em>disabled</em> for a specific range of Java Runtime
- * Environment (JRE) versions from {@link #min} to {@link #max}.
+ * Environment (JRE) versions.
+ *
+ * <p>Version ranges can be specified as {@link JRE} enum constants via {@link #min}
+ * and {@link #max} or as integers via {@link #minVersion} and {@link #maxVersion}.
  *
  * <p>When applied at the class level, all test methods within that class will
  * be disabled on the same specified JRE versions.
@@ -82,28 +86,74 @@
 public @interface DisabledForJreRange {
 
 	/**
-	 * Java Runtime Environment version which is used as the lower boundary
-	 * for the version range that determines if the annotated class or method
-	 * should be disabled.
+	 * Java Runtime Environment version which is used as the lower boundary for
+	 * the version range that determines if the annotated class or method should
+	 * be disabled, specified as a {@link JRE} enum constant.
+	 *
+	 * <p>If a {@code JRE} enum constant does not exist for a particular JRE
+	 * version, you can specify the minimum version via {@link #minVersion()}
+	 * instead.
 	 *
-	 * <p>Defaults to {@link JRE#JAVA_8 JAVA_8}, as this is the lowest
-	 * supported JRE version.
+	 * <p>Defaults to {@link JRE#UNDEFINED UNDEFINED}, which will be interpreted
+	 * as {@link JRE#JAVA_8 JAVA_8} if the {@link #minVersion()} is not set.
 	 *
 	 * @see JRE
+	 * @see #minVersion()
 	 */
-	JRE min() default JRE.JAVA_8;
+	JRE min() default JRE.UNDEFINED;
 
 	/**
-	 * Java Runtime Environment version which is used as the upper boundary
-	 * for the version range that determines if the annotated class or method
-	 * should be disabled.
+	 * Java Runtime Environment version which is used as the upper boundary for
+	 * the version range that determines if the annotated class or method should
+	 * be disabled, specified as a {@link JRE} enum constant.
 	 *
-	 * <p>Defaults to {@link JRE#OTHER OTHER}, as this will always be the highest
-	 * possible version.
+	 * <p>If a {@code JRE} enum constant does not exist for a particular JRE
+	 * version, you can specify the maximum version via {@link #maxVersion()}
+	 * instead.
+	 *
+	 * <p>Defaults to {@link JRE#UNDEFINED UNDEFINED}, which will be interpreted
+	 * as {@link JRE#OTHER OTHER} if the {@link #maxVersion()} is not set.
 	 *
 	 * @see JRE
+	 * @see #maxVersion()
+	 */
+	JRE max() default JRE.UNDEFINED;
+
+	/**
+	 * Java Runtime Environment version which is used as the lower boundary for
+	 * the version range that determines if the annotated class or method should
+	 * be disabled, specified as an integer.
+	 *
+	 * <p>If a {@code JRE} enum constant exists for the particular JRE version,
+	 * you can specify the minimum version via {@link #min()} instead.
+	 *
+	 * <p>Defaults to {@code -1} to signal that {@link #min()} should be used instead.
+	 *
+	 * @since 5.12
+	 * @see #min()
+	 * @see JRE#featureVersion()
+	 * @see Runtime.Version#feature()
+	 */
+	@API(status = EXPERIMENTAL, since = "5.12")
+	int minVersion() default -1;
+
+	/**
+	 * Java Runtime Environment version which is used as the upper boundary for
+	 * the version range that determines if the annotated class or method should
+	 * be disabled, specified as an integer.
+	 *
+	 * <p>If a {@code JRE} enum constant exists for the particular JRE version,
+	 * you can specify the maximum version via {@link #max()} instead.
+	 *
+	 * <p>Defaults to {@code -1} to signal that {@link #max()} should be used instead.
+	 *
+	 * @since 5.12
+	 * @see #max()
+	 * @see JRE#featureVersion()
+	 * @see Runtime.Version#feature()
 	 */
-	JRE max() default JRE.OTHER;
+	@API(status = EXPERIMENTAL, since = "5.12")
+	int maxVersion() default -1;
 
 	/**
 	 * Custom reason to provide if the test or container is disabled.

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

@@ -10,11 +10,10 @@
 
 package org.junit.jupiter.api.condition;
 
-import static org.junit.jupiter.api.condition.EnabledOnJreCondition.DISABLED_ON_CURRENT_JRE;
-import static org.junit.jupiter.api.condition.EnabledOnJreCondition.ENABLED_ON_CURRENT_JRE;
+import static org.junit.jupiter.api.condition.AbstractJreCondition.DISABLED_ON_CURRENT_JRE;
+import static org.junit.jupiter.api.condition.AbstractJreCondition.ENABLED_ON_CURRENT_JRE;
 
 import org.junit.jupiter.api.extension.ExecutionCondition;
-import org.junit.platform.commons.util.Preconditions;
 
 /**
  * {@link ExecutionCondition} for {@link DisabledForJreRange @DisabledForJreRange}.
@@ -31,15 +30,8 @@ class DisabledForJreRangeCondition extends BooleanExecutionCondition<DisabledFor
 
 	@Override
 	boolean isEnabled(DisabledForJreRange annotation) {
-		JRE min = annotation.min();
-		JRE max = annotation.max();
-
-		Preconditions.condition((min != JRE.JAVA_8 || max != JRE.OTHER),
-			"You must declare a non-default value for min or max in @DisabledForJreRange");
-		Preconditions.condition(max.compareTo(min) >= 0,
-			"@DisabledForJreRange.min must be less than or equal to @DisabledForJreRange.max");
-
-		return !JRE.isCurrentVersionWithinRange(min, max);
+		return !EnabledForJreRangeCondition.isCurrentVersionWithinRange("DisabledForJreRange", annotation.min(),
+			annotation.max(), annotation.minVersion(), annotation.maxVersion());
 	}
 
 }

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

@@ -10,6 +10,7 @@
 
 package org.junit.jupiter.api.condition;
 
+import static org.apiguardian.api.API.Status.EXPERIMENTAL;
 import static org.apiguardian.api.API.Status.STABLE;
 
 import java.lang.annotation.Documented;
@@ -24,7 +25,10 @@
 /**
  * {@code @DisabledOnJre} is used to signal that the annotated test class or
  * test method is <em>disabled</em> on one or more specified Java Runtime
- * Environment (JRE) {@linkplain #value versions}.
+ * Environment (JRE) versions.
+ *
+ * <p>Versions can be specified as {@link JRE} enum constants via {@link #value()}
+ * or as integers via {@link #versions()}.
  *
  * <p>When applied at the class level, all test methods within that class
  * will be disabled on the same specified JRE versions.
@@ -82,12 +86,31 @@
 public @interface DisabledOnJre {
 
 	/**
-	 * Java Runtime Environment versions on which the annotated class or
-	 * method should be disabled.
+	 * Java Runtime Environment versions on which the annotated class or method
+	 * should be disabled, specified as {@link JRE} enum constants.
+	 *
+	 * <p>If a {@code JRE} enum constant does not exist for a particular JRE
+	 * version, you can specify the version via {@link #versions()} instead.
 	 *
 	 * @see JRE
+	 * @see #versions()
+	 */
+	JRE[] value() default {};
+
+	/**
+	 * Java Runtime Environment versions on which the annotated class or method
+	 * should be disabled, specified as integers.
+	 *
+	 * <p>If a {@code JRE} enum constant exists for a particular JRE version, you
+	 * can specify the version via {@link #value()} instead.
+	 *
+	 * @since 5.12
+	 * @see #value()
+	 * @see JRE#featureVersion()
+	 * @see Runtime.Version#feature()
 	 */
-	JRE[] value();
+	@API(status = EXPERIMENTAL, since = "5.12")
+	int[] versions() default {};
 
 	/**
 	 * Custom reason to provide if the test or container is disabled.