fix: make JDK.min(Set, String) actually use the jdks parameter (#1713)

* fix: make JDK.min(Set, String) actually use the jdks parameter

The previous implementation had a precedence bug:

    if (jdks == null || jdks.isEmpty() && jenkinsVersion == null)

Because && binds tighter than ||, this evaluated as:

    if (jdks == null || (jdks.isEmpty() && jenkinsVersion == null))

As a result, whenever jdks was non-null and non-empty the method fell
through to a single-line return that completely ignored the jdks
argument.  A plugin declaring e.g. [JAVA_17, JAVA_21] would get back
JAVA_11 for Jenkins 2.479.3, even though 11 is not in the declared set.

The fix rewrites the method to:
1. Fast-path on null jenkinsVersion (delegate to single-arg min).
2. Compute the version-range list once.
3. Intersect the caller-supplied jdks with that list and return the
   minimum; fall back to the range minimum only when the intersection
   is empty.

Also replaces the bare orElseThrow() with orElse(JDK.min()) to avoid
a cryptic NoSuchElementException when a future version boundary leaves
the supported list empty.

* fix: apply Spotless formatting to JDK.java

* fix: address Copilot review feedback on JDK.min(Set, String)

- Treat empty jenkinsVersion as absent (consistent with get(String))
- Return min(jdks) on no-intersection fallback instead of version-min
- Add tests for empty version string and no-overlap cases
- Clarify Javadoc to document no-intersection fallback behavior

---------

Co-authored-by: Valentin Delaye <jonesbusy@users.noreply.github.com>

Author: Fikri-20

plugin-modernizer-core/src/main/java/io/jenkins/tools/pluginmodernizer/core/model/JDK.java

@@ -259,15 +259,27 @@ public static JDK min(Set<JDK> jdks) {
     }
 
     /**
-     * Return the minimum JDK
-     * @param jdks List of JDKS. Can be null or empty
-     * @return The minimum JDK. If the list is empty, return the minimum JDK available
+     * Return the minimum JDK that is both declared in {@code jdks} and supported by
+     * {@code jenkinsVersion}. Falls back to {@code min(jdks)} when either parameter
+     * is absent, or when no declared JDK overlaps the version-supported set.
+     *
+     * @param jdks           JDKs declared by the plugin (e.g. from its Jenkinsfile). Can be null or empty.
+     * @param jenkinsVersion Jenkins core version the plugin targets. Can be null or empty.
+     * @return The minimum compatible JDK, never null.
      */
     public static JDK min(Set<JDK> jdks, String jenkinsVersion) {
-        if (jdks == null || jdks.isEmpty() && jenkinsVersion == null) {
-            return JDK.min();
+        if (jenkinsVersion == null || jenkinsVersion.isEmpty()) {
+            return min(jdks);
+        }
+        List<JDK> supportedByVersion = get(jenkinsVersion);
+        if (jdks == null || jdks.isEmpty()) {
+            return supportedByVersion.stream().min(JDK::compareMajor).orElse(JDK.min());
         }
-        return JDK.get(jenkinsVersion).stream().min(JDK::compareMajor).orElseThrow();
+        // Intersect: lowest JDK that is both in the plugin's declared set and supported by this Jenkins version
+        return jdks.stream()
+                .filter(supportedByVersion::contains)
+                .min(JDK::compareMajor)
+                .orElseGet(() -> min(jdks));
     }
 
     /**

plugin-modernizer-core/src/test/java/io/jenkins/tools/pluginmodernizer/core/model/JDKTest.java

@@ -65,6 +65,22 @@ public void min() {
         assertEquals(JDK.JAVA_11, JDK.min(Set.of(JDK.values()), "2.361.1"));
         assertEquals(JDK.JAVA_11, JDK.min(Set.of(JDK.values()), "2.462.3"));
         assertEquals(JDK.JAVA_17, JDK.min(Set.of(JDK.values()), "2.479.3"));
+        // jdks subset: the result must respect the declared JDKs, not just the Jenkins version range.
+        // Jenkins 2.479.3 supports Java 17 and 21; a plugin declaring [17,21] must yield 17, not 11.
+        assertEquals(JDK.JAVA_17, JDK.min(Set.of(JDK.JAVA_17, JDK.JAVA_21), "2.479.3"));
+        // Plugin declares only Java 21; Jenkins 2.462.3 supports up to Java 21, so the result is 21.
+        assertEquals(JDK.JAVA_21, JDK.min(Set.of(JDK.JAVA_21), "2.462.3"));
+        // null / empty jdks fall back to version-range minimum
+        assertEquals(JDK.JAVA_11, JDK.min(null, "2.387.3"));
+        assertEquals(JDK.JAVA_11, JDK.min(Set.of(), "2.387.3"));
+        // null version falls back to single-param min()
+        assertEquals(JDK.JAVA_8, JDK.min(null, null));
+        // empty version string is treated the same as null
+        assertEquals(JDK.JAVA_8, JDK.min(null, ""));
+        // no overlap: plugin declares only JAVA_8, but Jenkins 2.479.3 only supports 17+ → falls back to min(jdks)
+        assertEquals(JDK.JAVA_8, JDK.min(Set.of(JDK.JAVA_8), "2.479.3"));
+        // no overlap: plugin declares only JAVA_25, but Jenkins 2.346.1 supports 8-17 → falls back to min(jdks)
+        assertEquals(JDK.JAVA_25, JDK.min(Set.of(JDK.JAVA_25), "2.346.1"));
     }
 
     @Test