| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | |
| 2 // for details. All rights reserved. Use of this source code is governed by a | |
| 3 // BSD-style license that can be found in the LICENSE file. | |
| 4 | |
| 5 library version_test; | |
| 6 | |
| 7 import 'package:unittest/unittest.dart'; | |
| 8 import 'test_pub.dart'; | |
| 9 import '../lib/src/version.dart'; | |
| 10 | |
| 11 main() { | |
| 12 initConfig(); | |
| 13 | |
| 14 final v114 = new Version.parse('1.1.4'); | |
| 15 final v123 = new Version.parse('1.2.3'); | |
| 16 final v124 = new Version.parse('1.2.4'); | |
| 17 final v130 = new Version.parse('1.3.0'); | |
| 18 final v140 = new Version.parse('1.4.0'); | |
| 19 final v200 = new Version.parse('2.0.0'); | |
| 20 final v201 = new Version.parse('2.0.1'); | |
| 21 final v234 = new Version.parse('2.3.4'); | |
| 22 final v250 = new Version.parse('2.5.0'); | |
| 23 final v300 = new Version.parse('3.0.0'); | |
| 24 | |
| 25 group('Version', () { | |
| 26 test('none', () { | |
| 27 expect(Version.none.toString(), equals('0.0.0')); | |
| 28 }); | |
| 29 | |
| 30 group('constructor', () { | |
| 31 test('throws on negative numbers', () { | |
| 32 throwsIllegalArg(() => new Version(-1, 1, 1)); | |
| 33 throwsIllegalArg(() => new Version(1, -1, 1)); | |
| 34 throwsIllegalArg(() => new Version(1, 1, -1)); | |
| 35 }); | |
| 36 }); | |
| 37 | |
| 38 group('comparison', () { | |
| 39 // A correctly sorted list of versions. | |
| 40 var versions = [ | |
| 41 '1.0.0-alpha', | |
| 42 '1.0.0-alpha.1', | |
| 43 '1.0.0-beta.2', | |
| 44 '1.0.0-beta.11', | |
| 45 '1.0.0-rc.1', | |
| 46 '1.0.0-rc.1+build.1', | |
| 47 '1.0.0', | |
| 48 '1.0.0+0.3.7', | |
| 49 '1.3.7+build', | |
| 50 '1.3.7+build.2.b8f12d7', | |
| 51 '1.3.7+build.11.e0f985a', | |
| 52 '2.0.0', | |
| 53 '2.1.0', | |
| 54 '2.2.0', | |
| 55 '2.11.0', | |
| 56 '2.11.1' | |
| 57 ]; | |
| 58 | |
| 59 test('compareTo()', () { | |
| 60 // Ensure that every pair of versions compares in the order that it | |
| 61 // appears in the list. | |
| 62 for (var i = 0; i < versions.length; i++) { | |
| 63 for (var j = 0; j < versions.length; j++) { | |
| 64 var a = new Version.parse(versions[i]); | |
| 65 var b = new Version.parse(versions[j]); | |
| 66 var expectation = i.compareTo(j); | |
| 67 expect(a.compareTo(b), equals(expectation)); | |
| 68 } | |
| 69 } | |
| 70 }); | |
| 71 | |
| 72 test('operators', () { | |
| 73 for (var i = 0; i < versions.length; i++) { | |
| 74 for (var j = 0; j < versions.length; j++) { | |
| 75 var a = new Version.parse(versions[i]); | |
| 76 var b = new Version.parse(versions[j]); | |
| 77 expect(a < b, equals(i < j)); | |
| 78 expect(a > b, equals(i > j)); | |
| 79 expect(a <= b, equals(i <= j)); | |
| 80 expect(a >= b, equals(i >= j)); | |
| 81 expect(a == b, equals(i == j)); | |
| 82 expect(a != b, equals(i != j)); | |
| 83 } | |
| 84 } | |
| 85 }); | |
| 86 | |
| 87 test('equality', () { | |
| 88 expect(new Version.parse('01.2.3'), equals(new Version.parse('1.2.3'))); | |
| 89 expect(new Version.parse('1.02.3'), equals(new Version.parse('1.2.3'))); | |
| 90 expect(new Version.parse('1.2.03'), equals(new Version.parse('1.2.3'))); | |
| 91 expect(new Version.parse('1.2.3-01'), | |
| 92 equals(new Version.parse('1.2.3-1'))); | |
| 93 expect(new Version.parse('1.2.3+01'), | |
| 94 equals(new Version.parse('1.2.3+1'))); | |
| 95 }); | |
| 96 }); | |
| 97 | |
| 98 test('allows()', () { | |
| 99 expect(v123.allows(v123), isTrue); | |
| 100 expect(v123.allows(v114), isFalse); | |
| 101 expect(v123.allows(v124), isFalse); | |
| 102 }); | |
| 103 | |
| 104 test('intersect()', () { | |
| 105 // Intersecting the same version returns the version. | |
| 106 expect(v123.intersect(v123), equals(v123)); | |
| 107 | |
| 108 // Intersecting a different version allows no versions. | |
| 109 expect(v123.intersect(v114).isEmpty, isTrue); | |
| 110 | |
| 111 // Intersecting a range returns the version if the range allows it. | |
| 112 expect(v123.intersect(new VersionRange(min: v114, max: v124)), | |
| 113 equals(v123)); | |
| 114 | |
| 115 // Intersecting a range allows no versions if the range doesn't allow it. | |
| 116 expect(v114.intersect(new VersionRange(min: v123, max: v124)).isEmpty, | |
| 117 isTrue); | |
| 118 }); | |
| 119 | |
| 120 test('isEmpty', () { | |
| 121 expect(v123.isEmpty, isFalse); | |
| 122 }); | |
| 123 | |
| 124 test('nextMajor', () { | |
| 125 expect(v123.nextMajor, equals(v200)); | |
| 126 expect(v114.nextMajor, equals(v200)); | |
| 127 expect(v200.nextMajor, equals(v300)); | |
| 128 | |
| 129 // Ignores pre-release if not on a major version. | |
| 130 expect(new Version.parse('1.2.3-dev').nextMajor, equals(v200)); | |
| 131 | |
| 132 // Just removes it if on a major version. | |
| 133 expect(new Version.parse('2.0.0-dev').nextMajor, equals(v200)); | |
| 134 | |
| 135 // Strips build suffix. | |
| 136 expect(new Version.parse('1.2.3+patch').nextMajor, equals(v200)); | |
| 137 }); | |
| 138 | |
| 139 test('nextMinor', () { | |
| 140 expect(v123.nextMinor, equals(v130)); | |
| 141 expect(v130.nextMinor, equals(v140)); | |
| 142 | |
| 143 // Ignores pre-release if not on a minor version. | |
| 144 expect(new Version.parse('1.2.3-dev').nextMinor, equals(v130)); | |
| 145 | |
| 146 // Just removes it if on a minor version. | |
| 147 expect(new Version.parse('1.3.0-dev').nextMinor, equals(v130)); | |
| 148 | |
| 149 // Strips build suffix. | |
| 150 expect(new Version.parse('1.2.3+patch').nextMinor, equals(v130)); | |
| 151 }); | |
| 152 | |
| 153 test('nextPatch', () { | |
| 154 expect(v123.nextPatch, equals(v124)); | |
| 155 expect(v200.nextPatch, equals(v201)); | |
| 156 | |
| 157 // Just removes pre-release version if present. | |
| 158 expect(new Version.parse('1.2.4-dev').nextPatch, equals(v124)); | |
| 159 | |
| 160 // Strips build suffix. | |
| 161 expect(new Version.parse('1.2.3+patch').nextPatch, equals(v124)); | |
| 162 }); | |
| 163 | |
| 164 test('parse()', () { | |
| 165 expect(new Version.parse('0.0.0'), equals(new Version(0, 0, 0))); | |
| 166 expect(new Version.parse('12.34.56'), equals(new Version(12, 34, 56))); | |
| 167 | |
| 168 expect(new Version.parse('1.2.3-alpha.1'), equals( | |
| 169 new Version(1, 2, 3, pre: 'alpha.1'))); | |
| 170 expect(new Version.parse('1.2.3-x.7.z-92'), equals( | |
| 171 new Version(1, 2, 3, pre: 'x.7.z-92'))); | |
| 172 | |
| 173 expect(new Version.parse('1.2.3+build.1'), equals( | |
| 174 new Version(1, 2, 3, build: 'build.1'))); | |
| 175 expect(new Version.parse('1.2.3+x.7.z-92'), equals( | |
| 176 new Version(1, 2, 3, build: 'x.7.z-92'))); | |
| 177 | |
| 178 expect(new Version.parse('1.0.0-rc-1+build-1'), equals( | |
| 179 new Version(1, 0, 0, pre: 'rc-1', build: 'build-1'))); | |
| 180 | |
| 181 expect(() => new Version.parse('1.0'), throwsFormatException); | |
| 182 expect(() => new Version.parse('1.2.3.4'), throwsFormatException); | |
| 183 expect(() => new Version.parse('1234'), throwsFormatException); | |
| 184 expect(() => new Version.parse('-2.3.4'), throwsFormatException); | |
| 185 expect(() => new Version.parse('1.3-pre'), throwsFormatException); | |
| 186 expect(() => new Version.parse('1.3+build'), throwsFormatException); | |
| 187 expect(() => new Version.parse('1.3+bu?!3ild'), throwsFormatException); | |
| 188 }); | |
| 189 | |
| 190 test('toString()', () { | |
| 191 expect(new Version(0, 0, 0).toString(), equals('0.0.0')); | |
| 192 expect(new Version(12, 34, 56).toString(), equals('12.34.56')); | |
| 193 | |
| 194 expect(new Version(1, 2, 3, pre: 'alpha.1').toString(), equals( | |
| 195 '1.2.3-alpha.1')); | |
| 196 expect(new Version(1, 2, 3, pre: 'x.7.z-92').toString(), equals( | |
| 197 '1.2.3-x.7.z-92')); | |
| 198 | |
| 199 expect(new Version(1, 2, 3, build: 'build.1').toString(), equals( | |
| 200 '1.2.3+build.1')); | |
| 201 expect(new Version(1, 2, 3, pre: 'pre', build: 'bui').toString(), equals( | |
| 202 '1.2.3-pre+bui')); | |
| 203 }); | |
| 204 }); | |
| 205 | |
| 206 group('VersionRange', () { | |
| 207 group('constructor', () { | |
| 208 test('takes a min and max', () { | |
| 209 var range = new VersionRange(min: v123, max: v124); | |
| 210 expect(range.isAny, isFalse); | |
| 211 expect(range.min, equals(v123)); | |
| 212 expect(range.max, equals(v124)); | |
| 213 }); | |
| 214 | |
| 215 test('allows omitting max', () { | |
| 216 var range = new VersionRange(min: v123); | |
| 217 expect(range.isAny, isFalse); | |
| 218 expect(range.min, equals(v123)); | |
| 219 expect(range.max, isNull); | |
| 220 }); | |
| 221 | |
| 222 test('allows omitting min and max', () { | |
| 223 var range = new VersionRange(); | |
| 224 expect(range.isAny, isTrue); | |
| 225 expect(range.min, isNull); | |
| 226 expect(range.max, isNull); | |
| 227 }); | |
| 228 | |
| 229 test('takes includeMin', () { | |
| 230 var range = new VersionRange(min: v123, includeMin: true); | |
| 231 expect(range.includeMin, isTrue); | |
| 232 }); | |
| 233 | |
| 234 test('includeMin defaults to false if omitted', () { | |
| 235 var range = new VersionRange(min: v123); | |
| 236 expect(range.includeMin, isFalse); | |
| 237 }); | |
| 238 | |
| 239 test('takes includeMax', () { | |
| 240 var range = new VersionRange(max: v123, includeMax: true); | |
| 241 expect(range.includeMax, isTrue); | |
| 242 }); | |
| 243 | |
| 244 test('includeMax defaults to false if omitted', () { | |
| 245 var range = new VersionRange(max: v123); | |
| 246 expect(range.includeMax, isFalse); | |
| 247 }); | |
| 248 | |
| 249 test('throws if min > max', () { | |
| 250 throwsIllegalArg(() => new VersionRange(min: v124, max: v123)); | |
| 251 }); | |
| 252 }); | |
| 253 | |
| 254 group('allows()', () { | |
| 255 test('version must be greater than min', () { | |
| 256 var range = new VersionRange(min: v123); | |
| 257 | |
| 258 expect(range.allows(new Version.parse('1.2.2')), isFalse); | |
| 259 expect(range.allows(new Version.parse('1.2.3')), isFalse); | |
| 260 expect(range.allows(new Version.parse('1.3.3')), isTrue); | |
| 261 expect(range.allows(new Version.parse('2.3.3')), isTrue); | |
| 262 }); | |
| 263 | |
| 264 test('version must be min or greater if includeMin', () { | |
| 265 var range = new VersionRange(min: v123, includeMin: true); | |
| 266 | |
| 267 expect(range.allows(new Version.parse('1.2.2')), isFalse); | |
| 268 expect(range.allows(new Version.parse('1.2.3')), isTrue); | |
| 269 expect(range.allows(new Version.parse('1.3.3')), isTrue); | |
| 270 expect(range.allows(new Version.parse('2.3.3')), isTrue); | |
| 271 }); | |
| 272 | |
| 273 test('pre-release versions of inclusive min are excluded', () { | |
| 274 var range = new VersionRange(min: v123, includeMin: true); | |
| 275 | |
| 276 expect(range.allows(new Version.parse('1.2.3-dev')), isFalse); | |
| 277 expect(range.allows(new Version.parse('1.2.4-dev')), isTrue); | |
| 278 }); | |
| 279 | |
| 280 test('version must be less than max', () { | |
| 281 var range = new VersionRange(max: v234); | |
| 282 | |
| 283 expect(range.allows(new Version.parse('2.3.3')), isTrue); | |
| 284 expect(range.allows(new Version.parse('2.3.4')), isFalse); | |
| 285 expect(range.allows(new Version.parse('2.4.3')), isFalse); | |
| 286 }); | |
| 287 | |
| 288 test('pre-release versions of non-pre-release max are excluded', () { | |
| 289 var range = new VersionRange(max: v234); | |
| 290 | |
| 291 expect(range.allows(new Version.parse('2.3.3')), isTrue); | |
| 292 expect(range.allows(new Version.parse('2.3.4-dev')), isFalse); | |
| 293 expect(range.allows(new Version.parse('2.3.4')), isFalse); | |
| 294 }); | |
| 295 | |
| 296 test('pre-release versions of pre-release max are included', () { | |
| 297 var range = new VersionRange(max: new Version.parse('2.3.4-dev.2')); | |
| 298 | |
| 299 expect(range.allows(new Version.parse('2.3.4-dev.1')), isTrue); | |
| 300 expect(range.allows(new Version.parse('2.3.4-dev.2')), isFalse); | |
| 301 expect(range.allows(new Version.parse('2.3.4-dev.3')), isFalse); | |
| 302 }); | |
| 303 | |
| 304 test('version must be max or less if includeMax', () { | |
| 305 var range = new VersionRange(min: v123, max: v234, includeMax: true); | |
| 306 | |
| 307 expect(range.allows(new Version.parse('2.3.3')), isTrue); | |
| 308 expect(range.allows(new Version.parse('2.3.4')), isTrue); | |
| 309 expect(range.allows(new Version.parse('2.4.3')), isFalse); | |
| 310 | |
| 311 // Pre-releases of the max are allowed. | |
| 312 expect(range.allows(new Version.parse('2.3.4-dev')), isTrue); | |
| 313 }); | |
| 314 | |
| 315 test('has no min if one was not set', () { | |
| 316 var range = new VersionRange(max: v123); | |
| 317 | |
| 318 expect(range.allows(new Version.parse('0.0.0')), isTrue); | |
| 319 expect(range.allows(new Version.parse('1.2.3')), isFalse); | |
| 320 }); | |
| 321 | |
| 322 test('has no max if one was not set', () { | |
| 323 var range = new VersionRange(min: v123); | |
| 324 | |
| 325 expect(range.allows(new Version.parse('1.2.3')), isFalse); | |
| 326 expect(range.allows(new Version.parse('1.3.3')), isTrue); | |
| 327 expect(range.allows(new Version.parse('999.3.3')), isTrue); | |
| 328 }); | |
| 329 | |
| 330 test('allows any version if there is no min or max', () { | |
| 331 var range = new VersionRange(); | |
| 332 | |
| 333 expect(range.allows(new Version.parse('0.0.0')), isTrue); | |
| 334 expect(range.allows(new Version.parse('999.99.9')), isTrue); | |
| 335 }); | |
| 336 }); | |
| 337 | |
| 338 group('intersect()', () { | |
| 339 test('two overlapping ranges', () { | |
| 340 var a = new VersionRange(min: v123, max: v250); | |
| 341 var b = new VersionRange(min: v200, max: v300); | |
| 342 var intersect = a.intersect(b); | |
| 343 expect(intersect.min, equals(v200)); | |
| 344 expect(intersect.max, equals(v250)); | |
| 345 expect(intersect.includeMin, isFalse); | |
| 346 expect(intersect.includeMax, isFalse); | |
| 347 }); | |
| 348 | |
| 349 test('a non-overlapping range allows no versions', () { | |
| 350 var a = new VersionRange(min: v114, max: v124); | |
| 351 var b = new VersionRange(min: v200, max: v250); | |
| 352 expect(a.intersect(b).isEmpty, isTrue); | |
| 353 }); | |
| 354 | |
| 355 test('adjacent ranges allow no versions if exclusive', () { | |
| 356 var a = new VersionRange(min: v114, max: v124, includeMax: false); | |
| 357 var b = new VersionRange(min: v124, max: v200, includeMin: true); | |
| 358 expect(a.intersect(b).isEmpty, isTrue); | |
| 359 }); | |
| 360 | |
| 361 test('adjacent ranges allow version if inclusive', () { | |
| 362 var a = new VersionRange(min: v114, max: v124, includeMax: true); | |
| 363 var b = new VersionRange(min: v124, max: v200, includeMin: true); | |
| 364 expect(a.intersect(b), equals(v124)); | |
| 365 }); | |
| 366 | |
| 367 test('with an open range', () { | |
| 368 var open = new VersionRange(); | |
| 369 var a = new VersionRange(min: v114, max: v124); | |
| 370 expect(open.intersect(open), equals(open)); | |
| 371 expect(a.intersect(open), equals(a)); | |
| 372 }); | |
| 373 | |
| 374 test('returns the version if the range allows it', () { | |
| 375 expect(new VersionRange(min: v114, max: v124).intersect(v123), | |
| 376 equals(v123)); | |
| 377 expect(new VersionRange(min: v123, max: v124).intersect(v114).isEmpty, | |
| 378 isTrue); | |
| 379 }); | |
| 380 }); | |
| 381 | |
| 382 test('isEmpty', () { | |
| 383 expect(new VersionRange().isEmpty, isFalse); | |
| 384 expect(new VersionRange(min: v123, max: v124).isEmpty, isFalse); | |
| 385 }); | |
| 386 }); | |
| 387 | |
| 388 group('VersionConstraint', () { | |
| 389 test('any', () { | |
| 390 expect(VersionConstraint.any.isAny, isTrue); | |
| 391 expect(VersionConstraint.any, allows([ | |
| 392 new Version.parse('0.0.0-blah'), | |
| 393 new Version.parse('1.2.3'), | |
| 394 new Version.parse('12345.678.90')])); | |
| 395 }); | |
| 396 | |
| 397 test('empty', () { | |
| 398 expect(VersionConstraint.empty.isEmpty, isTrue); | |
| 399 expect(VersionConstraint.empty.isAny, isFalse); | |
| 400 expect(VersionConstraint.empty, doesNotAllow([ | |
| 401 new Version.parse('0.0.0-blah'), | |
| 402 new Version.parse('1.2.3'), | |
| 403 new Version.parse('12345.678.90')])); | |
| 404 }); | |
| 405 | |
| 406 group('parse()', () { | |
| 407 test('parses an exact version', () { | |
| 408 var constraint = new VersionConstraint.parse('1.2.3-alpha'); | |
| 409 expect(constraint is Version, isTrue); | |
| 410 expect(constraint, equals(new Version(1, 2, 3, pre: 'alpha'))); | |
| 411 }); | |
| 412 | |
| 413 test('parses "any"', () { | |
| 414 var constraint = new VersionConstraint.parse('any'); | |
| 415 expect(constraint is VersionConstraint, isTrue); | |
| 416 expect(constraint, allows([ | |
| 417 new Version.parse('0.0.0'), | |
| 418 new Version.parse('1.2.3'), | |
| 419 new Version.parse('12345.678.90')])); | |
| 420 }); | |
| 421 | |
| 422 test('parses a ">" minimum version', () { | |
| 423 expect(new VersionConstraint.parse('>1.2.3'), allows([ | |
| 424 new Version.parse('1.2.3+foo'), | |
| 425 new Version.parse('1.2.4')])); | |
| 426 expect(new VersionConstraint.parse('>1.2.3'), doesNotAllow([ | |
| 427 new Version.parse('1.2.1'), | |
| 428 new Version.parse('1.2.3-build'), | |
| 429 new Version.parse('1.2.3')])); | |
| 430 }); | |
| 431 | |
| 432 test('parses a ">=" minimum version', () { | |
| 433 expect(new VersionConstraint.parse('>=1.2.3'), allows([ | |
| 434 new Version.parse('1.2.3'), | |
| 435 new Version.parse('1.2.3+foo'), | |
| 436 new Version.parse('1.2.4')])); | |
| 437 expect(new VersionConstraint.parse('>=1.2.3'), doesNotAllow([ | |
| 438 new Version.parse('1.2.1'), | |
| 439 new Version.parse('1.2.3-build')])); | |
| 440 }); | |
| 441 | |
| 442 test('parses a "<" maximum version', () { | |
| 443 expect(new VersionConstraint.parse('<1.2.3'), allows([ | |
| 444 new Version.parse('1.2.1'), | |
| 445 new Version.parse('1.2.2+foo')])); | |
| 446 expect(new VersionConstraint.parse('<1.2.3'), doesNotAllow([ | |
| 447 new Version.parse('1.2.3'), | |
| 448 new Version.parse('1.2.3+foo'), | |
| 449 new Version.parse('1.2.4')])); | |
| 450 }); | |
| 451 | |
| 452 test('parses a "<=" maximum version', () { | |
| 453 expect(new VersionConstraint.parse('<=1.2.3'), allows([ | |
| 454 new Version.parse('1.2.1'), | |
| 455 new Version.parse('1.2.3-build'), | |
| 456 new Version.parse('1.2.3')])); | |
| 457 expect(new VersionConstraint.parse('<=1.2.3'), doesNotAllow([ | |
| 458 new Version.parse('1.2.3+foo'), | |
| 459 new Version.parse('1.2.4')])); | |
| 460 }); | |
| 461 | |
| 462 test('parses a series of space-separated constraints', () { | |
| 463 var constraint = new VersionConstraint.parse('>1.0.0 >=1.2.3 <1.3.0'); | |
| 464 expect(constraint, allows([ | |
| 465 new Version.parse('1.2.3'), | |
| 466 new Version.parse('1.2.5')])); | |
| 467 expect(constraint, doesNotAllow([ | |
| 468 new Version.parse('1.2.3-pre'), | |
| 469 new Version.parse('1.3.0'), | |
| 470 new Version.parse('3.4.5')])); | |
| 471 }); | |
| 472 | |
| 473 test('ignores whitespace around operators', () { | |
| 474 var constraint = new VersionConstraint.parse(' >1.0.0>=1.2.3 < 1.3.0'); | |
| 475 expect(constraint, allows([ | |
| 476 new Version.parse('1.2.3'), | |
| 477 new Version.parse('1.2.5')])); | |
| 478 expect(constraint, doesNotAllow([ | |
| 479 new Version.parse('1.2.3-pre'), | |
| 480 new Version.parse('1.3.0'), | |
| 481 new Version.parse('3.4.5')])); | |
| 482 }); | |
| 483 | |
| 484 test('does not allow "any" to be mixed with other constraints', () { | |
| 485 expect(() => new VersionConstraint.parse('any 1.0.0'), | |
| 486 throwsFormatException); | |
| 487 }); | |
| 488 | |
| 489 test('throws FormatException on a bad string', () { | |
| 490 var bad = [ | |
| 491 "", " ", // Empty string. | |
| 492 "foo", // Bad text. | |
| 493 ">foo", // Bad text after operator. | |
| 494 "1.0.0 foo", "1.0.0foo", // Bad text after version. | |
| 495 "anything", // Bad text after "any". | |
| 496 "<>1.0.0", // Multiple operators. | |
| 497 "1.0.0<" // Trailing operator. | |
| 498 ]; | |
| 499 | |
| 500 for (var text in bad) { | |
| 501 expect(() => new VersionConstraint.parse(text), | |
| 502 throwsFormatException); | |
| 503 } | |
| 504 }); | |
| 505 }); | |
| 506 }); | |
| 507 } | |
| 508 | |
| 509 class VersionConstraintMatcher implements Matcher { | |
| 510 final List<Version> _expected; | |
| 511 final bool _allow; | |
| 512 | |
| 513 VersionConstraintMatcher(this._expected, this._allow); | |
| 514 | |
| 515 bool matches(item, Map matchState) => (item is VersionConstraint) && | |
| 516 _expected.every((version) => item.allows(version) == _allow); | |
| 517 | |
| 518 Description describe(Description description) => | |
| 519 description.add(' ${_allow ? "allows" : "does not allow"} versions'); | |
| 520 | |
| 521 Description describeMismatch(item, Description mismatchDescription, | |
| 522 Map matchState, bool verbose) { | |
| 523 if (item is! VersionConstraint) { | |
| 524 mismatchDescription.add('was not a VersionConstraint'); | |
| 525 return mismatchDescription; | |
| 526 } | |
| 527 | |
| 528 bool first = true; | |
| 529 for (var version in _expected) { | |
| 530 if (item.allows(version) != _allow) { | |
| 531 if (first) { | |
| 532 if (_allow) { | |
| 533 mismatchDescription.addDescriptionOf(item).add('did not allow '); | |
| 534 } else { | |
| 535 mismatchDescription.addDescriptionOf(item).add('allowed '); | |
| 536 } | |
| 537 } else { | |
| 538 mismatchDescription.add(' and '); | |
| 539 } | |
| 540 first = false; | |
| 541 | |
| 542 mismatchDescription.add(version.toString()); | |
| 543 } | |
| 544 } | |
| 545 | |
| 546 return mismatchDescription; | |
| 547 } | |
| 548 } | |
| 549 | |
| 550 Matcher allows(List<Version> versions) => | |
| 551 new VersionConstraintMatcher(versions, true); | |
| 552 | |
| 553 Matcher doesNotAllow(List<Version> versions) => | |
| 554 new VersionConstraintMatcher(versions, false); | |
| 555 | |
| 556 throwsIllegalArg(function) { | |
| 557 expect(function, throwsA((e) => e is ArgumentError)); | |
| 558 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 602253002:
Use pub_semver package in pub. (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart