refactor(tests): replace deprecated toThrow with toThrowWith

Closes dart-archive#1425

Author: vsavkin

test/angular_spec.dart

@@ -40,7 +40,7 @@ main() {
     it('should fail with not enough arguments', () {
       expect(() {
         relaxFnApply((required, alsoRequired) => "happy", [1]);
-      }).toThrow('Unknown function type, expecting 0 to 5 args.');
+      }).toThrowWith(message: 'Unknown function type, expecting 0 to 5 args.');
     });
   });
 

test/change_detection/watch_group_spec.dart

@@ -293,7 +293,7 @@ void main() {
         watchLast.remove();
         expect(watchGrp.fieldCost).toEqual(0);
 
-        expect(() => watch.remove()).toThrow('Already deleted!');
+        expect(() => watch.remove()).toThrowWith(message: 'Already deleted!');
       });
 
       it('should eval pure FunctionApply', () {

test/core/core_directive_spec.dart

@@ -52,7 +52,7 @@ void main() {
         var injector = applicationFactory().addModule(module).createInjector();
         expect(() {
           injector.get(DirectiveMap);
-        }).toThrow('Mapping for attribute foo is already defined (while '
+        }).toThrowWith(message: 'Mapping for attribute foo is already defined (while '
         'processing annottation for field foo of Bad1Component)');
       });
 
@@ -63,7 +63,7 @@ void main() {
         var injector = applicationFactory().addModule(module).createInjector();
         expect(() {
           injector.get(DirectiveMap);
-        }).toThrow('Attribute annotation for foo is defined more than once '
+        }).toThrowWith(message: 'Attribute annotation for foo is defined more than once '
         'in Bad2Component');
       });
     });

test/core/parser/lexer_spec.dart

@@ -225,11 +225,11 @@ main() {
     it('should throws exception for invalid exponent', () {
       expect(() {
         lex("0.5E-");
-      }).toThrow('Lexer Error: Invalid exponent at column 4 in expression [0.5E-]');
+      }).toThrowWith(message: 'Lexer Error: Invalid exponent at column 4 in expression [0.5E-]');
 
       expect(() {
         lex("0.5E-A");
-      }).toThrow('Lexer Error: Invalid exponent at column 4 in expression [0.5E-A]');
+      }).toThrowWith(message: 'Lexer Error: Invalid exponent at column 4 in expression [0.5E-A]');
     });
 
     it('should tokenize number starting with a dot', () {
@@ -240,7 +240,7 @@ main() {
     it('should throw error on invalid unicode', () {
       expect(() {
         lex("'\\u1''bla'");
-      }).toThrow("Lexer Error: Invalid unicode escape [\\u1''b] at column 2 in expression ['\\u1''bla']");
+      }).toThrowWith(message: "Lexer Error: Invalid unicode escape [\\u1''b] at column 2 in expression ['\\u1''bla']");
     });
   });
 }

test/core/parser/parser_spec.dart

