fix testChecker to include test inside

test/checker/checker_test.dart

 // Copyright (c) 2015, 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.
 
 /// General type checking tests
 library dev_compiler.test.checker_test;
 
 import 'package:test/test.dart';
 
 import '../testing.dart';
 
 void main() {
-  test('ternary operator', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('ternary operator', {
+    '/main.dart': '''
         abstract class Comparable<T> {
           int compareTo(T other);
           static int compare(Comparable a, Comparable b) => a.compareTo(b);
         }
         typedef int Comparator<T>(T a, T b);
 
         typedef bool _Predicate<T>(T value);
 
         class SplayTreeMap<K, V> {
           Comparator<K> _comparator;
@@ skipping 15 matching lines @@
           Object obj = 42;
           dynamic dyn = 42;
           int i = 42;
 
           // Check the boolean conversion of the condition.
           print((/*severe:StaticTypeError*/i) ? false : true);
           print((/*warning:DownCastImplicit*/obj) ? false : true);
           print((/*info:DynamicCast*/dyn) ? false : true);
         }
       '''
-    });
   });
 
-  test(
-      'if/for/do/while statements use boolean conversion',
-      () => testChecker({
-            '/main.dart': '''
+  testChecker('if/for/do/while statements use boolean conversion', {
+    '/main.dart': '''
       main() {
         dynamic d = 42;
         Object obj = 42;
         int i = 42;
         bool b = false;
 
         if (b) {}
         if (/*info:DynamicCast*/dyn) {}
         if (/*warning:DownCastImplicit*/obj) {}
         if (/*severe:StaticTypeError*/i) {}
 
         while (b) {}
         while (/*info:DynamicCast*/dyn) {}
         while (/*warning:DownCastImplicit*/obj) {}
         while (/*severe:StaticTypeError*/i) {}
 
         do {} while (b);
         do {} while (/*info:DynamicCast*/dyn);
         do {} while (/*warning:DownCastImplicit*/obj);
         do {} while (/*severe:StaticTypeError*/i);
 
         for (;b;) {}
         for (;/*info:DynamicCast*/dyn;) {}
         for (;/*warning:DownCastImplicit*/obj;) {}
         for (;/*severe:StaticTypeError*/i;) {}
       }
     '''
-          }));
+  });
 
-  test('dynamic invocation', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('dynamic invocation', {
+    '/main.dart': '''
 
       class A {
         dynamic call(dynamic x) => x;
       }
       class B extends A {
         int call(int x) => x;
         double col(double x) => x;
       }
       void main() {
         {
@@ skipping 23 matching lines @@
         {
           A f = new B();
           int x;
           double y;
           x = /*info:DynamicCast, info:DynamicInvoke*/f(3);
           y = /*info:DynamicCast, info:DynamicInvoke*/f(3);
           (/*info:DynamicInvoke*/f(3.0));
         }
       }
     '''
-    });
   });
 
-  test('conversion and dynamic invoke', () {
-    testChecker({
-      '/helper.dart': '''
+  testChecker('conversion and dynamic invoke', {
+    '/helper.dart': '''
       dynamic toString = (int x) => x + 42;
       dynamic hashCode = "hello";
       ''',
-      '/main.dart': '''
+    '/main.dart': '''
       import 'helper.dart' as helper;
 
       class A {
         String x = "hello world";
 
         void baz1(y) => x + /*info:DynamicCast*/y;
         static baz2(y) => /*info:DynamicInvoke*/y + y;
       }
 
       void foo(String str) {
@@ skipping 52 matching lines @@
 
         (/*info:DynamicInvoke*/helper.toString());
         var toStringClosure2 = helper.toString;
         (/*info:DynamicInvoke*/toStringClosure2());
         int hashCode = /*info:DynamicCast*/helper.hashCode;
 
         baz().toString();
         baz().hashCode;
       }
     '''
-    });
   });
 
-  test('Primitives', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Primitives', {
+    '/main.dart': '''
         int /*severe:InvalidVariableDeclaration*/a;
         double /*severe:InvalidVariableDeclaration*/b;
         num c;
 
         class A {
           int a;
           double b;
           num c;
 
           static int /*severe:InvalidVariableDeclaration*/x;
@@ skipping 27 matching lines @@
           // num is nullable
           z = null;
           z = x;
           z = y;
 
           // bool is nullable
           b = null;
           b = true;
         }
       '''
-    }, nonnullableTypes: <String>[
-      'int',
-      'double'
-    ]);
-  });
+  }, nonnullableTypes: <String>[
+    'int',
+    'double'
+  ]);
 
-  test('Primitives and generics', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Primitives and generics', {
+    '/main.dart': '''
         class A<T> {
           // TODO(vsm): This needs a static info indicating a runtime
           // check at construction.
           T x;
 
           // TODO(vsm): Should this be a different type of DownCast?
           T foo() => /*warning:DownCastImplicit*/null;
 
           void bar() {
             int /*severe:InvalidVariableDeclaration*/x;
@@ skipping 16 matching lines @@
 
         class C<T extends num> {
           // TODO(vsm): This needs a static info indicating a runtime
           // check at construction.
           T x;
 
           // TODO(vsm): Should this be a different type of DownCast?
           T foo() => /*warning:DownCastImplicit*/null;
         }
       '''
-    }, nonnullableTypes: <String>[
-      'int',
-      'double'
-    ]);
-  });
+  }, nonnullableTypes: <String>[
+    'int',
+    'double'
+  ]);
 
-  test('Constructors', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Constructors', {
+    '/main.dart': '''
       const num z = 25;
       Object obj = "world";
 
       class A {
         int x;
         String y;
 
         A(this.x) : this.y = /*severe:StaticTypeError*/42;
 
         A.c1(p): this.x = /*warning:DownCastImplicit*/z, this.y = /*info:DynamicCast*/p;
@@ skipping 10 matching lines @@
                                          /*severe:StaticTypeError*/x);
 
         B.c3(num x, Object y) : super.c3(x, /*warning:DownCastImplicit*/y);
       }
 
       void main() {
          A a = new A.c2(/*warning:DownCastImplicit*/z, /*severe:StaticTypeError*/z);
          var b = new B.c2(/*severe:StaticTypeError*/"hello", /*warning:DownCastImplicit*/obj);
       }
    '''
-    });
   });
 
-  test('Unbound variable', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Unbound variable', {
+    '/main.dart': '''
       void main() {
          dynamic y = /*pass should be severe:StaticTypeError*/unboundVariable;
       }
    '''
-    });
   });
 
-  test('Unbound type name', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Unbound type name', {
+    '/main.dart': '''
       void main() {
          /*pass should be severe:StaticTypeError*/AToB y;
       }
    '''
-    });
   });
 
-  test('Ground type subtyping: dynamic is top', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Ground type subtyping: dynamic is top', {
+    '/main.dart': '''
 
       class A {}
       class B extends A {}
 
       void main() {
          dynamic y;
          Object o;
          int i = 0;
          double d = 0.0;
          num n;
          A a;
          B b;
          y = o;
          y = i;
          y = d;
          y = n;
          y = a;
          y = b;
       }
    '''
-    });
   });
 
-  test('Ground type subtyping: dynamic downcasts', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Ground type subtyping: dynamic downcasts', {
+    '/main.dart': '''
 
       class A {}
       class B extends A {}
 
       void main() {
          dynamic y;
          Object o;
          int i = 0;
          double d = 0.0;
          num n;
          A a;
          B b;
          o = y;
          i = /*info:DynamicCast*/y;
          d = /*info:DynamicCast*/y;
          n = /*info:DynamicCast*/y;
          a = /*info:DynamicCast*/y;
          b = /*info:DynamicCast*/y;
       }
    '''
-    });
   });
 
-  test('Ground type subtyping: assigning a class', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Ground type subtyping: assigning a class', {
+    '/main.dart': '''
 
       class A {}
       class B extends A {}
 
       void main() {
          dynamic y;
          Object o;
          int i = 0;
          double d = 0.0;
          num n;
          A a;
          B b;
          y = a;
          o = a;
          i = /*severe:StaticTypeError*/a;
          d = /*severe:StaticTypeError*/a;
          n = /*severe:StaticTypeError*/a;
          a = a;
          b = /*warning:DownCastImplicit*/a;
       }
    '''
-    });
   });
 
-  test('Ground type subtyping: assigning a subclass', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Ground type subtyping: assigning a subclass', {
+    '/main.dart': '''
 
       class A {}
       class B extends A {}
       class C extends A {}
 
       void main() {
          dynamic y;
          Object o;
          int i = 0;
          double d = 0.0;
          num n;
          A a;
          B b;
          C c;
          y = b;
          o = b;
          i = /*severe:StaticTypeError*/b;
          d = /*severe:StaticTypeError*/b;
          n = /*severe:StaticTypeError*/b;
          a = b;
          b = b;
          c = /*severe:StaticTypeError*/b;
       }
    '''
-    });
   });
 
-  test('Ground type subtyping: interfaces', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Ground type subtyping: interfaces', {
+    '/main.dart': '''
 
       class A {}
       class B extends A {}
       class C extends A {}
       class D extends B implements C {}
 
       void main() {
          A top;
          B left;
          C right;
@@ skipping 17 matching lines @@
            right = bot;
          }
          {
            bot = /*warning:DownCastImplicit*/top;
            bot = /*warning:DownCastImplicit*/left;
            bot = /*warning:DownCastImplicit*/right;
            bot = bot;
          }
       }
    '''
-    });
   });
 
-  test('Function typing and subtyping: int and object', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Function typing and subtyping: int and object', {
+    '/main.dart': '''
 
       typedef Object Top(int x);      // Top of the lattice
       typedef int Left(int x);        // Left branch
       typedef int Left2(int x);       // Left branch
       typedef Object Right(Object x); // Right branch
       typedef int Bot(Object x);      // Bottom of the lattice
 
       Object top(int x) => x;
       int left(int x) => x;
       Object right(Object x) => x;
@@ skipping 28 matching lines @@
         }
         {
           Bot f;
           f = /*warning:DownCastComposite*/top;
           f = /*warning:DownCastComposite*/left;
           f = /*warning:DownCastComposite*/right;
           f = bot;
         }
       }
    '''
-    });
   });
 
-  test('Function typing and subtyping: classes', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Function typing and subtyping: classes', {
+    '/main.dart': '''
 
       class A {}
       class B extends A {}
 
       typedef A Top(B x);   // Top of the lattice
       typedef B Left(B x);  // Left branch
       typedef B Left2(B x); // Left branch
       typedef A Right(A x); // Right branch
       typedef B Bot(A x);   // Bottom of the lattice
 
@@ skipping 31 matching lines @@
         }
         {
           Bot f;
           f = /*warning:DownCastComposite*/top;
           f = /*warning:DownCastComposite*/left;
           f = /*warning:DownCastComposite*/right;
           f = bot;
         }
       }
    '''
-    });
   });
 
-  test('Function typing and subtyping: dynamic', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Function typing and subtyping: dynamic', {
+    '/main.dart': '''
 
       class A {}
 
       typedef dynamic Top(dynamic x);     // Top of the lattice
       typedef dynamic Left(A x);          // Left branch
       typedef A Right(dynamic x);         // Right branch
       typedef A Bottom(A x);              // Bottom of the lattice
 
       dynamic left(A x) => x;
       A bot(A x) => x;
@@ skipping 24 matching lines @@
         }
         {
           Bottom f;
           f = /*warning:DownCastComposite*/top;
           f = /*warning:DownCastComposite*/left;
           f = /*warning:DownCastComposite*/right;
           f = bot;
         }
       }
    '''
-    });
   });
 
-  test('Function typing and subtyping: function literal variance', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Function typing and subtyping: function literal variance', {
+    '/main.dart': '''
 
       class A {}
       class B extends A {}
 
       typedef T Function2<S, T>(S z);
 
       A top(B x) => x;
       B left(B x) => x;
       A right(A x) => x;
       B bot(A x) => x as B;
