1 package org.apache.maven.artifact.versioning;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.util.List;
23
24 import junit.framework.TestCase;
25
26 import org.apache.maven.artifact.Artifact;
27
28
29
30
31
32
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
169 checkInvalidRange( "[1.0,1.2),(1.1,1.3]" );
170
171 checkInvalidRange( "[1.1,1.3),(1.0,1.2]" );
172
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
183
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
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
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
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
729 }
730 }