Add declarative JRE gating for JUnit 4 tests

Introduces @EnabledForJreRange plus a small JreConditionRule so JUnit 4
tests can declare a JRE feature-version range at the method level,
mirroring the semantics of JUnit Jupiter's EnabledForJreRange. The rule
reads the annotation from the test description and throws
AssumptionViolatedException when the current JRE is outside the range,
so Surefire reports out-of-range methods as skipped.

Migrates VirtualThreadHelperTest off imperative Assume.assumeTrue /
Assume.assumeFalse calls: Java 21+ cases use @EnabledForJreRange(min=21),
the UnsupportedOperationException cases use @EnabledForJreRange(max=20).

Author: rzo1

container/openejb-core/src/test/java/org/apache/openejb/junit/jre/EnabledForJreRange.java

@@ -0,0 +1,37 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.openejb.junit.jre;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Enables a JUnit 4 test method only when the running JRE feature version falls in
+ * {@code [min, max]}. Mirrors {@code org.junit.jupiter.api.condition.EnabledForJreRange}
+ * for codebases that cannot depend on JUnit Jupiter. Tests outside the range are skipped
+ * via {@code Assume} semantics (surefire reports them as skipped).
+ *
+ * <p>Must be combined with {@link JreConditionRule} as a {@code @Rule}.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface EnabledForJreRange {
+    int min() default 0;
+    int max() default Integer.MAX_VALUE;
+}

container/openejb-core/src/test/java/org/apache/openejb/junit/jre/JreConditionRule.java

@@ -0,0 +1,52 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.openejb.junit.jre;
+
+import org.junit.AssumptionViolatedException;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+
+/**
+ * JUnit 4 rule that skips a test method when the running JRE feature version is
+ * outside the range declared by {@link EnabledForJreRange} on the method. Skipping is
+ * implemented by throwing {@link AssumptionViolatedException}, matching surefire's
+ * "skipped" category.
+ */
+public final class JreConditionRule implements TestRule {
+
+    @Override
+    public Statement apply(final Statement base, final Description description) {
+        final EnabledForJreRange range = description.getAnnotation(EnabledForJreRange.class);
+        if (range == null) {
+            return base;
+        }
+
+        final int current = Runtime.version().feature();
+        if (current < range.min() || current > range.max()) {
+            return new Statement() {
+                @Override
+                public void evaluate() {
+                    throw new AssumptionViolatedException(
+                            "Requires Java " + range.min() + ".." + range.max()
+                                    + ", running on " + current);
+                }
+            };
+        }
+        return base;
+    }
+}

container/openejb-core/src/test/java/org/apache/openejb/threads/impl/VirtualThreadHelperTest.java

@@ -16,7 +16,9 @@
  */
 package org.apache.openejb.threads.impl;
 
-import org.junit.Assume;
+import org.apache.openejb.junit.jre.EnabledForJreRange;
+import org.apache.openejb.junit.jre.JreConditionRule;
+import org.junit.Rule;
 import org.junit.Test;
 
 import java.util.concurrent.CountDownLatch;
@@ -31,18 +33,12 @@
 
 public class VirtualThreadHelperTest {
 
-    @Test
-    public void isSupportedReturnsConsistentValue() {
-        // Just verify it doesn't throw — result depends on JVM version
-        final boolean supported = VirtualThreadHelper.isSupported();
-        // On Java 21+ should be true, on 17 false
-        assertNotNull("isSupported should return a value", Boolean.valueOf(supported));
-    }
+    @Rule
+    public final JreConditionRule jreCondition = new JreConditionRule();
 
     @Test
+    @EnabledForJreRange(min = 21)
     public void newVirtualThreadCreatesThread() {
-        Assume.assumeTrue("Virtual threads require Java 21+", VirtualThreadHelper.isSupported());
-
         final CountDownLatch latch = new CountDownLatch(1);
         final Thread thread = VirtualThreadHelper.newVirtualThread("test-vt-", 1, latch::countDown);
 
@@ -59,9 +55,8 @@ public void newVirtualThreadCreatesThread() {
     }
 
     @Test
+    @EnabledForJreRange(min = 21)
     public void newVirtualThreadFactoryCreatesThreads() {
-        Assume.assumeTrue("Virtual threads require Java 21+", VirtualThreadHelper.isSupported());
-
         final ThreadFactory factory = VirtualThreadHelper.newVirtualThreadFactory("test-vtf-");
         assertNotNull(factory);
 
@@ -79,9 +74,8 @@ public void newVirtualThreadFactoryCreatesThreads() {
     }
 
     @Test
+    @EnabledForJreRange(min = 21)
     public void newVirtualThreadPerTaskExecutorWorks() {
-        Assume.assumeTrue("Virtual threads require Java 21+", VirtualThreadHelper.isSupported());
-
         final ThreadFactory factory = VirtualThreadHelper.newVirtualThreadFactory("test-vtpe-");
         final ExecutorService executor = VirtualThreadHelper.newVirtualThreadPerTaskExecutor(factory);
         assertNotNull(executor);
@@ -102,16 +96,14 @@ public void newVirtualThreadPerTaskExecutorWorks() {
     }
 
     @Test(expected = UnsupportedOperationException.class)
+    @EnabledForJreRange(max = 20)
     public void newVirtualThreadThrowsOnUnsupported() {
-        Assume.assumeFalse("Only run on Java < 21", VirtualThreadHelper.isSupported());
-
         VirtualThreadHelper.newVirtualThread("test-", 1, () -> {});
     }
 
     @Test(expected = UnsupportedOperationException.class)
+    @EnabledForJreRange(max = 20)
     public void newVirtualThreadFactoryThrowsOnUnsupported() {
-        Assume.assumeFalse("Only run on Java < 21", VirtualThreadHelper.isSupported());
-
         VirtualThreadHelper.newVirtualThreadFactory("test-");
     }
 }