001package org.apache.maven.artifact.versioning;
002
003/*
004 * Licensed to the Apache Software Foundation (ASF) under one
005 * or more contributor license agreements.  See the NOTICE file
006 * distributed with this work for additional information
007 * regarding copyright ownership.  The ASF licenses this file
008 * to you under the Apache License, Version 2.0 (the
009 * "License"); you may not use this file except in compliance
010 * with the License.  You may obtain a copy of the License at
011 *
012 *  http://www.apache.org/licenses/LICENSE-2.0
013 *
014 * Unless required by applicable law or agreed to in writing,
015 * software distributed under the License is distributed on an
016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
017 * KIND, either express or implied.  See the License for the
018 * specific language governing permissions and limitations
019 * under the License.
020 */
021
022import java.util.List;
023
024import junit.framework.TestCase;
025
026import org.apache.maven.artifact.Artifact;
027
028/**
029 * Tests version range construction.
030 *
031 * @author <a href="mailto:brett@apache.org">Brett Porter</a>
032 */
033public class VersionRangeTest
034    extends TestCase
035{
036    private static final String CHECK_NUM_RESTRICTIONS = "check number of restrictions";
037
038    private static final String CHECK_UPPER_BOUND = "check upper bound";
039
040    private static final String CHECK_UPPER_BOUND_INCLUSIVE = "check upper bound is inclusive";
041
042    private static final String CHECK_LOWER_BOUND = "check lower bound";
043
044    private static final String CHECK_LOWER_BOUND_INCLUSIVE = "check lower bound is inclusive";
045
046    private static final String CHECK_VERSION_RECOMMENDATION = "check version recommended";
047
048    private static final String CHECK_SELECTED_VERSION_KNOWN = "check selected version known";
049
050    private static final String CHECK_SELECTED_VERSION = "check selected version";
051
052    public void testRange()
053        throws InvalidVersionSpecificationException, OverConstrainedVersionException
054    {
055        Artifact artifact = null;
056        
057        VersionRange range = VersionRange.createFromVersionSpec( "(,1.0]" );
058        List<Restriction> restrictions = range.getRestrictions();
059        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
060        Restriction restriction = restrictions.get( 0 );
061        assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() );
062        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
063        assertEquals( CHECK_UPPER_BOUND, "1.0", restriction.getUpperBound().toString() );
064        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
065        assertNull( CHECK_VERSION_RECOMMENDATION, range.getRecommendedVersion() );
066        assertFalse( CHECK_SELECTED_VERSION_KNOWN, range.isSelectedVersionKnown( artifact ) );
067        assertNull( CHECK_SELECTED_VERSION, range.getSelectedVersion( artifact ) );
068
069        range = VersionRange.createFromVersionSpec( "1.0" );
070        assertEquals( CHECK_VERSION_RECOMMENDATION, "1.0", range.getRecommendedVersion().toString() );
071        restrictions = range.getRestrictions();
072        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
073        restriction = restrictions.get( 0 );
074        assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() );
075        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
076        assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() );
077        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
078        assertTrue( CHECK_SELECTED_VERSION_KNOWN, range.isSelectedVersionKnown( artifact ) );
079        assertEquals( CHECK_SELECTED_VERSION, "1.0", range.getSelectedVersion( artifact ).toString() );
080
081        range = VersionRange.createFromVersionSpec( "[1.0]" );
082        restrictions = range.getRestrictions();
083        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
084        restriction = restrictions.get( 0 );
085        assertEquals( CHECK_LOWER_BOUND, "1.0", restriction.getLowerBound().toString() );
086        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
087        assertEquals( CHECK_UPPER_BOUND, "1.0", restriction.getUpperBound().toString() );
088        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
089        assertNull( CHECK_VERSION_RECOMMENDATION, range.getRecommendedVersion() );
090        assertFalse( CHECK_SELECTED_VERSION_KNOWN, range.isSelectedVersionKnown( artifact ) );
091        assertNull( CHECK_SELECTED_VERSION, range.getSelectedVersion( artifact ) );
092
093        range = VersionRange.createFromVersionSpec( "[1.2,1.3]" );
094        restrictions = range.getRestrictions();
095        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
096        restriction = restrictions.get( 0 );
097        assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() );
098        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
099        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 testInvalidRanges()
158    {
159        checkInvalidRange( "(1.0)" );
160        checkInvalidRange( "[1.0)" );
161        checkInvalidRange( "(1.0]" );
162        checkInvalidRange( "(1.0,1.0]" );
163        checkInvalidRange( "[1.0,1.0)" );
164        checkInvalidRange( "(1.0,1.0)" );
165        checkInvalidRange( "[1.1,1.0]" );
166        checkInvalidRange( "[1.0,1.2),1.3" );
167        // overlap
168        checkInvalidRange( "[1.0,1.2),(1.1,1.3]" );
169        // overlap
170        checkInvalidRange( "[1.1,1.3),(1.0,1.2]" );
171        // ordering
172        checkInvalidRange( "(1.1,1.2],[1.0,1.1)" );
173    }
174
175    public void testIntersections()
176        throws InvalidVersionSpecificationException
177    {
178        VersionRange range1 = VersionRange.createFromVersionSpec( "1.0" );
179        VersionRange range2 = VersionRange.createFromVersionSpec( "1.1" );
180        VersionRange mergedRange = range1.restrict( range2 );
181        // TODO: current policy is to retain the original version - is this correct, do we need strategies or is that handled elsewhere?
182//        assertEquals( CHECK_VERSION_RECOMMENDATION, "1.1", mergedRange.getRecommendedVersion().toString() );
183        assertEquals( CHECK_VERSION_RECOMMENDATION, "1.0", mergedRange.getRecommendedVersion().toString() );
184        List<Restriction> restrictions = mergedRange.getRestrictions();
185        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
186        Restriction restriction = restrictions.get( 0 );
187        assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() );
188        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
189        assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() );
190        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
191
192        mergedRange = range2.restrict( range1 );
193        assertEquals( CHECK_VERSION_RECOMMENDATION, "1.1", mergedRange.getRecommendedVersion().toString() );
194        restrictions = mergedRange.getRestrictions();
195        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
196        restriction = restrictions.get( 0 );
197        assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() );
198        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
199        assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() );
200        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
201
202        // TODO: test reversed restrictions on all below
203        range1 = VersionRange.createFromVersionSpec( "[1.0,)" );
204        range2 = VersionRange.createFromVersionSpec( "1.1" );
205        mergedRange = range1.restrict( range2 );
206        assertEquals( CHECK_VERSION_RECOMMENDATION, "1.1", mergedRange.getRecommendedVersion().toString() );
207        restrictions = mergedRange.getRestrictions();
208        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
209        restriction = restrictions.get( 0 );
210        assertEquals( CHECK_LOWER_BOUND, "1.0", restriction.getLowerBound().toString() );
211        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
212        assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() );
213        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
214
215        range1 = VersionRange.createFromVersionSpec( "[1.1,)" );
216        range2 = VersionRange.createFromVersionSpec( "1.1" );
217        mergedRange = range1.restrict( range2 );
218        assertEquals( CHECK_VERSION_RECOMMENDATION, "1.1", mergedRange.getRecommendedVersion().toString() );
219        restrictions = mergedRange.getRestrictions();
220        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
221        restriction = restrictions.get( 0 );
222        assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() );
223        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
224        assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() );
225        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
226
227        range1 = VersionRange.createFromVersionSpec( "[1.1]" );
228        range2 = VersionRange.createFromVersionSpec( "1.1" );
229        mergedRange = range1.restrict( range2 );
230        assertEquals( CHECK_VERSION_RECOMMENDATION, "1.1", mergedRange.getRecommendedVersion().toString() );
231        restrictions = mergedRange.getRestrictions();
232        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
233        restriction = restrictions.get( 0 );
234        assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() );
235        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
236        assertEquals( CHECK_UPPER_BOUND, "1.1", restriction.getLowerBound().toString() );
237        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
238
239        range1 = VersionRange.createFromVersionSpec( "(1.1,)" );
240        range2 = VersionRange.createFromVersionSpec( "1.1" );
241        mergedRange = range1.restrict( range2 );
242        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
243        restrictions = mergedRange.getRestrictions();
244        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
245        restriction = restrictions.get( 0 );
246        assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() );
247        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
248        assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() );
249        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
250
251        range1 = VersionRange.createFromVersionSpec( "[1.2,)" );
252        range2 = VersionRange.createFromVersionSpec( "1.1" );
253        mergedRange = range1.restrict( range2 );
254        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
255        restrictions = mergedRange.getRestrictions();
256        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
257        restriction = restrictions.get( 0 );
258        assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() );
259        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
260        assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() );
261        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
262
263        range1 = VersionRange.createFromVersionSpec( "(,1.2]" );
264        range2 = VersionRange.createFromVersionSpec( "1.1" );
265        mergedRange = range1.restrict( range2 );
266        assertEquals( CHECK_VERSION_RECOMMENDATION, "1.1", mergedRange.getRecommendedVersion().toString() );
267        restrictions = mergedRange.getRestrictions();
268        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
269        restriction = restrictions.get( 0 );
270        assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() );
271        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
272        assertEquals( CHECK_UPPER_BOUND, "1.2", restriction.getUpperBound().toString() );
273        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
274
275        range1 = VersionRange.createFromVersionSpec( "(,1.1]" );
276        range2 = VersionRange.createFromVersionSpec( "1.1" );
277        mergedRange = range1.restrict( range2 );
278        assertEquals( CHECK_VERSION_RECOMMENDATION, "1.1", mergedRange.getRecommendedVersion().toString() );
279        restrictions = mergedRange.getRestrictions();
280        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
281        restriction = restrictions.get( 0 );
282        assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() );
283        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
284        assertEquals( CHECK_UPPER_BOUND, "1.1", restriction.getUpperBound().toString() );
285        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
286
287        range1 = VersionRange.createFromVersionSpec( "(,1.1)" );
288        range2 = VersionRange.createFromVersionSpec( "1.1" );
289        mergedRange = range1.restrict( range2 );
290        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
291        restrictions = mergedRange.getRestrictions();
292        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
293        restriction = restrictions.get( 0 );
294        assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() );
295        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
296        assertEquals( CHECK_UPPER_BOUND, "1.1", restriction.getUpperBound().toString() );
297        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
298
299        range1 = VersionRange.createFromVersionSpec( "(,1.0]" );
300        range2 = VersionRange.createFromVersionSpec( "1.1" );
301        mergedRange = range1.restrict( range2 );
302        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
303        restrictions = mergedRange.getRestrictions();
304        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
305        restriction = restrictions.get( 0 );
306        assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() );
307        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
308        assertEquals( CHECK_UPPER_BOUND, "1.0", restriction.getUpperBound().toString() );
309        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
310
311        range1 = VersionRange.createFromVersionSpec( "(,1.0], [1.1,)" );
312        range2 = VersionRange.createFromVersionSpec( "1.2" );
313        mergedRange = range1.restrict( range2 );
314        assertEquals( CHECK_VERSION_RECOMMENDATION, "1.2", mergedRange.getRecommendedVersion().toString() );
315        restrictions = mergedRange.getRestrictions();
316        assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() );
317        restriction = restrictions.get( 0 );
318        assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() );
319        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
320        assertEquals( CHECK_UPPER_BOUND, "1.0", restriction.getUpperBound().toString() );
321        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
322        restriction = restrictions.get( 1 );
323        assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() );
324        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
325        assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() );
326        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
327
328        range1 = VersionRange.createFromVersionSpec( "(,1.0], [1.1,)" );
329        range2 = VersionRange.createFromVersionSpec( "1.0.5" );
330        mergedRange = range1.restrict( range2 );
331        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
332        restrictions = mergedRange.getRestrictions();
333        assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() );
334        restriction = restrictions.get( 0 );
335        assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() );
336        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
337        assertEquals( CHECK_UPPER_BOUND, "1.0", restriction.getUpperBound().toString() );
338        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
339        restriction = restrictions.get( 1 );
340        assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() );
341        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
342        assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() );
343        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
344
345        range1 = VersionRange.createFromVersionSpec( "(,1.1), (1.1,)" );
346        range2 = VersionRange.createFromVersionSpec( "1.1" );
347        mergedRange = range1.restrict( range2 );
348        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
349        restrictions = mergedRange.getRestrictions();
350        assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() );
351        restriction = restrictions.get( 0 );
352        assertNull( CHECK_LOWER_BOUND, restriction.getLowerBound() );
353        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
354        assertEquals( CHECK_UPPER_BOUND, "1.1", restriction.getUpperBound().toString() );
355        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
356        restriction = restrictions.get( 1 );
357        assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() );
358        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
359        assertNull( CHECK_UPPER_BOUND, restriction.getUpperBound() );
360        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
361
362        range1 = VersionRange.createFromVersionSpec( "[1.1,1.3]" );
363        range2 = VersionRange.createFromVersionSpec( "(1.1,)" );
364        mergedRange = range1.restrict( range2 );
365        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
366        restrictions = mergedRange.getRestrictions();
367        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
368        restriction = restrictions.get( 0 );
369        assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() );
370        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
371        assertEquals( CHECK_UPPER_BOUND, "1.3", restriction.getUpperBound().toString() );
372        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
373
374        range1 = VersionRange.createFromVersionSpec( "(,1.3)" );
375        range2 = VersionRange.createFromVersionSpec( "[1.2,1.3]" );
376        mergedRange = range1.restrict( range2 );
377        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
378        restrictions = mergedRange.getRestrictions();
379        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
380        restriction = restrictions.get( 0 );
381        assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() );
382        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
383        assertEquals( CHECK_UPPER_BOUND, "1.3", restriction.getUpperBound().toString() );
384        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
385
386        range1 = VersionRange.createFromVersionSpec( "[1.1,1.3]" );
387        range2 = VersionRange.createFromVersionSpec( "[1.2,)" );
388        mergedRange = range1.restrict( range2 );
389        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
390        restrictions = mergedRange.getRestrictions();
391        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
392        restriction = restrictions.get( 0 );
393        assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() );
394        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
395        assertEquals( CHECK_UPPER_BOUND, "1.3", restriction.getUpperBound().toString() );
396        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
397
398        range1 = VersionRange.createFromVersionSpec( "(,1.3]" );
399        range2 = VersionRange.createFromVersionSpec( "[1.2,1.4]" );
400        mergedRange = range1.restrict( range2 );
401        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
402        restrictions = mergedRange.getRestrictions();
403        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
404        restriction = restrictions.get( 0 );
405        assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() );
406        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
407        assertEquals( CHECK_UPPER_BOUND, "1.3", restriction.getUpperBound().toString() );
408        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
409
410        range1 = VersionRange.createFromVersionSpec( "(1.2,1.3]" );
411        range2 = VersionRange.createFromVersionSpec( "[1.1,1.4]" );
412        mergedRange = range1.restrict( range2 );
413        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
414        restrictions = mergedRange.getRestrictions();
415        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
416        restriction = restrictions.get( 0 );
417        assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() );
418        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
419        assertEquals( CHECK_UPPER_BOUND, "1.3", restriction.getUpperBound().toString() );
420        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
421
422        range1 = VersionRange.createFromVersionSpec( "(1.2,1.3)" );
423        range2 = VersionRange.createFromVersionSpec( "[1.1,1.4]" );
424        mergedRange = range1.restrict( range2 );
425        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
426        restrictions = mergedRange.getRestrictions();
427        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
428        restriction = restrictions.get( 0 );
429        assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() );
430        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
431        assertEquals( CHECK_UPPER_BOUND, "1.3", restriction.getUpperBound().toString() );
432        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
433
434        range1 = VersionRange.createFromVersionSpec( "[1.2,1.3)" );
435        range2 = VersionRange.createFromVersionSpec( "[1.1,1.4]" );
436        mergedRange = range1.restrict( range2 );
437        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
438        restrictions = mergedRange.getRestrictions();
439        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
440        restriction = restrictions.get( 0 );
441        assertEquals( CHECK_LOWER_BOUND, "1.2", restriction.getLowerBound().toString() );
442        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
443        assertEquals( CHECK_UPPER_BOUND, "1.3", restriction.getUpperBound().toString() );
444        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
445
446        range1 = VersionRange.createFromVersionSpec( "[1.0,1.1]" );
447        range2 = VersionRange.createFromVersionSpec( "[1.1,1.4]" );
448        mergedRange = range1.restrict( range2 );
449        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
450        restrictions = mergedRange.getRestrictions();
451        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
452        restriction = restrictions.get( 0 );
453        assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() );
454        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
455        assertEquals( CHECK_UPPER_BOUND, "1.1", restriction.getUpperBound().toString() );
456        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
457
458        range1 = VersionRange.createFromVersionSpec( "[1.0,1.1)" );
459        range2 = VersionRange.createFromVersionSpec( "[1.1,1.4]" );
460        mergedRange = range1.restrict( range2 );
461        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
462        restrictions = mergedRange.getRestrictions();
463        assertEquals( CHECK_NUM_RESTRICTIONS, 0, restrictions.size() );
464
465        range1 = VersionRange.createFromVersionSpec( "[1.0,1.2],[1.3,1.5]" );
466        range2 = VersionRange.createFromVersionSpec( "[1.1]" );
467        mergedRange = range1.restrict( range2 );
468        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
469        restrictions = mergedRange.getRestrictions();
470        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
471        restriction = restrictions.get( 0 );
472        assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() );
473        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
474        assertEquals( CHECK_UPPER_BOUND, "1.1", restriction.getUpperBound().toString() );
475        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
476
477        range1 = VersionRange.createFromVersionSpec( "[1.0,1.2],[1.3,1.5]" );
478        range2 = VersionRange.createFromVersionSpec( "[1.4]" );
479        mergedRange = range1.restrict( range2 );
480        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
481        restrictions = mergedRange.getRestrictions();
482        assertEquals( CHECK_NUM_RESTRICTIONS, 1, restrictions.size() );
483        restriction = restrictions.get( 0 );
484        assertEquals( CHECK_LOWER_BOUND, "1.4", restriction.getLowerBound().toString() );
485        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
486        assertEquals( CHECK_UPPER_BOUND, "1.4", restriction.getUpperBound().toString() );
487        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
488
489        range1 = VersionRange.createFromVersionSpec( "[1.0,1.2],[1.3,1.5]" );
490        range2 = VersionRange.createFromVersionSpec( "[1.1,1.4]" );
491        mergedRange = range1.restrict( range2 );
492        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
493        restrictions = mergedRange.getRestrictions();
494        assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() );
495        restriction = restrictions.get( 0 );
496        assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() );
497        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
498        assertEquals( CHECK_UPPER_BOUND, "1.2", restriction.getUpperBound().toString() );
499        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
500        restriction = restrictions.get( 1 );
501        assertEquals( CHECK_LOWER_BOUND, "1.3", restriction.getLowerBound().toString() );
502        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
503        assertEquals( CHECK_UPPER_BOUND, "1.4", 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.1,1.4]" );
508        mergedRange = range1.restrict( range2 );
509        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
510        restrictions = mergedRange.getRestrictions();
511        assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() );
512        restriction = restrictions.get( 0 );
513        assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() );
514        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
515        assertEquals( CHECK_UPPER_BOUND, "1.2", restriction.getUpperBound().toString() );
516        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
517        restriction = restrictions.get( 1 );
518        assertEquals( CHECK_LOWER_BOUND, "1.3", restriction.getLowerBound().toString() );
519        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
520        assertEquals( CHECK_UPPER_BOUND, "1.4", restriction.getUpperBound().toString() );
521        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
522
523        range1 = VersionRange.createFromVersionSpec( "[1.0,1.2],[1.3,1.5]" );
524        range2 = VersionRange.createFromVersionSpec( "(1.1,1.4)" );
525        mergedRange = range1.restrict( range2 );
526        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
527        restrictions = mergedRange.getRestrictions();
528        assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() );
529        restriction = restrictions.get( 0 );
530        assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() );
531        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
532        assertEquals( CHECK_UPPER_BOUND, "1.2", restriction.getUpperBound().toString() );
533        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
534        restriction = restrictions.get( 1 );
535        assertEquals( CHECK_LOWER_BOUND, "1.3", restriction.getLowerBound().toString() );
536        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
537        assertEquals( CHECK_UPPER_BOUND, "1.4", restriction.getUpperBound().toString() );
538        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
539
540        range1 = VersionRange.createFromVersionSpec( "[1.0,1.2),(1.3,1.5]" );
541        range2 = VersionRange.createFromVersionSpec( "(1.1,1.4)" );
542        mergedRange = range1.restrict( range2 );
543        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
544        restrictions = mergedRange.getRestrictions();
545        assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() );
546        restriction = restrictions.get( 0 );
547        assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() );
548        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
549        assertEquals( CHECK_UPPER_BOUND, "1.2", restriction.getUpperBound().toString() );
550        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
551        restriction = restrictions.get( 1 );
552        assertEquals( CHECK_LOWER_BOUND, "1.3", restriction.getLowerBound().toString() );
553        assertFalse( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
554        assertEquals( CHECK_UPPER_BOUND, "1.4", restriction.getUpperBound().toString() );
555        assertFalse( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
556
557        range1 = VersionRange.createFromVersionSpec( "(,1.1),(1.4,)" );
558        range2 = VersionRange.createFromVersionSpec( "[1.1,1.4]" );
559        mergedRange = range1.restrict( range2 );
560        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
561        restrictions = mergedRange.getRestrictions();
562        assertEquals( CHECK_NUM_RESTRICTIONS, 0, restrictions.size() );
563
564        range1 = VersionRange.createFromVersionSpec( "(,1.1],[1.4,)" );
565        range2 = VersionRange.createFromVersionSpec( "(1.1,1.4)" );
566        mergedRange = range1.restrict( range2 );
567        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
568        restrictions = mergedRange.getRestrictions();
569        assertEquals( CHECK_NUM_RESTRICTIONS, 0, restrictions.size() );
570
571        range1 = VersionRange.createFromVersionSpec( "[,1.1],[1.4,]" );
572        range2 = VersionRange.createFromVersionSpec( "[1.2,1.3]" );
573        mergedRange = range1.restrict( range2 );
574        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
575        restrictions = mergedRange.getRestrictions();
576        assertEquals( CHECK_NUM_RESTRICTIONS, 0, restrictions.size() );
577
578        range1 = VersionRange.createFromVersionSpec( "[1.0,1.2],[1.3,1.5]" );
579        range2 = VersionRange.createFromVersionSpec( "[1.1,1.4],[1.6,]" );
580        mergedRange = range1.restrict( range2 );
581        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
582        restrictions = mergedRange.getRestrictions();
583        assertEquals( CHECK_NUM_RESTRICTIONS, 2, restrictions.size() );
584        restriction = restrictions.get( 0 );
585        assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() );
586        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
587        assertEquals( CHECK_UPPER_BOUND, "1.2", restriction.getUpperBound().toString() );
588        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
589        restriction = restrictions.get( 1 );
590        assertEquals( CHECK_LOWER_BOUND, "1.3", restriction.getLowerBound().toString() );
591        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
592        assertEquals( CHECK_UPPER_BOUND, "1.4", restriction.getUpperBound().toString() );
593        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
594
595        range1 = VersionRange.createFromVersionSpec( "[1.0,1.2],[1.3,1.5]" );
596        range2 = VersionRange.createFromVersionSpec( "[1.1,1.4],[1.5,]" );
597        mergedRange = range1.restrict( range2 );
598        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
599        restrictions = mergedRange.getRestrictions();
600        assertEquals( CHECK_NUM_RESTRICTIONS, 3, restrictions.size() );
601        restriction = restrictions.get( 0 );
602        assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() );
603        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
604        assertEquals( CHECK_UPPER_BOUND, "1.2", restriction.getUpperBound().toString() );
605        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
606        restriction = restrictions.get( 1 );
607        assertEquals( CHECK_LOWER_BOUND, "1.3", restriction.getLowerBound().toString() );
608        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
609        assertEquals( CHECK_UPPER_BOUND, "1.4", restriction.getUpperBound().toString() );
610        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
611        restriction = restrictions.get( 2 );
612        assertEquals( CHECK_LOWER_BOUND, "1.5", restriction.getLowerBound().toString() );
613        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
614        assertEquals( CHECK_UPPER_BOUND, "1.5", restriction.getUpperBound().toString() );
615        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
616
617        range1 = VersionRange.createFromVersionSpec( "[1.0,1.2],[1.3,1.7]" );
618        range2 = VersionRange.createFromVersionSpec( "[1.1,1.4],[1.5,1.6]" );
619        mergedRange = range1.restrict( range2 );
620        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
621        restrictions = mergedRange.getRestrictions();
622        assertEquals( CHECK_NUM_RESTRICTIONS, 3, restrictions.size() );
623        restriction = restrictions.get( 0 );
624        assertEquals( CHECK_LOWER_BOUND, "1.1", restriction.getLowerBound().toString() );
625        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
626        assertEquals( CHECK_UPPER_BOUND, "1.2", restriction.getUpperBound().toString() );
627        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
628        restriction = restrictions.get( 1 );
629        assertEquals( CHECK_LOWER_BOUND, "1.3", restriction.getLowerBound().toString() );
630        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
631        assertEquals( CHECK_UPPER_BOUND, "1.4", restriction.getUpperBound().toString() );
632        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
633        restriction = restrictions.get( 2 );
634        assertEquals( CHECK_LOWER_BOUND, "1.5", restriction.getLowerBound().toString() );
635        assertTrue( CHECK_LOWER_BOUND_INCLUSIVE, restriction.isLowerBoundInclusive() );
636        assertEquals( CHECK_UPPER_BOUND, "1.6", restriction.getUpperBound().toString() );
637        assertTrue( CHECK_UPPER_BOUND_INCLUSIVE, restriction.isUpperBoundInclusive() );
638
639        // test restricting empty sets
640        range1 = VersionRange.createFromVersionSpec( "[,1.1],[1.4,]" );
641        range2 = VersionRange.createFromVersionSpec( "[1.2,1.3]" );
642        range1 = range1.restrict( range2 );
643        mergedRange = range1.restrict( range2 );
644        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
645        restrictions = mergedRange.getRestrictions();
646        assertEquals( CHECK_NUM_RESTRICTIONS, 0, restrictions.size() );
647
648        range1 = VersionRange.createFromVersionSpec( "[,1.1],[1.4,]" );
649        range2 = VersionRange.createFromVersionSpec( "[1.2,1.3]" );
650        range2 = range1.restrict( range2 );
651        mergedRange = range1.restrict( range2 );
652        assertNull( CHECK_VERSION_RECOMMENDATION, mergedRange.getRecommendedVersion() );
653        restrictions = mergedRange.getRestrictions();
654        assertEquals( CHECK_NUM_RESTRICTIONS, 0, restrictions.size() );
655    }
656
657    public void testReleaseRangeBoundsContainsSnapshots()
658        throws InvalidVersionSpecificationException
659    {
660        VersionRange range = VersionRange.createFromVersionSpec( "[1.0,1.2]" );
661
662        assertTrue( range.containsVersion( new DefaultArtifactVersion( "1.1-SNAPSHOT" ) ) );
663        assertTrue( range.containsVersion( new DefaultArtifactVersion( "1.2-SNAPSHOT" ) ) );
664        assertFalse( range.containsVersion( new DefaultArtifactVersion( "1.0-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}