@@ skipping 22 matching lines @@
         }
         {
           Function2<A, B> f;
           f = /*warning:DownCastComposite*/top;
           f = /*warning:DownCastComposite*/left;
           f = /*warning:DownCastComposite*/right;
           f = bot;
         }
       }
    '''
-    });
   });
 
-  test('Function typing and subtyping: function variable variance', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Function typing and subtyping: function variable variance', {
+    '/main.dart': '''
 
       class A {}
       class B extends A {}
 
       typedef T Function2<S, T>(S z);
 
       void main() {
         {
           Function2<B, A> top;
           Function2<B, B> left;
@@ skipping 15 matching lines @@
           right = right;
           right = bot;
 
           bot = /*warning:DownCastComposite*/top;
           bot = /*warning:DownCastComposite*/left;
           bot = /*warning:DownCastComposite*/right;
           bot = bot;
         }
       }
    '''
-    });
   });
 
-  test('Function typing and subtyping: higher order function literals', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Function typing and subtyping: higher order function literals', {
+    '/main.dart': '''
 
       class A {}
       class B extends A {}
 
       typedef T Function2<S, T>(S z);
 
       typedef A BToA(B x);  // Top of the base lattice
       typedef B AToB(A x);  // Bot of the base lattice
 
       BToA top(AToB f) => f;
