View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *   http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.apache.maven.artifact.versioning;
20  
21  import java.util.List;
22  
23  import org.apache.maven.artifact.Artifact;
24  import org.junit.jupiter.api.Test;
25  
26  import static org.junit.jupiter.api.Assertions.assertEquals;
27  import static org.junit.jupiter.api.Assertions.assertFalse;
28  import static org.junit.jupiter.api.Assertions.assertNull;
29  import static org.junit.jupiter.api.Assertions.assertSame;
30  import static org.junit.jupiter.api.Assertions.assertTrue;
31  import static org.junit.jupiter.api.Assertions.fail;
32  
33  /**
34   * Tests version range construction.
35   *
36   * @author <a href="mailto:brett@apache.org">Brett Porter</a>
37   */
38  public class VersionRangeTest {
39      private static final String CHECK_NUM_RESTRICTIONS = "check number of restrictions";
40  
41      private static final String CHECK_UPPER_BOUND = "check upper bound";
42  
43      private static final String CHECK_UPPER_BOUND_INCLUSIVE = "check upper bound is inclusive";
44  
45      private static final String CHECK_LOWER_BOUND = "check lower bound";
46  
47      private static final String CHECK_LOWER_BOUND_INCLUSIVE = "check lower bound is inclusive";
48  
49      private static final String CHECK_VERSION_RECOMMENDATION = "check version recommended";
50  
51      private static final String CHECK_SELECTED_VERSION_KNOWN = "check selected version known";
52  
53      private static final String CHECK_SELECTED_VERSION = "check selected version";
54  
55      @Test
56      public void testRange() throws InvalidVersionSpecificationException, OverConstrainedVersionException {
57          Artifact artifact = null;
58  
59          VersionRange range = VersionRange.createFromVersionSpec("(,1.0]");
60          List<Restriction> restrictions = range.getRestrictions();
61          assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
62          Restriction restriction = restrictions.get(0);
63          assertNull(restriction.getLowerBound(), CHECK_LOWER_BOUND);
64          assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
65          assertEquals("1.0", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
66          assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
67          assertNull(range.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
68          assertFalse(range.isSelectedVersionKnown(artifact), CHECK_SELECTED_VERSION_KNOWN);
69          assertNull(range.getSelectedVersion(artifact), CHECK_SELECTED_VERSION);
70  
71          range = VersionRange.createFromVersionSpec("1.0");
72          assertEquals("1.0", range.getRecommendedVersion().toString(), CHECK_VERSION_RECOMMENDATION);
73          restrictions = range.getRestrictions();
74          assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
75          restriction = restrictions.get(0);
76          assertNull(restriction.getLowerBound(), CHECK_LOWER_BOUND);
77          assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
78          assertNull(restriction.getUpperBound(), CHECK_UPPER_BOUND);
79          assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
80          assertTrue(range.isSelectedVersionKnown(artifact), CHECK_SELECTED_VERSION_KNOWN);
81          assertEquals("1.0", range.getSelectedVersion(artifact).toString(), CHECK_SELECTED_VERSION);
82  
83          range = VersionRange.createFromVersionSpec("[1.0]");
84          restrictions = range.getRestrictions();
85          assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
86          restriction = restrictions.get(0);
87          assertEquals("1.0", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
88          assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
89          assertEquals("1.0", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
90          assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
91          assertNull(range.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
92          assertFalse(range.isSelectedVersionKnown(artifact), CHECK_SELECTED_VERSION_KNOWN);
93          assertNull(range.getSelectedVersion(artifact), CHECK_SELECTED_VERSION);
94  
95          range = VersionRange.createFromVersionSpec("[1.2,1.3]");
96          restrictions = range.getRestrictions();
97          assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
98          restriction = restrictions.get(0);
99          assertEquals("1.2", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
100         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
101         assertEquals("1.3", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
102         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
103         assertNull(range.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
104         assertFalse(range.isSelectedVersionKnown(artifact), CHECK_SELECTED_VERSION_KNOWN);
105         assertNull(range.getSelectedVersion(artifact), CHECK_SELECTED_VERSION);
106 
107         range = VersionRange.createFromVersionSpec("[1.0,2.0)");
108         restrictions = range.getRestrictions();
109         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
110         restriction = restrictions.get(0);
111         assertEquals("1.0", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
112         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
113         assertEquals("2.0", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
114         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
115         assertNull(range.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
116         assertFalse(range.isSelectedVersionKnown(artifact), CHECK_SELECTED_VERSION_KNOWN);
117         assertNull(range.getSelectedVersion(artifact), CHECK_SELECTED_VERSION);
118 
119         range = VersionRange.createFromVersionSpec("[1.5,)");
120         restrictions = range.getRestrictions();
121         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
122         restriction = restrictions.get(0);
123         assertEquals("1.5", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
124         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
125         assertNull(restriction.getUpperBound(), CHECK_UPPER_BOUND);
126         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
127         assertNull(range.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
128         assertFalse(range.isSelectedVersionKnown(artifact), CHECK_SELECTED_VERSION_KNOWN);
129         assertNull(range.getSelectedVersion(artifact), CHECK_SELECTED_VERSION);
130 
131         range = VersionRange.createFromVersionSpec("(,1.0],[1.2,)");
132         restrictions = range.getRestrictions();
133         assertEquals(2, restrictions.size(), CHECK_NUM_RESTRICTIONS);
134         restriction = restrictions.get(0);
135         assertNull(restriction.getLowerBound(), CHECK_LOWER_BOUND);
136         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
137         assertEquals("1.0", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
138         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
139         assertNull(range.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
140         restriction = restrictions.get(1);
141         assertEquals("1.2", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
142         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
143         assertNull(restriction.getUpperBound(), CHECK_UPPER_BOUND);
144         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
145         assertNull(range.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
146         assertFalse(range.isSelectedVersionKnown(artifact), CHECK_SELECTED_VERSION_KNOWN);
147         assertNull(range.getSelectedVersion(artifact), CHECK_SELECTED_VERSION);
148 
149         range = VersionRange.createFromVersionSpec("[1.0,)");
150         assertFalse(range.containsVersion(new DefaultArtifactVersion("1.0-SNAPSHOT")));
151 
152         range = VersionRange.createFromVersionSpec("[1.0,1.1-SNAPSHOT]");
153         assertTrue(range.containsVersion(new DefaultArtifactVersion("1.1-SNAPSHOT")));
154 
155         range = VersionRange.createFromVersionSpec("[5.0.9.0,5.0.10.0)");
156         assertTrue(range.containsVersion(new DefaultArtifactVersion("5.0.9.0")));
157     }
158 
159     @Test
160     public void testSameUpperAndLowerBoundRoundtrip() throws InvalidVersionSpecificationException {
161         VersionRange range = VersionRange.createFromVersionSpec("[1.0]");
162         VersionRange range2 = VersionRange.createFromVersionSpec(range.toString());
163         assertEquals(range, range2);
164     }
165 
166     @Test
167     public void testInvalidRanges() {
168         checkInvalidRange("(1.0)");
169         checkInvalidRange("[1.0)");
170         checkInvalidRange("(1.0]");
171         checkInvalidRange("(1.0,1.0]");
172         checkInvalidRange("[1.0,1.0)");
173         checkInvalidRange("(1.0,1.0)");
174         checkInvalidRange("[1.1,1.0]");
175         checkInvalidRange("[1.0,1.2),1.3");
176         // overlap
177         checkInvalidRange("[1.0,1.2),(1.1,1.3]");
178         // overlap
179         checkInvalidRange("[1.1,1.3),(1.0,1.2]");
180         // ordering
181         checkInvalidRange("(1.1,1.2],[1.0,1.1)");
182     }
183 
184     @SuppressWarnings("checkstyle:MethodLength")
185     @Test
186     public void testIntersections() throws InvalidVersionSpecificationException {
187         VersionRange range1 = VersionRange.createFromVersionSpec("1.0");
188         VersionRange range2 = VersionRange.createFromVersionSpec("1.1");
189         VersionRange mergedRange = range1.restrict(range2);
190         // TODO current policy is to retain the original version - is this correct, do we need strategies or is that
191         // handled elsewhere?
192         //        assertEquals( CHECK_VERSION_RECOMMENDATION, "1.1", mergedRange.getRecommendedVersion().toString() );
193         assertEquals("1.0", mergedRange.getRecommendedVersion().toString(), CHECK_VERSION_RECOMMENDATION);
194         List<Restriction> restrictions = mergedRange.getRestrictions();
195         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
196         Restriction restriction = restrictions.get(0);
197         assertNull(restriction.getLowerBound(), CHECK_LOWER_BOUND);
198         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
199         assertNull(restriction.getUpperBound(), CHECK_UPPER_BOUND);
200         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
201 
202         mergedRange = range2.restrict(range1);
203         assertEquals("1.1", mergedRange.getRecommendedVersion().toString(), CHECK_VERSION_RECOMMENDATION);
204         restrictions = mergedRange.getRestrictions();
205         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
206         restriction = restrictions.get(0);
207         assertNull(restriction.getLowerBound(), CHECK_LOWER_BOUND);
208         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
209         assertNull(restriction.getUpperBound(), CHECK_UPPER_BOUND);
210         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
211 
212         // TODO test reversed restrictions on all below
213         range1 = VersionRange.createFromVersionSpec("[1.0,)");
214         range2 = VersionRange.createFromVersionSpec("1.1");
215         mergedRange = range1.restrict(range2);
216         assertEquals("1.1", mergedRange.getRecommendedVersion().toString(), CHECK_VERSION_RECOMMENDATION);
217         restrictions = mergedRange.getRestrictions();
218         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
219         restriction = restrictions.get(0);
220         assertEquals("1.0", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
221         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
222         assertNull(restriction.getUpperBound(), CHECK_UPPER_BOUND);
223         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
224 
225         range1 = VersionRange.createFromVersionSpec("[1.1,)");
226         range2 = VersionRange.createFromVersionSpec("1.1");
227         mergedRange = range1.restrict(range2);
228         assertEquals("1.1", mergedRange.getRecommendedVersion().toString(), CHECK_VERSION_RECOMMENDATION);
229         restrictions = mergedRange.getRestrictions();
230         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
231         restriction = restrictions.get(0);
232         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
233         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
234         assertNull(restriction.getUpperBound(), CHECK_UPPER_BOUND);
235         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
236 
237         range1 = VersionRange.createFromVersionSpec("[1.1]");
238         range2 = VersionRange.createFromVersionSpec("1.1");
239         mergedRange = range1.restrict(range2);
240         assertEquals("1.1", mergedRange.getRecommendedVersion().toString(), CHECK_VERSION_RECOMMENDATION);
241         restrictions = mergedRange.getRestrictions();
242         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
243         restriction = restrictions.get(0);
244         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
245         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
246         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_UPPER_BOUND);
247         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
248 
249         range1 = VersionRange.createFromVersionSpec("(1.1,)");
250         range2 = VersionRange.createFromVersionSpec("1.1");
251         mergedRange = range1.restrict(range2);
252         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
253         restrictions = mergedRange.getRestrictions();
254         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
255         restriction = restrictions.get(0);
256         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
257         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
258         assertNull(restriction.getUpperBound(), CHECK_UPPER_BOUND);
259         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
260 
261         range1 = VersionRange.createFromVersionSpec("[1.2,)");
262         range2 = VersionRange.createFromVersionSpec("1.1");
263         mergedRange = range1.restrict(range2);
264         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
265         restrictions = mergedRange.getRestrictions();
266         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
267         restriction = restrictions.get(0);
268         assertEquals("1.2", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
269         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
270         assertNull(restriction.getUpperBound(), CHECK_UPPER_BOUND);
271         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
272 
273         range1 = VersionRange.createFromVersionSpec("(,1.2]");
274         range2 = VersionRange.createFromVersionSpec("1.1");
275         mergedRange = range1.restrict(range2);
276         assertEquals("1.1", mergedRange.getRecommendedVersion().toString(), CHECK_VERSION_RECOMMENDATION);
277         restrictions = mergedRange.getRestrictions();
278         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
279         restriction = restrictions.get(0);
280         assertNull(restriction.getLowerBound(), CHECK_LOWER_BOUND);
281         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
282         assertEquals("1.2", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
283         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
284 
285         range1 = VersionRange.createFromVersionSpec("(,1.1]");
286         range2 = VersionRange.createFromVersionSpec("1.1");
287         mergedRange = range1.restrict(range2);
288         assertEquals("1.1", mergedRange.getRecommendedVersion().toString(), CHECK_VERSION_RECOMMENDATION);
289         restrictions = mergedRange.getRestrictions();
290         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
291         restriction = restrictions.get(0);
292         assertNull(restriction.getLowerBound(), CHECK_LOWER_BOUND);
293         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
294         assertEquals("1.1", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
295         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
296 
297         range1 = VersionRange.createFromVersionSpec("(,1.1)");
298         range2 = VersionRange.createFromVersionSpec("1.1");
299         mergedRange = range1.restrict(range2);
300         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
301         restrictions = mergedRange.getRestrictions();
302         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
303         restriction = restrictions.get(0);
304         assertNull(restriction.getLowerBound(), CHECK_LOWER_BOUND);
305         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
306         assertEquals("1.1", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
307         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
308 
309         range1 = VersionRange.createFromVersionSpec("(,1.0]");
310         range2 = VersionRange.createFromVersionSpec("1.1");
311         mergedRange = range1.restrict(range2);
312         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
313         restrictions = mergedRange.getRestrictions();
314         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
315         restriction = restrictions.get(0);
316         assertNull(restriction.getLowerBound(), CHECK_LOWER_BOUND);
317         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
318         assertEquals("1.0", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
319         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
320 
321         range1 = VersionRange.createFromVersionSpec("(,1.0], [1.1,)");
322         range2 = VersionRange.createFromVersionSpec("1.2");
323         mergedRange = range1.restrict(range2);
324         assertEquals("1.2", mergedRange.getRecommendedVersion().toString(), CHECK_VERSION_RECOMMENDATION);
325         restrictions = mergedRange.getRestrictions();
326         assertEquals(2, restrictions.size(), CHECK_NUM_RESTRICTIONS);
327         restriction = restrictions.get(0);
328         assertNull(restriction.getLowerBound(), CHECK_LOWER_BOUND);
329         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
330         assertEquals("1.0", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
331         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
332         restriction = restrictions.get(1);
333         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
334         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
335         assertNull(restriction.getUpperBound(), CHECK_UPPER_BOUND);
336         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
337 
338         range1 = VersionRange.createFromVersionSpec("(,1.0], [1.1,)");
339         range2 = VersionRange.createFromVersionSpec("1.0.5");
340         mergedRange = range1.restrict(range2);
341         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
342         restrictions = mergedRange.getRestrictions();
343         assertEquals(2, restrictions.size(), CHECK_NUM_RESTRICTIONS);
344         restriction = restrictions.get(0);
345         assertNull(restriction.getLowerBound(), CHECK_LOWER_BOUND);
346         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
347         assertEquals("1.0", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
348         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
349         restriction = restrictions.get(1);
350         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
351         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
352         assertNull(restriction.getUpperBound(), CHECK_UPPER_BOUND);
353         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
354 
355         range1 = VersionRange.createFromVersionSpec("(,1.1), (1.1,)");
356         range2 = VersionRange.createFromVersionSpec("1.1");
357         mergedRange = range1.restrict(range2);
358         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
359         restrictions = mergedRange.getRestrictions();
360         assertEquals(2, restrictions.size(), CHECK_NUM_RESTRICTIONS);
361         restriction = restrictions.get(0);
362         assertNull(restriction.getLowerBound(), CHECK_LOWER_BOUND);
363         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
364         assertEquals("1.1", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
365         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
366         restriction = restrictions.get(1);
367         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
368         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
369         assertNull(restriction.getUpperBound(), CHECK_UPPER_BOUND);
370         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
371 
372         range1 = VersionRange.createFromVersionSpec("[1.1,1.3]");
373         range2 = VersionRange.createFromVersionSpec("(1.1,)");
374         mergedRange = range1.restrict(range2);
375         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
376         restrictions = mergedRange.getRestrictions();
377         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
378         restriction = restrictions.get(0);
379         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
380         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
381         assertEquals("1.3", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
382         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
383 
384         range1 = VersionRange.createFromVersionSpec("(,1.3)");
385         range2 = VersionRange.createFromVersionSpec("[1.2,1.3]");
386         mergedRange = range1.restrict(range2);
387         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
388         restrictions = mergedRange.getRestrictions();
389         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
390         restriction = restrictions.get(0);
391         assertEquals("1.2", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
392         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
393         assertEquals("1.3", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
394         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
395 
396         range1 = VersionRange.createFromVersionSpec("[1.1,1.3]");
397         range2 = VersionRange.createFromVersionSpec("[1.2,)");
398         mergedRange = range1.restrict(range2);
399         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
400         restrictions = mergedRange.getRestrictions();
401         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
402         restriction = restrictions.get(0);
403         assertEquals("1.2", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
404         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
405         assertEquals("1.3", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
406         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
407 
408         range1 = VersionRange.createFromVersionSpec("(,1.3]");
409         range2 = VersionRange.createFromVersionSpec("[1.2,1.4]");
410         mergedRange = range1.restrict(range2);
411         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
412         restrictions = mergedRange.getRestrictions();
413         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
414         restriction = restrictions.get(0);
415         assertEquals("1.2", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
416         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
417         assertEquals("1.3", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
418         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
419 
420         range1 = VersionRange.createFromVersionSpec("(1.2,1.3]");
421         range2 = VersionRange.createFromVersionSpec("[1.1,1.4]");
422         mergedRange = range1.restrict(range2);
423         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
424         restrictions = mergedRange.getRestrictions();
425         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
426         restriction = restrictions.get(0);
427         assertEquals("1.2", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
428         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
429         assertEquals("1.3", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
430         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
431 
432         range1 = VersionRange.createFromVersionSpec("(1.2,1.3)");
433         range2 = VersionRange.createFromVersionSpec("[1.1,1.4]");
434         mergedRange = range1.restrict(range2);
435         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
436         restrictions = mergedRange.getRestrictions();
437         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
438         restriction = restrictions.get(0);
439         assertEquals("1.2", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
440         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
441         assertEquals("1.3", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
442         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
443 
444         range1 = VersionRange.createFromVersionSpec("[1.2,1.3)");
445         range2 = VersionRange.createFromVersionSpec("[1.1,1.4]");
446         mergedRange = range1.restrict(range2);
447         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
448         restrictions = mergedRange.getRestrictions();
449         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
450         restriction = restrictions.get(0);
451         assertEquals("1.2", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
452         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
453         assertEquals("1.3", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
454         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
455 
456         range1 = VersionRange.createFromVersionSpec("[1.0,1.1]");
457         range2 = VersionRange.createFromVersionSpec("[1.1,1.4]");
458         mergedRange = range1.restrict(range2);
459         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
460         restrictions = mergedRange.getRestrictions();
461         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
462         restriction = restrictions.get(0);
463         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
464         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
465         assertEquals("1.1", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
466         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
467 
468         range1 = VersionRange.createFromVersionSpec("[1.0,1.1)");
469         range2 = VersionRange.createFromVersionSpec("[1.1,1.4]");
470         mergedRange = range1.restrict(range2);
471         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
472         restrictions = mergedRange.getRestrictions();
473         assertEquals(0, restrictions.size(), CHECK_NUM_RESTRICTIONS);
474 
475         range1 = VersionRange.createFromVersionSpec("[1.0,1.2],[1.3,1.5]");
476         range2 = VersionRange.createFromVersionSpec("[1.1]");
477         mergedRange = range1.restrict(range2);
478         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
479         restrictions = mergedRange.getRestrictions();
480         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
481         restriction = restrictions.get(0);
482         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
483         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
484         assertEquals("1.1", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
485         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
486 
487         range1 = VersionRange.createFromVersionSpec("[1.0,1.2],[1.3,1.5]");
488         range2 = VersionRange.createFromVersionSpec("[1.4]");
489         mergedRange = range1.restrict(range2);
490         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
491         restrictions = mergedRange.getRestrictions();
492         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
493         restriction = restrictions.get(0);
494         assertEquals("1.4", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
495         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
496         assertEquals("1.4", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
497         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
498 
499         range1 = VersionRange.createFromVersionSpec("[1.0,1.2],[1.3,1.5]");
500         range2 = VersionRange.createFromVersionSpec("[1.1,1.4]");
501         mergedRange = range1.restrict(range2);
502         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
503         restrictions = mergedRange.getRestrictions();
504         assertEquals(2, restrictions.size(), CHECK_NUM_RESTRICTIONS);
505         restriction = restrictions.get(0);
506         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
507         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
508         assertEquals("1.2", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
509         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
510         restriction = restrictions.get(1);
511         assertEquals("1.3", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
512         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
513         assertEquals("1.4", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
514         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
515 
516         range1 = VersionRange.createFromVersionSpec("[1.0,1.2),(1.3,1.5]");
517         range2 = VersionRange.createFromVersionSpec("[1.1,1.4]");
518         mergedRange = range1.restrict(range2);
519         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
520         restrictions = mergedRange.getRestrictions();
521         assertEquals(2, restrictions.size(), CHECK_NUM_RESTRICTIONS);
522         restriction = restrictions.get(0);
523         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
524         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
525         assertEquals("1.2", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
526         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
527         restriction = restrictions.get(1);
528         assertEquals("1.3", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
529         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
530         assertEquals("1.4", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
531         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
532 
533         range1 = VersionRange.createFromVersionSpec("[1.0,1.2],[1.3,1.5]");
534         range2 = VersionRange.createFromVersionSpec("(1.1,1.4)");
535         mergedRange = range1.restrict(range2);
536         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
537         restrictions = mergedRange.getRestrictions();
538         assertEquals(2, restrictions.size(), CHECK_NUM_RESTRICTIONS);
539         restriction = restrictions.get(0);
540         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
541         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
542         assertEquals("1.2", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
543         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
544         restriction = restrictions.get(1);
545         assertEquals("1.3", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
546         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
547         assertEquals("1.4", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
548         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
549 
550         range1 = VersionRange.createFromVersionSpec("[1.0,1.2),(1.3,1.5]");
551         range2 = VersionRange.createFromVersionSpec("(1.1,1.4)");
552         mergedRange = range1.restrict(range2);
553         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
554         restrictions = mergedRange.getRestrictions();
555         assertEquals(2, restrictions.size(), CHECK_NUM_RESTRICTIONS);
556         restriction = restrictions.get(0);
557         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
558         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
559         assertEquals("1.2", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
560         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
561         restriction = restrictions.get(1);
562         assertEquals("1.3", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
563         assertFalse(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
564         assertEquals("1.4", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
565         assertFalse(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
566 
567         range1 = VersionRange.createFromVersionSpec("(,1.1),(1.4,)");
568         range2 = VersionRange.createFromVersionSpec("[1.1,1.4]");
569         mergedRange = range1.restrict(range2);
570         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
571         restrictions = mergedRange.getRestrictions();
572         assertEquals(0, restrictions.size(), CHECK_NUM_RESTRICTIONS);
573 
574         range1 = VersionRange.createFromVersionSpec("(,1.1],[1.4,)");
575         range2 = VersionRange.createFromVersionSpec("(1.1,1.4)");
576         mergedRange = range1.restrict(range2);
577         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
578         restrictions = mergedRange.getRestrictions();
579         assertEquals(0, restrictions.size(), CHECK_NUM_RESTRICTIONS);
580 
581         range1 = VersionRange.createFromVersionSpec("[,1.1],[1.4,]");
582         range2 = VersionRange.createFromVersionSpec("[1.2,1.3]");
583         mergedRange = range1.restrict(range2);
584         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
585         restrictions = mergedRange.getRestrictions();
586         assertEquals(0, restrictions.size(), CHECK_NUM_RESTRICTIONS);
587 
588         range1 = VersionRange.createFromVersionSpec("[1.0,1.2],[1.3,1.5]");
589         range2 = VersionRange.createFromVersionSpec("[1.1,1.4],[1.6,]");
590         mergedRange = range1.restrict(range2);
591         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
592         restrictions = mergedRange.getRestrictions();
593         assertEquals(2, restrictions.size(), CHECK_NUM_RESTRICTIONS);
594         restriction = restrictions.get(0);
595         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
596         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
597         assertEquals("1.2", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
598         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
599         restriction = restrictions.get(1);
600         assertEquals("1.3", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
601         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
602         assertEquals("1.4", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
603         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
604 
605         range1 = VersionRange.createFromVersionSpec("[1.0,1.2],[1.3,1.5]");
606         range2 = VersionRange.createFromVersionSpec("[1.1,1.4],[1.5,]");
607         mergedRange = range1.restrict(range2);
608         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
609         restrictions = mergedRange.getRestrictions();
610         assertEquals(3, restrictions.size(), CHECK_NUM_RESTRICTIONS);
611         restriction = restrictions.get(0);
612         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
613         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
614         assertEquals("1.2", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
615         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
616         restriction = restrictions.get(1);
617         assertEquals("1.3", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
618         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
619         assertEquals("1.4", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
620         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
621         restriction = restrictions.get(2);
622         assertEquals("1.5", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
623         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
624         assertEquals("1.5", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
625         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
626 
627         range1 = VersionRange.createFromVersionSpec("[1.0,1.2],[1.3,1.7]");
628         range2 = VersionRange.createFromVersionSpec("[1.1,1.4],[1.5,1.6]");
629         mergedRange = range1.restrict(range2);
630         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
631         restrictions = mergedRange.getRestrictions();
632         assertEquals(3, restrictions.size(), CHECK_NUM_RESTRICTIONS);
633         restriction = restrictions.get(0);
634         assertEquals("1.1", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
635         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
636         assertEquals("1.2", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
637         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
638         restriction = restrictions.get(1);
639         assertEquals("1.3", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
640         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
641         assertEquals("1.4", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
642         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
643         restriction = restrictions.get(2);
644         assertEquals("1.5", restriction.getLowerBound().toString(), CHECK_LOWER_BOUND);
645         assertTrue(restriction.isLowerBoundInclusive(), CHECK_LOWER_BOUND_INCLUSIVE);
646         assertEquals("1.6", restriction.getUpperBound().toString(), CHECK_UPPER_BOUND);
647         assertTrue(restriction.isUpperBoundInclusive(), CHECK_UPPER_BOUND_INCLUSIVE);
648 
649         // test restricting empty sets
650         range1 = VersionRange.createFromVersionSpec("[,1.1],[1.4,]");
651         range2 = VersionRange.createFromVersionSpec("[1.2,1.3]");
652         range1 = range1.restrict(range2);
653         mergedRange = range1.restrict(range2);
654         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
655         restrictions = mergedRange.getRestrictions();
656         assertEquals(0, restrictions.size(), CHECK_NUM_RESTRICTIONS);
657 
658         range1 = VersionRange.createFromVersionSpec("[,1.1],[1.4,]");
659         range2 = VersionRange.createFromVersionSpec("[1.2,1.3]");
660         range2 = range1.restrict(range2);
661         mergedRange = range1.restrict(range2);
662         assertNull(mergedRange.getRecommendedVersion(), CHECK_VERSION_RECOMMENDATION);
663         restrictions = mergedRange.getRestrictions();
664         assertEquals(0, restrictions.size(), CHECK_NUM_RESTRICTIONS);
665     }
666 
667     @Test
668     public void testReleaseRangeBoundsContainsSnapshots() throws InvalidVersionSpecificationException {
669         VersionRange range = VersionRange.createFromVersionSpec("[1.0,1.2]");
670 
671         assertTrue(range.containsVersion(new DefaultArtifactVersion("1.1-SNAPSHOT")));
672         assertTrue(range.containsVersion(new DefaultArtifactVersion("1.2-SNAPSHOT")));
673         assertFalse(range.containsVersion(new DefaultArtifactVersion("1.0-SNAPSHOT")));
674     }
675 
676     @Test
677     public void testSnapshotRangeBoundsCanContainSnapshots() throws InvalidVersionSpecificationException {
678         VersionRange range = VersionRange.createFromVersionSpec("[1.0,1.2-SNAPSHOT]");
679 
680         assertTrue(range.containsVersion(new DefaultArtifactVersion("1.1-SNAPSHOT")));
681         assertTrue(range.containsVersion(new DefaultArtifactVersion("1.2-SNAPSHOT")));
682 
683         range = VersionRange.createFromVersionSpec("[1.0-SNAPSHOT,1.2]");
684 
685         assertTrue(range.containsVersion(new DefaultArtifactVersion("1.0-SNAPSHOT")));
686         assertTrue(range.containsVersion(new DefaultArtifactVersion("1.1-SNAPSHOT")));
687     }
688 
689     @Test
690     public void testSnapshotSoftVersionCanContainSnapshot() throws InvalidVersionSpecificationException {
691         VersionRange range = VersionRange.createFromVersionSpec("1.0-SNAPSHOT");
692 
693         assertTrue(range.containsVersion(new DefaultArtifactVersion("1.0-SNAPSHOT")));
694     }
695 
696     private void checkInvalidRange(String version) {
697         try {
698             VersionRange.createFromVersionSpec(version);
699             fail("Version " + version + " should have failed to construct");
700         } catch (InvalidVersionSpecificationException expected) {
701             // expected
702         }
703     }
704 
705     @Test
706     public void testContains() throws InvalidVersionSpecificationException {
707         ArtifactVersion actualVersion = new DefaultArtifactVersion("2.0.5");
708         assertTrue(enforceVersion("2.0.5", actualVersion));
709         assertTrue(enforceVersion("2.0.4", actualVersion));
710         assertTrue(enforceVersion("[2.0.5]", actualVersion));
711         assertFalse(enforceVersion("[2.0.6,)", actualVersion));
712         assertFalse(enforceVersion("[2.0.6]", actualVersion));
713         assertTrue(enforceVersion("[2.0,2.1]", actualVersion));
714         assertFalse(enforceVersion("[2.0,2.0.3]", actualVersion));
715         assertTrue(enforceVersion("[2.0,2.0.5]", actualVersion));
716         assertFalse(enforceVersion("[2.0,2.0.5)", actualVersion));
717     }
718 
719     public boolean enforceVersion(String requiredVersionRange, ArtifactVersion actualVersion)
720             throws InvalidVersionSpecificationException {
721         VersionRange vr = null;
722 
723         vr = VersionRange.createFromVersionSpec(requiredVersionRange);
724 
725         return vr.containsVersion(actualVersion);
726     }
727 
728     public void testOrder0() {
729         // assertTrue( new DefaultArtifactVersion( "1.0-alpha10" ).compareTo( new DefaultArtifactVersion( "1.0-alpha1" )
730         // ) > 0 );
731     }
732 
733     @Test
734     public void testCache() throws InvalidVersionSpecificationException {
735         VersionRange range = VersionRange.createFromVersionSpec("[1.0,1.2]");
736         assertSame(range, VersionRange.createFromVersionSpec("[1.0,1.2]")); // same instance from spec cache
737 
738         VersionRange spec = VersionRange.createFromVersionSpec("1.0");
739         assertSame(spec, VersionRange.createFromVersionSpec("1.0")); // same instance from spec cache
740         List<Restriction> restrictions = spec.getRestrictions();
741         assertEquals(1, restrictions.size(), CHECK_NUM_RESTRICTIONS);
742 
743         VersionRange version = VersionRange.createFromVersion("1.0");
744         assertSame(version, VersionRange.createFromVersion("1.0")); // same instance from version cache
745         restrictions = version.getRestrictions();
746         assertEquals(0, restrictions.size(), CHECK_NUM_RESTRICTIONS);
747 
748         assertFalse(
749                 spec.equals(version),
750                 "check !VersionRange.createFromVersionSpec(x).equals(VersionRange.createFromVersion(x))");
751     }
752 }