@@ -165,111 +165,111 @@ main() {
 
       // PARSER ERRORS
       it('should throw a reasonable error for unconsumed tokens', () {
-        expectEval(")").toThrow('Parser Error: Unconsumed token ) at column 1 in [)]');
+        expectEval(")").toThrowWith(message: 'Parser Error: Unconsumed token ) at column 1 in [)]');
       });
 
 
       it('should throw on missing expected token', () {
-        expectEval("a(b").toThrow('Parser Error: Missing expected ) the end of the expression [a(b]');
+        expectEval("a(b").toThrowWith(message: 'Parser Error: Missing expected ) the end of the expression [a(b]');
       });
 
 
       it('should throw on bad assignment', () {
-        expectEval("5=4").toThrow('Parser Error: Expression 5 is not assignable at column 2 in [5=4]');
-        expectEval("array[5=4]").toThrow('Parser Error: Expression 5 is not assignable at column 8 in [array[5=4]]');
+        expectEval("5=4").toThrowWith(message: 'Parser Error: Expression 5 is not assignable at column 2 in [5=4]');
+        expectEval("array[5=4]").toThrowWith(message: 'Parser Error: Expression 5 is not assignable at column 8 in [array[5=4]]');
       });
 
 
       it('should throw on incorrect ternary operator syntax', () {
-        expectEval("true?1").toThrow('Parser Error: Conditional expression true?1 requires all 3 expressions');
+        expectEval("true?1").toThrowWith(message: 'Parser Error: Conditional expression true?1 requires all 3 expressions');
       });
 
 
       it('should throw on non-function function calls', () {
-        expectEval("4()").toThrow('4 is not a function');
+        expectEval("4()").toThrowWith(message: '4 is not a function');
       });
 
       it("should throw on an unexpected token", (){
         expectEval("[1,2] trac")
-            .toThrow('Parser Error: \'trac\' is an unexpected token at column 7 in [[1,2] trac]');
+            .toThrowWith(message: 'Parser Error: \'trac\' is an unexpected token at column 7 in [[1,2] trac]');
       });
 
       it('should fail gracefully when invoking non-function', () {
         expect(() {
           parser('a[0]()').eval({'a': [4]});
-        }).toThrow('a[0] is not a function');
+        }).toThrowWith(message:'a[0] is not a function');
 
         expect(() {
           parser('a[x()]()').eval({'a': [4], 'x': () => 0});
-        }).toThrow('a[x()] is not a function');
+        }).toThrowWith(message:'a[x()] is not a function');
 
         expect(() {
           parser('{}()').eval({});
-        }).toThrow('{} is not a function');
+        }).toThrowWith(message:'{} is not a function');
       });
 
 
       it('should throw on undefined functions (relaxed message)', () {
-        expectEval("notAFn()").toThrow('notAFn');
+        expectEval("notAFn()").toThrowWith(message:'notAFn');
       });
 
 
       it('should fail gracefully when missing a function (relaxed message)', () {
         expect(() {
           parser('doesNotExist()').eval({});
-        }).toThrow('doesNotExist');
+        }).toThrowWith(message:'doesNotExist');
 
         expect(() {
           parser('exists(doesNotExist())').eval({'exists': () => true});
-        }).toThrow('doesNotExist');
+        }).toThrowWith(message:'doesNotExist');
 
         expect(() {
           parser('doesNotExists(exists())').eval({'exists': () => true});
-        }).toThrow('doesNotExist');
+        }).toThrowWith(message:'doesNotExist');
 
         expect(() {
           parser('doesNotExist(1)').eval({});
-        }).toThrow('doesNotExist');
+        }).toThrowWith(message:'doesNotExist');
 
         expect(() {
           parser('doesNotExist(1, 2)').eval({});
-        }).toThrow('doesNotExist');
+        }).toThrowWith(message:'doesNotExist');
 
         expect(() {
           parser('doesNotExist()').eval(new TestData());
-        }).toThrow('doesNotExist');
+        }).toThrowWith(message:'doesNotExist');
 
         expect(() {
           parser('doesNotExist(1)').eval(new TestData());
-        }).toThrow('doesNotExist');
+        }).toThrowWith(message:'doesNotExist');
 
         expect(() {
           parser('doesNotExist(1, 2)').eval(new TestData());
-        }).toThrow('doesNotExist');
+        }).toThrowWith(message:'doesNotExist');
 
         expect(() {
           parser('a.doesNotExist()').eval({'a': {}});
-        }).toThrow('doesNotExist');
+        }).toThrowWith(message:'doesNotExist');
 
         expect(() {
           parser('a.doesNotExist(1)').eval({'a': {}});
-        }).toThrow('doesNotExist');
+        }).toThrowWith(message:'doesNotExist');
 
         expect(() {
           parser('a.doesNotExist(1, 2)').eval({'a': {}});
-        }).toThrow('doesNotExist');
+        }).toThrowWith(message:'doesNotExist');
 
         expect(() {
           parser('a.doesNotExist()').eval({'a': new TestData()});
-        }).toThrow('doesNotExist');
+        }).toThrowWith(message:'doesNotExist');
 
         expect(() {
           parser('a.doesNotExist(1)').eval({'a': new TestData()});
-        }).toThrow('doesNotExist');
+        }).toThrowWith(message:'doesNotExist');
 
         expect(() {
           parser('a.doesNotExist(1, 2)').eval({'a': new TestData()});
-        }).toThrow('doesNotExist');
+        }).toThrowWith(message:'doesNotExist');
       });
 
 
@@ -278,7 +278,7 @@ main() {
 
         expect(eval('null')).toBe(null);
         expect(() => eval('map.null'))
-            .toThrow("Identifier 'null' is a reserved word.");
+            .toThrowWith(message:"Identifier 'null' is a reserved word.");
       });
 
 