@@ skipping 39 matching lines @@
         }
         {
           Function2<BToA, AToB> f; // Bot
           f = bot;
           f = /*warning:DownCastComposite*/left;
           f = /*warning:DownCastComposite*/top;
           f = /*warning:DownCastComposite*/left;
         }
       }
    '''
-    });
   });
 
-  test('Function typing and subtyping: higher order function variables', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'Function typing and subtyping: higher order function variables', {
+    '/main.dart': '''
 
     class A {}
     class B extends A {}
 
     typedef T Function2<S, T>(S z);
 
     void main() {
       {
         Function2<Function2<A, B>, Function2<B, A>> top;
         Function2<Function2<B, A>, Function2<B, A>> right;
@@ skipping 17 matching lines @@
         right = right;
         right = bot;
 
         bot = /*warning:DownCastComposite*/top;
         bot = /*warning:DownCastComposite*/left;
         bot = /*warning:DownCastComposite*/right;
         bot = bot;
       }
     }
    '''
-    });
   });
 
-  test('Function typing and subtyping: named and optional parameters', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Function typing and subtyping: named and optional parameters', {
+    '/main.dart': '''
 
       class A {}
 
       typedef A FR(A x);
       typedef A FO([A x]);
       typedef A FN({A x});
       typedef A FRR(A x, A y);
       typedef A FRO(A x, [A y]);
       typedef A FRN(A x, {A n});
       typedef A FOO([A x, A y]);
@@ skipping 95 matching lines @@
          nnn = /*severe:StaticTypeError*/o;
          nnn = /*warning:DownCastComposite*/n;
          nnn = /*severe:StaticTypeError*/rr;
          nnn = /*severe:StaticTypeError*/ro;
          nnn = /*severe:StaticTypeError*/rn;
          nnn = /*severe:StaticTypeError*/oo;
          nnn = /*warning:DownCastComposite*/nn;
          nnn = nnn;
       }
    '''
-    });
   });
 
-  test('Function subtyping: objects with call methods', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Function subtyping: objects with call methods', {
+    '/main.dart': '''
 
       typedef int I2I(int x);
       typedef num N2N(num x);
       class A {
          int call(int x) => x;
       }
       class B {
          num call(num x) => x;
       }
       int i2i(int x) => x;
@@ skipping 39 matching lines @@
            Function f;
            f = new A();
            f = new B();
            f = i2i;
            f = n2n;
            f = /*warning:DownCastImplicit*/i2i as Object;
            f = (n2n as Function);
          }
       }
    '''
-    });
   });
 
-  test('Function typing and subtyping: void', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Function typing and subtyping: void', {
+    '/main.dart': '''
 
       class A {
         void bar() => null;
         void foo() => bar; // allowed
       }
    '''
-    });
   });
 
-  test('Covariant generic subtyping: invariance', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'Covariant generic subtyping: invariance',
+      {
+        '/main.dart': '''
 
       class A {}
       class B extends A {}
       class C implements A {}
 
       class L<T> {}
       class M<T> extends L<T> {}
       class N extends M<A> {}
 
       void main() {
@@ skipping 88 matching lines @@
         // Concrete subclass subtyping
         ns = /*warning:DownCastImplicit*/lOfAs;
         ns = /*severe:StaticTypeError*/lOfBs;
         ns = /*severe:StaticTypeError*/lOfCs;
         ns = /*warning:DownCastImplicit*/mOfAs;
         ns = /*severe:StaticTypeError*/mOfBs;
         ns = /*severe:StaticTypeError*/mOfCs;
         ns = ns;
       }
    '''
-    }, relaxedCasts: false);
-  });
+      },
+      relaxedCasts: false);
 
-  test('Relaxed casts', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'Relaxed casts',
+      {
+        '/main.dart': '''
 
       class A {}
 
       class L<T> {}
       class M<T> extends L<T> {}
       //     L<dynamic|Object>
       //    /              \
       // M<dynamic|Object>  L<A>
       //    \              /
       //          M<A>
@@ skipping 54 matching lines @@
           mOfAs = /*warning:DownCastComposite*/mOfDs;
           mOfAs = /*warning:DownCastComposite*/mOfOs;
           mOfAs = mOfAs;
           mOfAs = /*warning:DownCastComposite*/lOfDs;
           mOfAs = /*warning:DownCastComposite*/lOfOs;
           mOfAs = /*warning:DownCastComposite*/lOfAs;
         }
 
       }
    '''
-    }, relaxedCasts: true);
-  });
-
-  test('Subtyping literals', () {
-    testChecker({
-      '/main.dart': '''
+      },
+      relaxedCasts: true);
+  testChecker(
+      'Subtyping literals',
+      {
+        '/main.dart': '''
           test() {
             Iterable i1 = [1, 2, 3];
             i1 = <int>[1, 2, 3];
 
             List l1 = [1, 2, 3];
             l1 = <int>[1, 2, 3];
 
             Iterable<int> i2 = /*severe:StaticTypeError*/[1, 2, 3];
             i2 = /*warning:DownCastComposite*/i1;
             i2 = /*warning:DownCastComposite*/l1;
             i2 = <int>[1, 2, 3];
 
             List<int> l2 = /*severe:StaticTypeError*/[1, 2, 3];
             l2 = /*warning:DownCastComposite*/i1;
             l2 = /*warning:DownCastComposite*/l1;
 
             l2 = /*severe:StaticTypeError*/new List();
             l2 = /*severe:StaticTypeError*/new List(10);
             l2 = /*severe:StaticTypeError*/new List.filled(10, 42);
           }
    '''
-    }, inferDownwards: false);
-  });
+      },
+      inferDownwards: false);
 
