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