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