-  test('Type checking literals', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Type checking literals', {
+    '/main.dart': '''
           test() {
             num n = 3;
             int i = 3;
             String s = "hello";
             {
                List<int> l = <int>[i];
                l = <int>[/*severe:StaticTypeError*/s];
                l = <int>[/*warning:DownCastImplicit*/n];
                l = <int>[i, /*warning:DownCastImplicit*/n, /*severe:StaticTypeError*/s];
             }
@@ skipping 19 matching lines @@
                m = {s: n};
                m = {s: i,
                     s: n,
                     s: s};
                m = {i: s,
                     n: s,
                     s: s};
             }
           }
    '''
-    });
   });
 
-  test('casts in constant contexts', () {
-    String mk(String error1, String error2) => '''
+  testChecker('casts in constant contexts', {
+    '/main.dart': '''
           class A {
             static const num n = 3.0;
-            static const int i = /*$error2*/n;
+            static const int i = /*info:AssignmentCast*/n;
             final int fi;
-            const A(num a) : this.fi = /*$error1*/a;
+            const A(num a) : this.fi = /*warning:DownCastImplicit*/a;
           }
           class B extends A {
-            const B(Object a) : super(/*$error1*/a);
+            const B(Object a) : super(/*warning:DownCastImplicit*/a);
           }
           void foo(Object o) {
-            var a = const A(/*$error1*/o);
+            var a = const A(/*warning:DownCastImplicit*/o);
           }
-     ''';
-    testChecker(
-        {'/main.dart': mk("warning:DownCastImplicit", "info:AssignmentCast")});
+     '''
   });
 
-  test('casts in conditionals', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('casts in conditionals', {
+    '/main.dart': '''
           main() {
             bool b = true;
             num x = b ? 1 : 2.3;
             int y = /*info:AssignmentCast*/b ? 1 : 2.3;
             String z = !b ? "hello" : null;
             z = b ? null : "hello";
           }
       '''
-    });
   });
 
-  test('redirecting constructor', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('redirecting constructor', {
+    '/main.dart': '''
           class A {
             A(A x) {}
             A.two() : this(/*severe:StaticTypeError*/3);
           }
        '''
-    });
   });
 
-  test('super constructor', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('super constructor', {
+    '/main.dart': '''
           class A { A(A x) {} }
           class B extends A {
             B() : super(/*severe:StaticTypeError*/3);
           }
        '''
-    });
   });
 
-  test('field/field override', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'field/field override',
+      {
+        '/main.dart': '''
           class A {}
           class B extends A {}
           class C extends B {}
 
           class Base {
             B f1;
             B f2;
             B f3;
             B f4;
           }
 
           class Child extends Base {
             /*severe:InvalidMethodOverride*/A f1; // invalid for getter
             /*severe:InvalidMethodOverride*/C f2; // invalid for setter
             var f3;
             /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/dynamic f4;
           }
        '''
-    }, inferFromOverrides: true);
+      },
+      inferFromOverrides: true);
 
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'field/field override 2',
+      {
+        '/main.dart': '''
           class A {}
           class B extends A {}
           class C extends B {}
 
           class Base {
             B f1;
             B f2;
             B f3;
             B f4;
           }
 
           class Child extends Base {
             /*severe:InvalidMethodOverride*/A f1; // invalid for getter
             /*severe:InvalidMethodOverride*/C f2; // invalid for setter
             /*severe:InferableOverride,severe:InvalidMethodOverride*/var f3;
             /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/dynamic f4;
           }
        '''
-    }, inferFromOverrides: false);
-  });
+      },
+      inferFromOverrides: false);
 
-  test('getter/getter override', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'getter/getter override',
+      {
+        '/main.dart': '''
           class A {}
           class B extends A {}
           class C extends B {}
 
           abstract class Base {
             B get f1;
             B get f2;
             B get f3;
             B get f4;
           }
 
           class Child extends Base {
             /*severe:InvalidMethodOverride*/A get f1 => null;
             C get f2 => null;
             get f3 => null;
             /*severe:InvalidMethodOverride*/dynamic get f4 => null;
           }
        '''
-    }, inferFromOverrides: true);
+      },
+      inferFromOverrides: true);
 
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'getter/getter override 2',
+      {
+        '/main.dart': '''
           class A {}
           class B extends A {}
           class C extends B {}
 
           abstract class Base {
             B get f1;
             B get f2;
             B get f3;
             B get f4;
           }
 
           class Child extends Base {
             /*severe:InvalidMethodOverride*/A get f1 => null;
             C get f2 => null;
             /*severe:InferableOverride*/get f3 => null;
             /*severe:InvalidMethodOverride*/dynamic get f4 => null;
           }
        '''
-    }, inferFromOverrides: false);
-  });
+      },
+      inferFromOverrides: false);
 
-  test('field/getter override', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'field/getter override',
+      {
+        '/main.dart': '''
           class A {}
           class B extends A {}
           class C extends B {}
 
           abstract class Base {
             B f1;
             B f2;
             B f3;
             B f4;
           }
 
           class Child extends Base {
             /*severe:InvalidMethodOverride*/A get f1 => null;
             C get f2 => null;
             get f3 => null;
             /*severe:InvalidMethodOverride*/dynamic get f4 => null;
           }
        '''
-    }, inferFromOverrides: true);
-  });
+      },
+      inferFromOverrides: true);
 
-  test('setter/setter override', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('setter/setter override', {
+    '/main.dart': '''
           class A {}
           class B extends A {}
           class C extends B {}
 
           abstract class Base {
             void set f1(B value);
             void set f2(B value);
             void set f3(B value);
             void set f4(B value);
             void set f5(B value);
           }
 
           class Child extends Base {
             void set f1(A value) {}
             /*severe:InvalidMethodOverride*/void set f2(C value) {}
             /*severe:InvalidMethodOverride*/void set f3(value) {}
             /*severe:InvalidMethodOverride*/void set f4(dynamic value) {}
             set f5(B value) {}
           }
        '''
-    });
   });
 
-  test('field/setter override', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('field/setter override', {
+    '/main.dart': '''
           class A {}
           class B extends A {}
           class C extends B {}
 
           class Base {
             B f1;
             B f2;
             B f3;
             B f4;
             B f5;
           }
 
           class Child extends Base {
             B get f1 => null;
             B get f2 => null;
             B get f3 => null;
             B get f4 => null;
             B get f5 => null;
 
             void set f1(A value) {}
             /*severe:InvalidMethodOverride*/void set f2(C value) {}
             /*severe:InvalidMethodOverride*/void set f3(value) {}
             /*severe:InvalidMethodOverride*/void set f4(dynamic value) {}
             set f5(B value) {}
           }
        '''
-    });
   });
 
