Rename BadNumberFormatException -> FormatException.

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 74 matching lines @@
         parser.addFlag('verbose');
 
         var args = parser.parse([]);
         expect(args['verbose'], isFalse);
       });
 
       test('throws if given a value', () {
         var parser = new ArgParser();
         parser.addFlag('verbose');
 
-        throwsBadFormat(parser, ['--verbose=true']);
+        throwsFormat(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);
@@ skipping 14 matching lines @@
 
         var args = parser.parse(['--no-strum']);
         expect(args['no-strum'], isTrue);
         expect(args['strum'], isFalse);
       });
 
       test('fail for non-negatable flags', () {
         var parser = new ArgParser();
         parser.addFlag('strum', negatable: false);
 
-        throwsBadFormat(parser, ['--no-strum']);
+        throwsFormat(parser, ['--no-strum']);
       });
     });
 
     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']);
@@ skipping 100 matching lines @@
       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'));
       });
 
       test('throw if unknown', () {
         var parser = new ArgParser();
-        throwsBadFormat(parser, ['-f']);
+        throwsFormat(parser, ['-f']);
       });
 
       test('throw if the value is missing', () {
         var parser = new ArgParser();
         parser.addOption('file', abbr: 'f');
 
-        throwsBadFormat(parser, ['-f']);
+        throwsFormat(parser, ['-f']);
       });
 
       test('throw if the value looks like an option', () {
         var parser = new ArgParser();
         parser.addOption('file', abbr: 'f');
         parser.addOption('other');
 
-        throwsBadFormat(parser, ['-f', '--other']);
-        throwsBadFormat(parser, ['-f', '--unknown']);
-        throwsBadFormat(parser, ['-f', '-abbr']);
+        throwsFormat(parser, ['-f', '--other']);
+        throwsFormat(parser, ['-f', '--unknown']);
+        throwsFormat(parser, ['-f', '-abbr']);
       });
 
       test('throw if the value is not allowed', () {
         var parser = new ArgParser();
         parser.addOption('mode', abbr: 'm', allowed: ['debug', 'release']);
 
-        throwsBadFormat(parser, ['-mprofile']);
+        throwsFormat(parser, ['-mprofile']);
       });
 
       test('throw if any but the first is not a flag', () {
         var parser = new ArgParser();
         parser.addFlag('apple', abbr: 'a');
         parser.addOption('banana', abbr: 'b'); // Takes an argument.
         parser.addFlag('cherry', abbr: 'c');
 
-        throwsBadFormat(parser, ['-abc']);
+        throwsFormat(parser, ['-abc']);
       });
 
       test('throw if it has a value but the option is a flag', () {
         var parser = new ArgParser();
         parser.addFlag('apple', abbr: 'a');
         parser.addFlag('banana', abbr: 'b');
 
         // The '?!' means this can only be understood as '--apple b?!c'.
-        throwsBadFormat(parser, ['-ab?!c']);
+        throwsFormat(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'));
       });
@@ skipping 14 matching lines @@
 
       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'));
       });
 
       test('throw if unknown', () {
         var parser = new ArgParser();
-        throwsBadFormat(parser, ['--unknown']);
-        throwsBadFormat(parser, ['--nobody']); // Starts with "no".
+        throwsFormat(parser, ['--unknown']);
+        throwsFormat(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']);
+        throwsFormat(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']);
+        throwsFormat(parser, ['--mode', '--other']);
+        throwsFormat(parser, ['--mode', '--unknown']);
+        throwsFormat(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'));
       });
 
       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']);
+        throwsFormat(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');
 
@@ skipping 184 matching lines @@
       var results = parser.parse([]);
       throwsIllegalArg(() => results['unknown']);
     });
   });
 }
 
 throwsIllegalArg(function) {
   expect(function, throwsA(new isInstanceOf<IllegalArgumentException>()));
 }
 
-throwsBadFormat(ArgParser parser, List<String> args) {
-  expect(() => parser.parse(args),
-      throwsA(new isInstanceOf<ArgFormatException>()));
+throwsFormat(ArgParser parser, List<String> args) {
+  expect(() => parser.parse(args), throwsFormatException);
 }
 
 validateUsage(ArgParser parser, String expected) {
   expected = unindentString(expected);
   expect(parser.getUsage(), equals(expected));
 }
 
 // TODO(rnystrom): Replace one in test_utils.
 String unindentString(String text) {
   var lines = text.split('\n');
@@ skipping 21 matching lines @@
         throw new IllegalArgumentException(
             'Line "$line" does not have enough indentation.');
       }
 
       lines[i] = line.substring(indent);
     }
   }
 
   return Strings.join(lines, '\n');
 }