@@ -304,14 +304,14 @@ main() {
       it('should pass exceptions through getters', () {
         expect(() {
           parser('boo').eval(new ScopeWithErrors());
-        }).toThrow('boo to you');
+        }).toThrowWith(message:'boo to you');
       });
 
 
       it('should pass noSuchMethodExceptions through getters', () {
         expect(() {
           parser('getNoSuchMethod').eval(new ScopeWithErrors());
-        }).toThrow("null");
+        }).toThrowWith(message:"null");
         // Dartium throws: The null object does not have a method 'iDontExist'
         // Chrome throws: NullError: Cannot call "iDontExist$0" on null
         // Firefox throws: NullError: null has no properties
@@ -321,14 +321,14 @@ main() {
       it('should pass exceptions through methods', () {
         expect(() {
           parser('foo()').eval(new ScopeWithErrors());
-        }).toThrow('foo to you');
+        }).toThrowWith(message:'foo to you');
       });
 
 
       it('should fail if reflected object has no property', () {
         expect(() {
           parser('notAProperty').eval(new TestData());
-        }).toThrow("notAProperty");
+        }).toThrowWith(message:"notAProperty");
       });
 
 
@@ -344,22 +344,22 @@ main() {
 
 
       it('should only allow identifier or keyword as formatter names', () {
-        expect(() => parser('"Foo"|(')).toThrow('identifier or keyword');
-        expect(() => parser('"Foo"|1234')).toThrow('identifier or keyword');
-        expect(() => parser('"Foo"|"uppercase"')).toThrow('identifier or keyword');
+        expect(() => parser('"Foo"|(')).toThrowWith(message:'identifier or keyword');
+        expect(() => parser('"Foo"|1234')).toThrowWith(message:'identifier or keyword');
+        expect(() => parser('"Foo"|"uppercase"')).toThrowWith(message:'identifier or keyword');
       });
 
 
       it('should only allow identifier or keyword as member names', () {
-        expect(() => parser('x.(')).toThrow('identifier or keyword');
-        expect(() => parser('x. 1234')).toThrow('identifier or keyword');
-        expect(() => parser('x."foo"')).toThrow('identifier or keyword');
+        expect(() => parser('x.(')).toThrowWith(message:'identifier or keyword');
+        expect(() => parser('x. 1234')).toThrowWith(message:'identifier or keyword');
+        expect(() => parser('x."foo"')).toThrowWith(message:'identifier or keyword');
       });
 
 
       it('should only allow identifier, string, or keyword as object literal key', () {
-        expect(() => parser('{(:0}')).toThrow('expected identifier, keyword, or string');
-        expect(() => parser('{1234:0}')).toThrow('expected identifier, keyword, or string');
+        expect(() => parser('{(:0}')).toThrowWith(message:'expected identifier, keyword, or string');
+        expect(() => parser('{1234:0}')).toThrowWith(message:'expected identifier, keyword, or string');
       });
     });
 
@@ -433,15 +433,15 @@ main() {
       it('should rethrow an error from a function', () {
         expect(() {
           parser("causeException()").eval(new TestData());
-        }).toThrow('NoSuchMethodError');
+        }).toThrowWith(message:'NoSuchMethodError');
       });
 
 
       xit('should throw a nice error for type mismatch', () {
         context['obj'] = new SetterObject();
         expect(() {
           eval('obj.integer = "hello"');
-        }).toThrow("Eval Error: Caught type 'String' is not a subtype of type 'int' of 'value'. while evaling [obj.integer = \"hello\"]");
+        }).toThrowWith(message:"Eval Error: Caught type 'String' is not a subtype of type 'int' of 'value'. while evaling [obj.integer = \"hello\"]");
       });
     });
 
@@ -468,7 +468,7 @@ main() {
         for (String reserved in RESERVED_WORDS) {
           expect(() {
             parser("o.$reserved()").eval({ 'o': new Object() });
-          }).toThrow('Undefined function $reserved');
+          }).toThrowWith(message:'Undefined function $reserved');
           expect(parser("o.$reserved()").eval({ 'o': { reserved: () => reserved }})).toEqual(reserved);
         }
       });