-  test('method override', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'method override',
+      {
+        '/main.dart': '''
           class A {}
           class B extends A {}
           class C extends B {}
 
           class Base {
             B m1(B a);
             B m2(B a);
             B m3(B a);
             B m4(B a);
             B m5(B a);
             B m6(B a);
           }
 
           class Child extends Base {
             /*severe:InvalidMethodOverride*/A m1(A value) {}
             /*severe:InvalidMethodOverride*/C m2(C value) {}
             /*severe:InvalidMethodOverride*/A m3(C value) {}
             C m4(A value) {}
             /*severe:InvalidMethodOverride*/m5(value) {}
             /*severe:InvalidMethodOverride*/dynamic m6(dynamic value) {}
           }
        '''
-    }, inferFromOverrides: true);
-  });
+      },
+      inferFromOverrides: true);
 
-  test(
-      'unary operators',
-      () => testChecker({
-            '/main.dart': '''
+  testChecker('unary operators', {
+    '/main.dart': '''
       class A {
         A operator ~() {}
         A operator +(int x) {}
         A operator -(int x) {}
         A operator -() {}
       }
 
       foo() => new A();
 
       test() {
@@ skipping 12 matching lines @@
         ++a;
         --a;
         (/*info:DynamicInvoke*/++d);
         (/*info:DynamicInvoke*/--d);
 
         a++;
         a--;
         (/*info:DynamicInvoke*/d++);
         (/*info:DynamicInvoke*/d--);
       }'''
-          }));
+  });
 
-  test('binary and index operators', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('binary and index operators', {
+    '/main.dart': '''
           class A {
             A operator *(B b) {}
             A operator /(B b) {}
             A operator ~/(B b) {}
             A operator %(B b) {}
             A operator +(B b) {}
             A operator -(B b) {}
             A operator <<(B b) {}
             A operator >>(B b) {}
             A operator &(B b) {}
@@ skipping 41 matching lines @@
             p = (/*info:DynamicCast*/c) && /*info:DynamicCast*/c;
             p = (/*severe:StaticTypeError*/y) && p;
             p = c == y;
 
             a = a[b];
             a = a[/*info:DynamicCast*/c];
             c = (/*info:DynamicInvoke*/c[b]);
             a[/*severe:StaticTypeError*/y];
           }
        '''
-    });
   });
 
-  test('compound assignments', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('compound assignments', {
+    '/main.dart': '''
           class A {
             A operator *(B b) {}
             A operator /(B b) {}
             A operator ~/(B b) {}
             A operator %(B b) {}
             A operator +(B b) {}
             A operator -(B b) {}
             A operator <<(B b) {}
             A operator >>(B b) {}
             A operator &(B b) {}
@@ skipping 58 matching lines @@
 
             var d = new D();
             a[b] += d;
             a[/*info:DynamicCast*/c] += d;
             a[/*severe:StaticTypeError*/z] += d;
             a[b] += /*info:DynamicCast*/c;
             a[b] += /*severe:StaticTypeError*/z;
             (/*info:DynamicInvoke*/(/*info:DynamicInvoke*/c[b]) += d);
           }
        '''
-    });
   });
 
-  test('super call placement', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('super call placement', {
+    '/main.dart': '''
           class Base {
             var x;
             Base() : x = print('Base.1') { print('Base.2'); }
           }
 
           class Derived extends Base {
             var y, z;
             Derived()
                 : y = print('Derived.1'),
                   /*severe:InvalidSuperInvocation*/super(),
@@ skipping 11 matching lines @@
               print('Valid.3');
             }
           }
 
           class AlsoValid extends Base {
             AlsoValid() : super();
           }
 
           main() => new Derived();
        '''
-    });
   });
 
-  test('for loop variable', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('for loop variable', {
+    '/main.dart': '''
           foo() {
             for (int i = 0; i < 10; i++) {
               i = /*severe:StaticTypeError*/"hi";
             }
           }
           bar() {
             for (var i = 0; i < 10; i++) {
               int j = i + 1;
             }
           }
         '''
-    });
   });
 
   group('invalid overrides', () {
-    test('child override', () {
-      testChecker({
-        '/main.dart': '''
+    testChecker('child override', {
+      '/main.dart': '''
             class A {}
             class B {}
 
             class Base {
                 A f;
             }
 
             class T1 extends Base {
               /*severe:InvalidMethodOverride*/B get f => null;
             }
 
             class T2 extends Base {
               /*severe:InvalidMethodOverride*/set f(B b) => null;
             }
 
             class T3 extends Base {
               /*severe:InvalidMethodOverride*/final B f;
             }
             class T4 extends Base {
               // two: one for the getter one for the setter.
               /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/B f;
             }
          '''
-      });
+    });
 
-      testChecker({
-        '/main.dart': '''
+    testChecker('child override 2', {
+      '/main.dart': '''
             class A {}
             class B {}
 
             class Base {
                 m(A a) {}
             }
 
             class Test extends Base {
                 /*severe:InvalidMethodOverride*/m(B a) {}
             }
          '''
-      });
     });
-    test('grandchild override', () {
-      testChecker({
-        '/main.dart': '''
+    testChecker('grandchild override', {
+      '/main.dart': '''
             class A {}
             class B {}
 
             class Grandparent {
                 m(A a) {}
             }
             class Parent extends Grandparent {
             }
 
             class Test extends Parent {
                 /*severe:InvalidMethodOverride*/m(B a) {}
             }
          '''
-      });
     });
 
