This is an automated email from the ASF dual-hosted git repository.

gnodet pushed a commit to branch maven-4.0.x
in repository https://gitbox.apache.org/repos/asf/maven.git


The following commit(s) were added to refs/heads/maven-4.0.x by this push:
     new 0cfc5dd4f0 [Backport maven-4.0.x] #13995: Protect cached version range 
restrictions (#14026)
0cfc5dd4f0 is described below

commit 0cfc5dd4f000d8988cbe4e432381e5d8d04fa753
Author: Guillaume Nodet <[email protected]>
AuthorDate: Mon Nov 16 23:04:51 2026 +0100

    [Backport maven-4.0.x] #13995: Protect cached version range restrictions 
(#14026)
    
    * [Backport maven-4.0.x] #13995: Protect cached version range restrictions
    
    - VersionRange caches and returns shared instances from 
createFromVersionSpec() and createFromVersion(), but getRestrictions() exposed 
the mutable backing list; callers that cleared or mutated it corrupted 
subsequent range checks for every other caller using the same cached 
specification
    - Move the Collections.unmodifiableList() wrap into the private constructor 
so every code path (direct construction, cloneOf(), restrict()) produces an 
immutable restriction list from the start; remove the now-redundant wrapping in 
restrict()
    - Document getRestrictions() to state that the returned list is 
unmodifiable and non-null
    - Add parameterized tests verifying that cached, cloned, intersected, and 
version-only ranges all throw UnsupportedOperationException on mutation 
attempts and that the cache remains consistent after attempted mutation
    
    Cherry-picked from bd1d61041394fe485bb2902a6dc063290bb6ad8a
    
    * fix: apply Spotless formatting
    
    ---------
    
    Co-authored-by: Amar Ghugare <[email protected]>
---
 .../maven/artifact/versioning/VersionRange.java    | 12 ++++-
 .../artifact/versioning/VersionRangeTest.java      | 56 ++++++++++++++++++++++
 2 files changed, 66 insertions(+), 2 deletions(-)

diff --git 
a/compat/maven-artifact/src/main/java/org/apache/maven/artifact/versioning/VersionRange.java
 
b/compat/maven-artifact/src/main/java/org/apache/maven/artifact/versioning/VersionRange.java
index 1869dcc584..da8a5c7780 100644
--- 
a/compat/maven-artifact/src/main/java/org/apache/maven/artifact/versioning/VersionRange.java
+++ 
b/compat/maven-artifact/src/main/java/org/apache/maven/artifact/versioning/VersionRange.java
@@ -44,13 +44,21 @@ public class VersionRange {
 
     private VersionRange(ArtifactVersion recommendedVersion, List<Restriction> 
restrictions) {
         this.recommendedVersion = recommendedVersion;
-        this.restrictions = restrictions;
+        this.restrictions = Collections.unmodifiableList(restrictions);
     }
 
     public ArtifactVersion getRecommendedVersion() {
         return recommendedVersion;
     }
 
+    /**
+     * Returns the intervals used to match versions against this range.
+     *
+     * <p>If this list is empty, {@link #containsVersion(ArtifactVersion)} 
returns {@code false}.
+     * A recommended version may still be available from {@link 
#getRecommendedVersion()}.</p>
+     *
+     * @return an unmodifiable, non-null list of version restrictions
+     */
     public List<Restriction> getRestrictions() {
         return restrictions;
     }
@@ -251,7 +259,7 @@ public VersionRange restrict(VersionRange restriction) {
         if (r1.isEmpty() || r2.isEmpty()) {
             restrictions = Collections.emptyList();
         } else {
-            restrictions = Collections.unmodifiableList(intersection(r1, r2));
+            restrictions = intersection(r1, r2);
         }
 
         ArtifactVersion version = null;
diff --git 
a/compat/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/VersionRangeTest.java
 
b/compat/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/VersionRangeTest.java
index 7685a899b1..a953a1e5be 100644
--- 
a/compat/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/VersionRangeTest.java
+++ 
b/compat/maven-artifact/src/test/java/org/apache/maven/artifact/versioning/VersionRangeTest.java
@@ -22,6 +22,8 @@
 
 import org.apache.maven.artifact.Artifact;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -793,4 +795,58 @@ void testCache() throws 
InvalidVersionSpecificationException {
                 spec.equals(version),
                 "check 
!VersionRange.createFromVersionSpec(x).equals(VersionRange.createFromVersion(x))");
     }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"[1.1234,2.5678]", "[1.1234]", 
"(,1.1234],[2.5678,)", "1.1234"})
+    void testCachedRestrictionsAreUnmodifiable(String spec) throws 
InvalidVersionSpecificationException {
+        VersionRange range = VersionRange.createFromVersionSpec(spec);
+        List<Restriction> restrictions = List.copyOf(range.getRestrictions());
+        ArtifactVersion version = new DefaultArtifactVersion("1.1234");
+        assertTrue(range.containsVersion(version));
+
+        assertThrows(UnsupportedOperationException.class, () -> 
range.getRestrictions()
+                .clear());
+        assertThrows(UnsupportedOperationException.class, () -> 
range.getRestrictions()
+                .set(0, Restriction.EVERYTHING));
+
+        VersionRange cached = VersionRange.createFromVersionSpec(spec);
+        assertSame(range, cached);
+        assertEquals(restrictions, cached.getRestrictions());
+        assertTrue(cached.containsVersion(version));
+    }
+
+    @Test
+    @SuppressWarnings("deprecation")
+    void testClonedRestrictionsAreUnmodifiable() throws 
InvalidVersionSpecificationException {
+        VersionRange range = 
VersionRange.createFromVersionSpec("[3.1234,4.5678]");
+        VersionRange clone = range.cloneOf();
+
+        assertThrows(UnsupportedOperationException.class, () -> 
clone.getRestrictions()
+                .clear());
+        assertEquals(range, clone);
+        assertTrue(clone.containsVersion(new 
DefaultArtifactVersion("3.5000")));
+        assertFalse(clone.containsVersion(new DefaultArtifactVersion("5.0")));
+    }
+
+    @Test
+    void testIntersectedRestrictionsAreUnmodifiable() throws 
InvalidVersionSpecificationException {
+        VersionRange range = 
VersionRange.createFromVersionSpec("[3.1234,4.5678]")
+                .restrict(VersionRange.createFromVersionSpec("[3.5000,5.0]"));
+
+        assertThrows(UnsupportedOperationException.class, () -> 
range.getRestrictions()
+                .clear());
+        assertTrue(range.containsVersion(new DefaultArtifactVersion("4.0")));
+        assertFalse(range.containsVersion(new 
DefaultArtifactVersion("3.2500")));
+    }
+
+    @Test
+    void testVersionRestrictionsAreUnmodifiable() {
+        VersionRange range = VersionRange.createFromVersion("3.1234");
+
+        assertThrows(UnsupportedOperationException.class, () -> 
range.getRestrictions()
+                .add(Restriction.EVERYTHING));
+        assertSame(range, VersionRange.createFromVersion("3.1234"));
+        assertTrue(range.getRestrictions().isEmpty());
+        assertEquals(new DefaultArtifactVersion("3.1234"), 
range.getRecommendedVersion());
+    }
 }

Reply via email to