@@ -499,7 +499,7 @@ main() {
           if ([ "true", "false", "null"].contains(reserved)) continue;
           expect(() {
             parser("$reserved()").eval(new Object());
-          }).toThrow('Undefined function $reserved');
+          }).toThrowWith(message:'Undefined function $reserved');
           expect(parser("$reserved()").eval({ reserved: () => reserved })).toEqual(reserved);
         }
       });
@@ -644,7 +644,7 @@ main() {
 
       it('should catch NoSuchMethod', () {
         context = {'a': {'b': 23}};
-        expect(() => eval('a.b.c.d')).toThrow('NoSuchMethod');
+        expect(() => eval('a.b.c.d')).toThrowWith(message:'NoSuchMethod');
       });
 
 
@@ -816,7 +816,7 @@ main() {
       it('should throw exception on non-closed bracket', () {
         expect(() {
           eval('[].count(');
-        }).toThrow('Unexpected end of expression: [].count(');
+        }).toThrowWith(message:'Unexpected end of expression: [].count(');
       });
 
 
@@ -1058,16 +1058,16 @@ main() {
 
 
       it('should be an error to use the same name twice', () {
-        expect(() => parser('foo(a: 0, a: 1)')).toThrow("Duplicate argument named 'a' at column 11");
-        expect(() => parser('foo(a: 0, b: 1, a: 2)')).toThrow("Duplicate argument named 'a' at column 17");
-        expect(() => parser('foo(0, a: 1, a: 2)')).toThrow("Duplicate argument named 'a' at column 14");
-        expect(() => parser('foo(0, a: 1, b: 2, a: 3)')).toThrow("Duplicate argument named 'a' at column 20");
+        expect(() => parser('foo(a: 0, a: 1)')).toThrowWith(message:"Duplicate argument named 'a' at column 11");
+        expect(() => parser('foo(a: 0, b: 1, a: 2)')).toThrowWith(message:"Duplicate argument named 'a' at column 17");
+        expect(() => parser('foo(0, a: 1, a: 2)')).toThrowWith(message:"Duplicate argument named 'a' at column 14");
+        expect(() => parser('foo(0, a: 1, b: 2, a: 3)')).toThrowWith(message:"Duplicate argument named 'a' at column 20");
       });
 
 
       it('should be an error to use Dart reserved words as names', () {
-        expect(() => parser('foo(if: 0)')).toThrow("Cannot use Dart reserved word 'if' as named argument at column 5");
-        expect(() => parser('foo(a: 0, class: 0)')).toThrow("Cannot use Dart reserved word 'class' as named argument at column 11");
+        expect(() => parser('foo(if: 0)')).toThrowWith(message:"Cannot use Dart reserved word 'if' as named argument at column 5");
+        expect(() => parser('foo(a: 0, class: 0)')).toThrowWith(message:"Cannot use Dart reserved word 'class' as named argument at column 11");
       });
 
 
@@ -1129,10 +1129,10 @@ main() {
       it('should parse formatters', () {
         expect(() {
           eval("1|nonexistent");
-        }).toThrow('No formatter \'nonexistent\' found!');
+        }).toThrowWith(message:'No formatter \'nonexistent\' found!');
         expect(() {
           eval("1|nonexistent", formatters);
-        }).toThrow('No formatter \'nonexistent\' found!');
+        }).toThrowWith(message:'No formatter \'nonexistent\' found!');
 
         context['offset'] =  3;
         expect(eval("'abcd'|substring:1:offset")).toEqual("bc");
@@ -1143,7 +1143,7 @@ main() {
         var expression = parser("'World'|hello");
         expect(() {
           expression.eval({}, formatters);
-        }).toThrow('No formatter \'hello\' found!');
+        }).toThrowWith(message:'No formatter \'hello\' found!');
 
         var module = new Module()
             ..bind(FormatterMap)
@@ -1157,10 +1157,10 @@ main() {
       it('should not allow formatters in a chain', () {
         expect(() {
           parser("1;'World'|hello");
-        }).toThrow('Cannot have a formatter in a chain the end of the expression [1;\'World\'|hello]');
+        }).toThrowWith(message:'Cannot have a formatter in a chain the end of the expression [1;\'World\'|hello]');
         expect(() {
           parser("'World'|hello;1");
-        }).toThrow('Cannot have a formatter in a chain at column 15 in [\'World\'|hello;1]');
+        }).toThrowWith(message:'Cannot have a formatter in a chain at column 15 in [\'World\'|hello;1]');
       });
     });
   });