-    test('double override', () {
-      testChecker({
-        '/main.dart': '''
+    testChecker('double override', {
+      '/main.dart': '''
             class A {}
             class B {}
 
             class Grandparent {
                 m(A a) {}
             }
             class Parent extends Grandparent {
                 m(A a) {}
             }
 
             class Test extends Parent {
                 // Reported only once
                 /*severe:InvalidMethodOverride*/m(B a) {}
             }
          '''
-      });
+    });
 
-      testChecker({
-        '/main.dart': '''
+    testChecker('double override 2', {
+      '/main.dart': '''
             class A {}
             class B {}
 
             class Grandparent {
                 m(A a) {}
             }
             class Parent extends Grandparent {
                 /*severe:InvalidMethodOverride*/m(B a) {}
             }
 
             class Test extends Parent {
                 m(B a) {}
             }
          '''
-      });
     });
 
-    test('mixin override to base', () {
-      testChecker({
-        '/main.dart': '''
+    testChecker('mixin override to base', {
+      '/main.dart': '''
             class A {}
             class B {}
 
             class Base {
                 m(A a) {}
             }
 
             class M1 {
                 m(B a) {}
             }
 
             class M2 {}
 
             class T1 extends Base with /*severe:InvalidMethodOverride*/M1 {}
             class T2 extends Base with /*severe:InvalidMethodOverride*/M1, M2 {}
             class T3 extends Base with M2, /*severe:InvalidMethodOverride*/M1 {}
          '''
-      });
     });
 
-    test('mixin override to mixin', () {
-      testChecker({
-        '/main.dart': '''
+    testChecker('mixin override to mixin', {
+      '/main.dart': '''
             class A {}
             class B {}
 
             class Base {
             }
 
             class M1 {
                 m(B a) {}
             }
 
             class M2 {
                 m(A a) {}
             }
 
             class T1 extends Base with M1, /*severe:InvalidMethodOverride*/M2 {}
          '''
-      });
     });
 
-    test('no duplicate mixin override', () {
-      // This is a regression test for a bug in an earlier implementation were
-      // names were hiding errors if the first mixin override looked correct,
-      // but subsequent ones did not.
-      testChecker({
-        '/main.dart': '''
+    // This is a regression test for a bug in an earlier implementation were
+    // names were hiding errors if the first mixin override looked correct,
+    // but subsequent ones did not.
+    testChecker('no duplicate mixin override', {
+      '/main.dart': '''
             class A {}
             class B {}
 
             class Base {
                 m(A a) {}
             }
 
             class M1 {
                 m(A a) {}
             }
 
             class M2 {
                 m(B a) {}
             }
 
             class M3 {
                 m(B a) {}
             }
 
             class T1 extends Base
                 with M1, /*severe:InvalidMethodOverride*/M2, M3 {}
          '''
-      });
     });
 
-    test('class override of interface', () {
-      testChecker({
-        '/main.dart': '''
+    testChecker('class override of interface', {
+      '/main.dart': '''
             class A {}
             class B {}
 
             abstract class I {
                 m(A a);
             }
 
             class T1 implements I {
                 /*severe:InvalidMethodOverride*/m(B a) {}
             }
          '''
-      });
     });
 
-    test('base class override to child interface', () {
-      testChecker({
-        '/main.dart': '''
+    testChecker('base class override to child interface', {
+      '/main.dart': '''
             class A {}
             class B {}
 
             abstract class I {
                 m(A a);
             }
 
             class Base {
                 m(B a) {}
             }
 
 
             class T1 /*severe:InvalidMethodOverride*/extends Base implements I {
             }
          '''
-      });
     });
 
-    test('mixin override of interface', () {
-      testChecker({
-        '/main.dart': '''
+    testChecker('mixin override of interface', {
+      '/main.dart': '''
             class A {}
             class B {}
 
             abstract class I {
                 m(A a);
             }
 
             class M {
                 m(B a) {}
             }
 
             class T1 extends Object with /*severe:InvalidMethodOverride*/M
                implements I {}
          '''
-      });
     });
 
-    test('no errors if subclass correctly overrides base and interface', () {
-      // This is a case were it is incorrect to say that the base class
-      // incorrectly overrides the interface.
-      testChecker({
-        '/main.dart': '''
+    // This is a case were it is incorrect to say that the base class
+    // incorrectly overrides the interface.
+    testChecker(
+        'no errors if subclass correctly overrides base and interface', {
+      '/main.dart': '''
             class A {}
             class B {}
 
             class Base {
                 m(A a) {}
             }
 
             class I1 {
                 m(B a) {}
             }
 
             class T1 /*severe:InvalidMethodOverride*/extends Base
                 implements I1 {}
 
             class T2 extends Base implements I1 {
                 /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/m(a) {}
             }
 
             class T3 extends Object with /*severe:InvalidMethodOverride*/Base
                 implements I1 {}
 
             class T4 extends Object with Base implements I1 {
                 /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/m(a) {}
             }
          '''
-      });
     });
+  });
 
-    group('class override of grand interface', () {
-      test('interface of interface of child', () {
-        testChecker({
-          '/main.dart': '''
+  group('class override of grand interface', () {
+    testChecker('interface of interface of child', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class I2 implements I1 {}
 
               class T1 implements I2 {
                   /*severe:InvalidMethodOverride*/m(B a) {}
               }
            '''
-        });
-      });
-      test('superclass of interface of child', () {
-        testChecker({
-          '/main.dart': '''
+    });
+    testChecker('superclass of interface of child', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class I2 extends I1 {}
 
               class T1 implements I2 {
                   /*severe:InvalidMethodOverride*/m(B a) {}
               }
            '''
-        });
-      });
-      test('mixin of interface of child', () {
-        testChecker({
-          '/main.dart': '''
+    });
+    testChecker('mixin of interface of child', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class M1 {
                   m(A a);
               }
               abstract class I2 extends Object with M1 {}
 
               class T1 implements I2 {
                   /*severe:InvalidMethodOverride*/m(B a) {}
               }
            '''
-        });
-      });
-      test('interface of abstract superclass', () {
-        testChecker({
-          '/main.dart': '''
+    });
+    testChecker('interface of abstract superclass', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class Base implements I1 {}
 
               class T1 extends Base {
                   /*severe:InvalidMethodOverride*/m(B a) {}
               }
            '''
-        });
-      });
-      test('interface of concrete superclass', () {
-        testChecker({
-          '/main.dart': '''
+    });
+    testChecker('interface of concrete superclass', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
 
               // See issue #25
               /*pass should be warning:AnalyzerError*/class Base implements I1 {
               }
 
               class T1 extends Base {
                   // not reported technically because if the class is concrete,
                   // it should implement all its interfaces and hence it is
                   // sufficient to check overrides against it.
                   m(B a) {}
               }
            '''
-        });
-      });
     });
+  });
 
-    group('mixin override of grand interface', () {
-      test('interface of interface of child', () {
-        testChecker({
-          '/main.dart': '''
+  group('mixin override of grand interface', () {
+    testChecker('interface of interface of child', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class I2 implements I1 {}
 
               class M {
                   m(B a) {}
               }
 
               class T1 extends Object with /*severe:InvalidMethodOverride*/M
                   implements I2 {
               }
            '''
-        });
-      });
-      test('superclass of interface of child', () {
-        testChecker({
-          '/main.dart': '''
+    });
+    testChecker('superclass of interface of child', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class I2 extends I1 {}
 
               class M {
                   m(B a) {}
               }
 
               class T1 extends Object with /*severe:InvalidMethodOverride*/M
                   implements I2 {
               }
            '''
-        });
-      });
-      test('mixin of interface of child', () {
-        testChecker({
-          '/main.dart': '''
+    });
+    testChecker('mixin of interface of child', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class M1 {
                   m(A a);
               }
               abstract class I2 extends Object with M1 {}
 
               class M {
                   m(B a) {}
               }
 
               class T1 extends Object with /*severe:InvalidMethodOverride*/M
                   implements I2 {
               }
            '''
-        });
-      });
-      test('interface of abstract superclass', () {
-        testChecker({
-          '/main.dart': '''
+    });
+    testChecker('interface of abstract superclass', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class Base implements I1 {}
 
               class M {
                   m(B a) {}
               }
 
               class T1 extends Base with /*severe:InvalidMethodOverride*/M {
               }
            '''
-        });
-      });
-      test('interface of concrete superclass', () {
-        testChecker({
-          '/main.dart': '''
+    });
+    testChecker('interface of concrete superclass', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
 
               // See issue #25
               /*pass should be warning:AnalyzerError*/class Base implements I1 {
               }
 
               class M {
                   m(B a) {}
               }
 
               class T1 extends Base with M {
               }
            '''
-        });
-      });
     });
+  });
 
-    group('superclass override of grand interface', () {
-      test('interface of interface of child', () {
-        testChecker({
-          '/main.dart': '''
+  group('superclass override of grand interface', () {
+    testChecker('interface of interface of child', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class I2 implements I1 {}
 
               class Base {
                   m(B a) {}
               }
 
               class T1 /*severe:InvalidMethodOverride*/extends Base
                   implements I2 {
               }
            '''
-        });
-      });
-      test('superclass of interface of child', () {
-        testChecker({
-          '/main.dart': '''
+    });
+    testChecker('superclass of interface of child', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class I2 extends I1 {}
 
               class Base {
                   m(B a) {}
               }
 
               class T1 /*severe:InvalidMethodOverride*/extends Base
                   implements I2 {
               }
            '''
-        });
-      });
-      test('mixin of interface of child', () {
-        testChecker({
-          '/main.dart': '''
+    });
+    testChecker('mixin of interface of child', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class M1 {
                   m(A a);
               }
               abstract class I2 extends Object with M1 {}
 
               class Base {
                   m(B a) {}
               }
 
               class T1 /*severe:InvalidMethodOverride*/extends Base
                   implements I2 {
               }
            '''
-        });
-      });
-      test('interface of abstract superclass', () {
-        testChecker({
-          '/main.dart': '''
+    });
+    testChecker('interface of abstract superclass', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
 
               abstract class Base implements I1 {
                   /*severe:InvalidMethodOverride*/m(B a) {}
               }
 
               class T1 extends Base {
                   // we consider the base class incomplete because it is
                   // abstract, so we report the error here too.
                   // TODO(sigmund): consider tracking overrides in a fine-grain
                   // manner, then this and the double-overrides would not be
                   // reported.
                   /*severe:InvalidMethodOverride*/m(B a) {}
               }
            '''
-        });
-      });
-      test('interface of concrete superclass', () {
-        testChecker({
-          '/main.dart': '''
+    });
+    testChecker('interface of concrete superclass', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
 
               class Base implements I1 {
                   /*severe:InvalidMethodOverride*/m(B a) {}
               }
 
               class T1 extends Base {
                   m(B a) {}
               }
            '''
-        });
-      });
     });
+  });
 
-    group('no duplicate reports from overriding interfaces', () {
-      test('type overrides same method in multiple interfaces', () {
-        testChecker({
-          '/main.dart': '''
+  group('no duplicate reports from overriding interfaces', () {
+    testChecker('type overrides same method in multiple interfaces', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
               abstract class I2 implements I1 {
                   m(A a);
               }
 
               class Base {
               }
 
               class T1 implements I2 {
                 /*severe:InvalidMethodOverride*/m(B a) {}
               }
            '''
-        });
-      });
+    });
 
-      test('type and base type override same method in interface', () {
-        testChecker({
-          '/main.dart': '''
+    testChecker('type and base type override same method in interface', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
 
               class Base {
                   m(B a);
               }
 
               // Note: no error reported in `extends Base` to avoid duplicating
               // the error in T1.
               class T1 extends Base implements I1 {
                 /*severe:InvalidMethodOverride*/m(B a) {}
               }
 
               // If there is no error in the class, we do report the error at
               // the base class:
               class T2 /*severe:InvalidMethodOverride*/extends Base
                   implements I1 {
               }
            '''
-        });
-      });
+    });
 
-      test('type and mixin override same method in interface', () {
-        testChecker({
-          '/main.dart': '''
+    testChecker('type and mixin override same method in interface', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
 
               class M {
                   m(B a);
               }
 
               class T1 extends Object with M implements I1 {
                 /*severe:InvalidMethodOverride*/m(B a) {}
               }
 
               class T2 extends Object with /*severe:InvalidMethodOverride*/M
                   implements I1 {
               }
            '''
-        });
-      });
+    });
 
-      test('two grand types override same method in interface', () {
-        testChecker({
-          '/main.dart': '''
+    testChecker('two grand types override same method in interface', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
 
               class Grandparent {
                   m(B a) {}
               }
 
               class Parent1 extends Grandparent {
                   m(B a) {}
               }
               class Parent2 extends Grandparent {
               }
 
               // Note: otherwise both errors would be reported on this line
               class T1 /*severe:InvalidMethodOverride*/extends Parent1
                   implements I1 {
               }
               class T2 /*severe:InvalidMethodOverride*/extends Parent2
                   implements I1 {
               }
            '''
-        });
-      });
+    });
 
-      test('two mixins override same method in interface', () {
-        testChecker({
-          '/main.dart': '''
+    testChecker('two mixins override same method in interface', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
 
               class M1 {
                   m(B a) {}
               }
 
               class M2 {
                   m(B a) {}
               }
 
               // Here we want to report both, because the error location is
               // different.
               // TODO(sigmund): should we merge these as well?
               class T1 extends Object
                   with /*severe:InvalidMethodOverride*/M1
                   with /*severe:InvalidMethodOverride*/M2
                   implements I1 {
               }
            '''
-        });
-      });
+    });
 
-      test('base type and mixin override same method in interface', () {
-        testChecker({
-          '/main.dart': '''
+    testChecker('base type and mixin override same method in interface', {
+      '/main.dart': '''
               class A {}
               class B {}
 
               abstract class I1 {
                   m(A a);
               }
 
               class Base {
                   m(B a) {}
               }
 
               class M {
                   m(B a) {}
               }
 
               // Here we want to report both, because the error location is
               // different.
               // TODO(sigmund): should we merge these as well?
               class T1 /*severe:InvalidMethodOverride*/extends Base
                   with /*severe:InvalidMethodOverride*/M
                   implements I1 {
               }
            '''
-        });
-      });
     });
+  });
 
-    test('no reporting of overrides with Object twice.', () {
-      // This is a regression test: we used to report it twice because it was
-      // the top super class and top super interface.
-      // TODO(sigmund): maybe we generalize this and don't report again errors
-      // when an interface is also a superclass.
-      testChecker({
+  // This is a regression test: we used to report it twice because it was
+  // the top super class and top super interface.
+  // TODO(sigmund): maybe we generalize this and don't report again errors
+  // when an interface is also a superclass.
+  testChecker(
+      'no reporting of overrides with Object twice.',
+      {
         '/main.dart': '''
             class A {}
             class T1 implements A {
                 /*severe:InferableOverride*/toString() {}
             }
          '''
-      }, inferFromOverrides: false);
-    });
-  });
+      },
+      inferFromOverrides: false);
 
-  test('invalid runtime checks', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('invalid runtime checks', {
+    '/main.dart': '''
           typedef int I2I(int x);
           typedef int D2I(x);
           typedef int II2I(int x, int y);
           typedef int DI2I(x, int y);
           typedef int ID2I(int x, y);
           typedef int DD2I(x, y);
 
           typedef I2D(int x);
           typedef D2D(x);
           typedef II2D(int x, int y);
@@ skipping 30 matching lines @@
             f = bar as II2I;
             f = bar as DI2I;
             f = bar as ID2I;
             f = bar as II2D;
             f = bar as DD2I;
             f = bar as DI2D;
             f = bar as ID2D;
             f = bar as DD2D;
           }
       '''
-    });
   });
 
-  test(
-      'custom URL mappings',
-      () => testChecker({
-            '/main.dart': '''
+  testChecker('custom URL mappings', {
+    '/main.dart': '''
       import 'dart:foobar' show Baz;
       main() {
         print(Baz.quux);
       }'''
-          }, customUrlMappings: {
-            'dart:foobar': '$testDirectory/checker/dart_foobar.dart'
-          }));
+  }, customUrlMappings: {
+    'dart:foobar': '$testDirectory/checker/dart_foobar.dart'
+  });
 
   group('function modifiers', () {
-    test(
-        'async',
-        () => testChecker({
-              '/main.dart': '''
+    testChecker('async', {
+      '/main.dart': '''
         import 'dart:async';
         import 'dart:math' show Random;
 
         dynamic x;
 
         foo1() async => x;
         Future foo2() async => x;
         Future<int> foo3() async => (/*info:DynamicCast*/x);
         Future<int> foo4() async => (/*severe:StaticTypeError*/new Future<int>.value(/*info:DynamicCast*/x));
 
@@ skipping 14 matching lines @@
 
         Future<bool> get issue_264 async {
           await 42;
           if (new Random().nextBool()) {
             return true;
           } else {
             return /*severe:StaticTypeError*/new Future<bool>.value(false);
           }
         }
     '''
-            }));
+    });
 
-    test(
-        'async*',
-        () => testChecker({
-              '/main.dart': '''
+    testChecker('async*', {
+      '/main.dart': '''
         import 'dart:async';
 
         dynamic x;
 
         bar1() async* { yield x; }
         Stream bar2() async* { yield x; }
         Stream<int> bar3() async* { yield (/*info:DynamicCast*/x); }
         Stream<int> bar4() async* { yield (/*severe:StaticTypeError*/new Stream<int>()); }
 
         baz1() async* { yield* (/*info:DynamicCast*/x); }
         Stream baz2() async* { yield* (/*info:DynamicCast*/x); }
         Stream<int> baz3() async* { yield* (/*warning:DownCastComposite*/x); }
         Stream<int> baz4() async* { yield* new Stream<int>(); }
         Stream<int> baz5() async* { yield* (/*info:InferredTypeAllocation*/new Stream()); }
     '''
-            }));
+    });
 
-    test(
-        'sync*',
-        () => testChecker({
-              '/main.dart': '''
+    testChecker('sync*', {
+      '/main.dart': '''
         import 'dart:async';
 
         dynamic x;
 
         bar1() sync* { yield x; }
         Iterable bar2() sync* { yield x; }
         Iterable<int> bar3() sync* { yield (/*info:DynamicCast*/x); }
         Iterable<int> bar4() sync* { yield (/*severe:StaticTypeError*/new Iterable<int>()); }
 
         baz1() sync* { yield* (/*info:DynamicCast*/x); }
         Iterable baz2() sync* { yield* (/*info:DynamicCast*/x); }
         Iterable<int> baz3() sync* { yield* (/*warning:DownCastComposite*/x); }
         Iterable<int> baz4() sync* { yield* new Iterable<int>(); }
         Iterable<int> baz5() sync* { yield* (/*info:InferredTypeAllocation*/new Iterable()); }
     '''
-            }));
+    });
 
-    test(
-        'dart:math min/max',
-        () => testChecker({
-              '/main.dart': '''
+    testChecker('dart:math min/max', {
+      '/main.dart': '''
         import 'dart:math';
 
         void printInt(int x) => print(x);
         void printDouble(double x) => print(x);
 
         num myMax(num x, num y) => max(x, y);
 
         main() {
           // Okay if static types match.
           printInt(max(1, 2));
@@ skipping 11 matching lines @@
           printDouble(/*warning:DownCastImplicit*/max(1, 2.0));
           printDouble(/*warning:DownCastImplicit*/min(1, 2.0));
 
           // Types other than int and double are not accepted.
           printInt(
               /*warning:DownCastImplicit*/min(
                   /*severe:StaticTypeError*/"hi",
                   /*severe:StaticTypeError*/"there"));
         }
     '''
-            }));
+    });
   });
 }