New expectation functions plus convert old tests to use these.

tests/lib/args/args_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('args_test');
 
 #import('../../../lib/unittest/unittest.dart');
 #import('../../../lib/args/args.dart');
 
 main() {
@@ skipping 49 matching lines @@
     });
   });
 
   group('ArgParser.parse()', () {
     group('flags', () {
       test('are true if present', () {
         var parser = new ArgParser();
         parser.addFlag('verbose');
 
         var args = parser.parse(['--verbose']);
-        expect(args['verbose']).isTrue();
+        expect(args['verbose'], isTrue);
       });
 
       test('default if missing', () {
         var parser = new ArgParser();
         parser.addFlag('a', defaultsTo: true);
         parser.addFlag('b', defaultsTo: false);
 
         var args = parser.parse([]);
-        expect(args['a']).isTrue();
-        expect(args['b']).isFalse();
+        expect(args['a'], isTrue);
+        expect(args['b'], isFalse);
       });
 
       test('are false if missing with no default', () {
         var parser = new ArgParser();
         parser.addFlag('verbose');
 
         var args = parser.parse([]);
-        expect(args['verbose']).isFalse();
+        expect(args['verbose'], isFalse);
       });
 
       test('throws if given a value', () {
         var parser = new ArgParser();
         parser.addFlag('verbose');
 
         throwsBadFormat(parser, ['--verbose=true']);
       });
     });
 
     group('flags negated with "no-"', () {
       test('set the flag to false', () {
         var parser = new ArgParser();
         parser.addFlag('verbose');
 
         var args = parser.parse(['--no-verbose']);
-        expect(args['verbose']).isFalse();
+        expect(args['verbose'], isFalse);
       });
 
       test('set the flag to true if the flag actually starts with "no-"', () {
         var parser = new ArgParser();
         parser.addFlag('no-body');
 
         var args = parser.parse(['--no-body']);
-        expect(args['no-body']).isTrue();
+        expect(args['no-body'], isTrue);
       });
 
       test('are not preferred over a colliding one without', () {
         var parser = new ArgParser();
         parser.addFlag('no-strum');
         parser.addFlag('strum');
 
         var args = parser.parse(['--no-strum']);
-        expect(args['no-strum']).isTrue();
-        expect(args['strum']).isFalse();
+        expect(args['no-strum'], isTrue);
+        expect(args['strum'], isFalse);
       });
     });
 
     group('callbacks', () {
       test('for present flags are invoked with the value', () {
         var a;
         var parser = new ArgParser();
         parser.addFlag('a', callback: (value) => a = value);
 
         var args = parser.parse(['--a']);
-        expect(a).isTrue();
+        expect(a, isTrue);
       });
 
       test('for absent flags are invoked with the default value', () {
         var a;
         var parser = new ArgParser();
         parser.addFlag('a', defaultsTo: false,
             callback: (value) => a = value);
 
         var args = parser.parse([]);
-        expect(a).isFalse();
+        expect(a, isFalse);
       });
 
       test('are invoked even if the flag is not present', () {
         var a = 'not called';
         var parser = new ArgParser();
         parser.addFlag('a', callback: (value) => a = value);
 
         var args = parser.parse([]);
-        expect(a).isFalse();
+        expect(a, isFalse);
       });
 
       test('for present options are invoked with the value', () {
         var a;
         var parser = new ArgParser();
         parser.addOption('a', callback: (value) => a = value);
 
         var args = parser.parse(['--a=v']);
-        expect(a).equals('v');
+        expect(a, equals('v'));
       });
 
       test('for absent options are invoked with the default value', () {
         var a;
         var parser = new ArgParser();
         parser.addOption('a', defaultsTo: 'v',
             callback: (value) => a = value);
 
         var args = parser.parse([]);
-        expect(a).equals('v');
+        expect(a, equals('v'));
       });
 
       test('are invoked even if the option is not present', () {
         var a = 'not called';
         var parser = new ArgParser();
         parser.addOption('a', callback: (value) => a = value);
 
         var args = parser.parse([]);
-        expect(a).isNull();
+        expect(a, isNull);
       });
     });
 
     group('abbreviations', () {
       test('are parsed with a preceding "-"', () {
         var parser = new ArgParser();
         parser.addFlag('arg', abbr: 'a');
 
         var args = parser.parse(['-a']);
-        expect(args['arg']).isTrue();
+        expect(args['arg'], isTrue);
       });
 
       test('can use multiple after a single "-"', () {
         var parser = new ArgParser();
         parser.addFlag('first', abbr: 'f');
         parser.addFlag('second', abbr: 's');
         parser.addFlag('third', abbr: 't');
 
         var args = parser.parse(['-tf']);
-        expect(args['first']).isTrue();
-        expect(args['second']).isFalse();
-        expect(args['third']).isTrue();
+        expect(args['first'], isTrue);
+        expect(args['second'], isFalse);
+        expect(args['third'], isTrue);
       });
 
       test('can have multiple "-" args', () {
         var parser = new ArgParser();
         parser.addFlag('first', abbr: 'f');
         parser.addFlag('second', abbr: 's');
         parser.addFlag('third', abbr: 't');
 
         var args = parser.parse(['-s', '-tf']);
-        expect(args['first']).isTrue();
-        expect(args['second']).isTrue();
-        expect(args['third']).isTrue();
+        expect(args['first'], isTrue);
+        expect(args['second'], isTrue);
+        expect(args['third'], isTrue);
       });
 
       test('can take arguments without a space separating', () {
         var parser = new ArgParser();
         parser.addOption('file', abbr: 'f');
 
         var args = parser.parse(['-flip']);
-        expect(args['file']).equals('lip');
+        expect(args['file'], equals('lip'));
       });
 
       test('can take arguments with a space separating', () {
         var parser = new ArgParser();
         parser.addOption('file', abbr: 'f');
 
         var args = parser.parse(['-f', 'name']);
-        expect(args['file']).equals('name');
+        expect(args['file'], equals('name'));
       });
 
       test('allow non-option characters in the value', () {
         var parser = new ArgParser();
         parser.addOption('apple', abbr: 'a');
 
         var args = parser.parse(['-ab?!c']);
-        expect(args['apple']).equals('b?!c');
+        expect(args['apple'], equals('b?!c'));
       });
 
       test('throw if unknown', () {
         var parser = new ArgParser();
         throwsBadFormat(parser, ['-f']);
       });
 
       test('throw if the value is missing', () {
         var parser = new ArgParser();
         parser.addOption('file', abbr: 'f');
@@ skipping 35 matching lines @@
         // The '?!' means this can only be understood as '--apple b?!c'.
         throwsBadFormat(parser, ['-ab?!c']);
       });
     });
 
     group('options', () {
       test('are parsed if present', () {
         var parser = new ArgParser();
         parser.addOption('mode');
         var args = parser.parse(['--mode=release']);
-        expect(args['mode']).equals('release');
+        expect(args['mode'], equals('release'));
       });
 
       test('are null if not present', () {
         var parser = new ArgParser();
         parser.addOption('mode');
         var args = parser.parse([]);
-        expect(args['mode']).isNull();
+        expect(args['mode'], isNull);
       });
 
       test('default if missing', () {
         var parser = new ArgParser();
         parser.addOption('mode', defaultsTo: 'debug');
         var args = parser.parse([]);
-        expect(args['mode']).equals('debug');
+        expect(args['mode'], equals('debug'));
       });
 
       test('allow the value to be separated by whitespace', () {
         var parser = new ArgParser();
         parser.addOption('mode');
         var args = parser.parse(['--mode', 'release']);
-        expect(args['mode']).equals('release');
+        expect(args['mode'], equals('release'));
       });
 
       test('throw if unknown', () {
         var parser = new ArgParser();
         throwsBadFormat(parser, ['--unknown']);
         throwsBadFormat(parser, ['--nobody']); // Starts with "no".
       });
 
       test('throw if the arg does not include a value', () {
         var parser = new ArgParser();
         parser.addOption('mode');
         throwsBadFormat(parser, ['--mode']);
       });
 
       test('throw if the value looks like an option', () {
         var parser = new ArgParser();
         parser.addOption('mode');
         parser.addOption('other');
 
         throwsBadFormat(parser, ['--mode', '--other']);
         throwsBadFormat(parser, ['--mode', '--unknown']);
         throwsBadFormat(parser, ['--mode', '-abbr']);
       });
 
       test('do not throw if the value is in the allowed set', () {
         var parser = new ArgParser();
         parser.addOption('mode', allowed: ['debug', 'release']);
         var args = parser.parse(['--mode=debug']);
-        expect(args['mode']).equals('debug');
+        expect(args['mode'], equals('debug'));
       });
 
       test('throw if the value is not in the allowed set', () {
         var parser = new ArgParser();
         parser.addOption('mode', allowed: ['debug', 'release']);
         throwsBadFormat(parser, ['--mode=profile']);
       });
     });
 
     group('remaining args', () {
       test('stops parsing args when a non-option-like arg is encountered', () {
         var parser = new ArgParser();
         parser.addFlag('woof');
         parser.addOption('meow');
         parser.addOption('tweet', defaultsTo: 'bird');
 
         var results = parser.parse(['--woof', '--meow', 'v', 'not', 'option']);
-        expect(results['woof']).isTrue();
-        expect(results['meow']).equals('v');
-        expect(results['tweet']).equals('bird');
-        expect(results.rest).equalsCollection(['not', 'option']);
+        expect(results['woof'], isTrue);
+        expect(results['meow'], equals('v'));
+        expect(results['tweet'], equals('bird'));
+        expect(results.rest, orderedEquals(['not', 'option']));
       });
 
       test('stops parsing at "--"', () {
         var parser = new ArgParser();
         parser.addFlag('woof', defaultsTo: false);
         parser.addOption('meow', defaultsTo: 'kitty');
 
         var results = parser.parse(['--woof', '--', '--meow']);
-        expect(results['woof']).isTrue();
-        expect(results['meow']).equals('kitty');
-        expect(results.rest).equalsCollection(['--meow']);
+        expect(results['woof'], isTrue);
+        expect(results['meow'], equals('kitty'));
+        expect(results.rest, orderedEquals(['--meow']));
       });
     });
   });
 
   group('ArgParser.getUsage()', () {
     test('flags show "no-" in title', () {
       var parser = new ArgParser();
       parser.addFlag('mode', help: 'The mode');
 
       validateUsage(parser,
@@ skipping 145 matching lines @@
   group('ArgResults[]', () {
     test('throws if the name is not an option', () {
       var parser = new ArgParser();
       var results = parser.parse([]);
       throwsIllegalArg(() => results['unknown']);
     });
   });
 }
 
 throwsIllegalArg(function) {
-  expectThrow(function, (e) => e is IllegalArgumentException);
+  expect(function, throwsA(new isInstanceOf<IllegalArgumentException>()));
 }
 
 throwsBadFormat(ArgParser parser, List<String> args) {
-  expectThrow(() => parser.parse(args), (e) => e is ArgFormatException);
+  expect(() => parser.parse(args),
+      throwsA(new isInstanceOf<ArgFormatException>()));
 }
 
 validateUsage(ArgParser parser, String expected) {
   expected = unindentString(expected);
-  expect(parser.getUsage()).equals(expected);
+  expect(parser.getUsage(), equals(expected));
 }
 
 // TODO(rnystrom): Replace one in test_utils.
 String unindentString(String text) {
   var lines = text.split('\n');
 
   // Count the indentation of the last line.
   var whitespace = const RegExp('^ *');
   var indent = whitespace.firstMatch(lines[lines.length - 1])[0].length;
 
@@ skipping 16 matching lines @@
         throw new IllegalArgumentException(
             'Line "$line" does not have enough indentation.');
       }
 
       lines[i] = line.substring(indent);
     }
   }
 
   return Strings.join(lines, '\n');
 }