Modified unittest to use new argument syntax.

utils/tests/pub/version_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library version_test;
 
 import '../../../pkg/unittest/unittest.dart';
 import '../../pub/utils.dart';
 import '../../pub/version.dart';
 
@@ skipping 63 matching lines @@
             expect(a <= b, equals(i <= j));
             expect(a >= b, equals(i >= j));
             expect(a == b, equals(i == j));
             expect(a != b, equals(i != j));
           }
         }
       });
     });
 
     test('allows()', () {
-      expect(v123.allows(v123));
-      expect(!v123.allows(v114));
-      expect(!v123.allows(v124));
+      expect(v123.allows(v123), isTrue);
+      expect(v123.allows(v114), isFalse);
+      expect(v123.allows(v124), isFalse);
     });
 
     test('intersect()', () {
       // Intersecting the same version returns the version.
       expect(v123.intersect(v123), equals(v123));
 
       // Intersecting a different version allows no versions.
-      expect(v123.intersect(v114).isEmpty);
+      expect(v123.intersect(v114).isEmpty, isTrue);
 
       // Intersecting a range returns the version if the range allows it.
       expect(v123.intersect(new VersionRange(min: v114, max: v124)),
           equals(v123));
 
       // Intersecting a range allows no versions if the range doesn't allow it.
-      expect(v114.intersect(new VersionRange(min: v123, max: v124)).isEmpty);
+      expect(v114.intersect(new VersionRange(min: v123, max: v124)).isEmpty,
+          isTrue);
     });
 
     test('isEmpty', () {
-      expect(!v123.isEmpty);
+      expect(v123.isEmpty, isFalse);
     });
 
     test('parse()', () {
       expect(new Version.parse('0.0.0'), equals(new Version(0, 0, 0)));
       expect(new Version.parse('12.34.56'), equals(new Version(12, 34, 56)));
 
       expect(new Version.parse('1.2.3-alpha.1'), equals(
           new Version(1, 2, 3, pre: 'alpha.1')));
       expect(new Version.parse('1.2.3-x.7.z-92'), equals(
           new Version(1, 2, 3, pre: 'x.7.z-92')));
@@ skipping 46 matching lines @@
       });
 
       test('allows omitting min and max', () {
         var range = new VersionRange();
         expect(range.min, isNull);
         expect(range.max, isNull);
       });
 
       test('takes includeMin', () {
         var range = new VersionRange(min: v123, includeMin: true);
-        expect(range.includeMin);
+        expect(range.includeMin, isTrue);
       });
 
       test('includeMin defaults to false if omitted', () {
         var range = new VersionRange(min: v123);
         expect(range.includeMin, isFalse);
       });
 
       test('takes includeMax', () {
         var range = new VersionRange(max: v123, includeMax: true);
-        expect(range.includeMax);
+        expect(range.includeMax, isTrue);
       });
 
       test('includeMax defaults to false if omitted', () {
         var range = new VersionRange(max: v123);
         expect(range.includeMax, isFalse);
       });
 
       test('throws if min > max', () {
         throwsIllegalArg(() => new VersionRange(min: v124, max: v123));
       });
     });
 
     group('allows()', () {
       test('version must be greater than min', () {
         var range = new VersionRange(min: v123, max: v234);
 
-        expect(!range.allows(new Version.parse('1.2.2')));
-        expect(!range.allows(new Version.parse('1.2.3')));
-        expect(range.allows(new Version.parse('1.3.3')));
-        expect(range.allows(new Version.parse('2.3.3')));
+        expect(range.allows(new Version.parse('1.2.2')), isFalse);
+        expect(range.allows(new Version.parse('1.2.3')), isFalse);
+        expect(range.allows(new Version.parse('1.3.3')), isTrue);
+        expect(range.allows(new Version.parse('2.3.3')), isTrue);
       });
 
       test('version must be min or greater if includeMin', () {
         var range = new VersionRange(min: v123, max: v234, includeMin: true);
 
-        expect(!range.allows(new Version.parse('1.2.2')));
-        expect(range.allows(new Version.parse('1.2.3')));
-        expect(range.allows(new Version.parse('1.3.3')));
-        expect(range.allows(new Version.parse('2.3.3')));
+        expect(range.allows(new Version.parse('1.2.2')), isFalse);
+        expect(range.allows(new Version.parse('1.2.3')), isTrue);
+        expect(range.allows(new Version.parse('1.3.3')), isTrue);
+        expect(range.allows(new Version.parse('2.3.3')), isTrue);
       });
 
       test('version must be less than max', () {
         var range = new VersionRange(min: v123, max: v234);
 
-        expect(range.allows(new Version.parse('2.3.3')));
-        expect(!range.allows(new Version.parse('2.3.4')));
-        expect(!range.allows(new Version.parse('2.4.3')));
+        expect(range.allows(new Version.parse('2.3.3')), isTrue);
+        expect(range.allows(new Version.parse('2.3.4')), isFalse);
+        expect(range.allows(new Version.parse('2.4.3')), isFalse);
       });
 
       test('version must be max or less if includeMax', () {
         var range = new VersionRange(min: v123, max: v234, includeMax: true);
 
-        expect(range.allows(new Version.parse('2.3.3')));
-        expect(range.allows(new Version.parse('2.3.4')));
-        expect(!range.allows(new Version.parse('2.4.3')));
+        expect(range.allows(new Version.parse('2.3.3')), isTrue);
+        expect(range.allows(new Version.parse('2.3.4')), isTrue);
+        expect(range.allows(new Version.parse('2.4.3')), isFalse);
       });
 
       test('has no min if one was not set', () {
         var range = new VersionRange(max: v123);
 
-        expect(range.allows(new Version.parse('0.0.0')));
-        expect(!range.allows(new Version.parse('1.2.3')));
+        expect(range.allows(new Version.parse('0.0.0')), isTrue);
+        expect(range.allows(new Version.parse('1.2.3')), isFalse);
       });
 
       test('has no max if one was not set', () {
         var range = new VersionRange(min: v123);
 
-        expect(!range.allows(new Version.parse('1.2.3')));
-        expect(range.allows(new Version.parse('1.3.3')));
-        expect(range.allows(new Version.parse('999.3.3')));
+        expect(range.allows(new Version.parse('1.2.3')), isFalse);
+        expect(range.allows(new Version.parse('1.3.3')), isTrue);
+        expect(range.allows(new Version.parse('999.3.3')), isTrue);
       });
 
       test('allows any version if there is no min or max', () {
         var range = new VersionRange();
 
-        expect(range.allows(new Version.parse('0.0.0')));
-        expect(range.allows(new Version.parse('999.99.9')));
+        expect(range.allows(new Version.parse('0.0.0')), isTrue);
+        expect(range.allows(new Version.parse('999.99.9')), isTrue);
       });
     });
 
     group('intersect()', () {
       test('two overlapping ranges', () {
         var a = new VersionRange(min: v123, max: v250);
         var b = new VersionRange(min: v200, max: v300);
         var intersect = a.intersect(b);
         expect(intersect.min, equals(v200));
         expect(intersect.max, equals(v250));
         expect(intersect.includeMin, isFalse);
         expect(intersect.includeMax, isFalse);
       });
 
       test('a non-overlapping range allows no versions', () {
         var a = new VersionRange(min: v114, max: v124);
         var b = new VersionRange(min: v200, max: v250);
-        expect(a.intersect(b).isEmpty);
+        expect(a.intersect(b).isEmpty, isTrue);
       });
 
       test('adjacent ranges allow no versions if exclusive', () {
         var a = new VersionRange(min: v114, max: v124, includeMax: false);
         var b = new VersionRange(min: v124, max: v200, includeMin: true);
-        expect(a.intersect(b).isEmpty);
+        expect(a.intersect(b).isEmpty, isTrue);
       });
 
       test('adjacent ranges allow version if inclusive', () {
         var a = new VersionRange(min: v114, max: v124, includeMax: true);
         var b = new VersionRange(min: v124, max: v200, includeMin: true);
         expect(a.intersect(b), equals(v124));
       });
 
       test('with an open range', () {
         var open = new VersionRange();
         var a = new VersionRange(min: v114, max: v124);
         expect(open.intersect(open), equals(open));
         expect(a.intersect(open), equals(a));
       });
 
       test('returns the version if the range allows it', () {
         expect(new VersionRange(min: v114, max: v124).intersect(v123),
             equals(v123));
-        expect(new VersionRange(min: v123, max: v124).intersect(v114).isEmpty);
+        expect(new VersionRange(min: v123, max: v124).intersect(v114).isEmpty,
+            isTrue);
       });
     });
 
     test('isEmpty', () {
       expect(new VersionRange().isEmpty, isFalse);
       expect(new VersionRange(min: v123, max: v124).isEmpty, isFalse);
     });
   });
 
   group('VersionConstraint', () {
     test('empty', () {
-      expect(new VersionConstraint.empty().isEmpty);
+      expect(new VersionConstraint.empty().isEmpty, isTrue);
     });
 
     group('parse()', () {
       test('parses an exact version', () {
         var constraint = new VersionConstraint.parse('1.2.3-alpha');
-        expect(constraint is Version);
+        expect(constraint is Version, isTrue);
         expect(constraint, equals(new Version(1, 2, 3, pre: 'alpha')));
       });
 
       test('parses "any"', () {
         var constraint = new VersionConstraint.parse('any');
-        expect(constraint is VersionConstraint);
+        expect(constraint is VersionConstraint, isTrue);
         expect(constraint, allows([
             new Version.parse('0.0.0'),
             new Version.parse('1.2.3'),
             new Version.parse('12345.678.90')]));
       });
 
       test('parses a ">" minimum version', () {
         expect(new VersionConstraint.parse('>1.2.3'), allows([
             new Version.parse('1.2.3+foo'),
             new Version.parse('1.2.4')]));
@@ skipping 97 matching lines @@
 
 Matcher allows(List<Version> versions) =>
     new VersionConstraintMatcher(versions, true);
 
 Matcher doesNotAllow(List<Version> versions) =>
     new VersionConstraintMatcher(versions, false);
 
 throwsIllegalArg(function) {
   expect(function, throwsA((e) => e is ArgumentError));
 }