fix testChecker to include test inside

test/checker/inferred_type_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.
 
 /// Tests for type inference.
 library dev_compiler.test.inferred_type_test;
 
 import 'package:test/test.dart';
 
 import '../testing.dart';
 
 void main() {
-  test('infer type on var', () {
-    // Error also expected when declared type is `int`.
-    testChecker({
-      '/main.dart': '''
+  // Error also expected when declared type is `int`.
+  testChecker('infer type on var', {
+    '/main.dart': '''
       test1() {
         int x = 3;
         x = /*severe:StaticTypeError*/"hi";
       }
     '''
-    });
+  });
 
-    // If inferred type is `int`, error is also reported
-    testChecker({
-      '/main.dart': '''
+  // If inferred type is `int`, error is also reported
+  testChecker('infer type on var 2', {
+    '/main.dart': '''
       test2() {
         var x = 3;
         x = /*severe:StaticTypeError*/"hi";
       }
     '''
-    });
   });
 
-  test('Error when declared type is `int` and assigned null.', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Error when declared type is `int` and assigned null.', {
+    '/main.dart': '''
         test1() {
           int x = 3;
           x = /*severe:StaticTypeError*/null;
         }
       '''
-    }, nonnullableTypes: <String>[
-      'int',
-      'double'
-    ]);
-  });
+  }, nonnullableTypes: <String>[
+    'int',
+    'double'
+  ]);
 
-  test('Error when inferred type is `int` and assigned null.', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('Error when inferred type is `int` and assigned null.', {
+    '/main.dart': '''
         test1() {
           var x = 3;
           x = /*severe:StaticTypeError*/null;
         }
       '''
-    }, nonnullableTypes: <String>[
-      'int',
-      'double'
-    ]);
-  });
+  }, nonnullableTypes: <String>[
+    'int',
+    'double'
+  ]);
 
-  test('No error when declared type is `num` and assigned null.', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('No error when declared type is `num` and assigned null.', {
+    '/main.dart': '''
         test1() {
           num x = 3;
           x = null;
         }
       '''
-    });
   });
 
-  test('do not infer type on dynamic', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('do not infer type on dynamic', {
+    '/main.dart': '''
       test() {
         dynamic x = 3;
         x = "hi";
       }
     '''
-    });
   });
 
-  test('do not infer type when initializer is null', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('do not infer type when initializer is null', {
+    '/main.dart': '''
       test() {
         var x = null;
         x = "hi";
         x = 3;
       }
     '''
-    });
   });
 
-  test('infer type on var from field', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('infer type on var from field', {
+    '/main.dart': '''
       class A {
         int x = 0;
 
         test1() {
           var a = x;
           a = /*severe:StaticTypeError*/"hi";
           a = 3;
           var b = y;
           b = /*severe:StaticTypeError*/"hi";
           b = 4;
           var c = z;
           c = /*severe:StaticTypeError*/"hi";
           c = 4;
         }
 
         int y; // field def after use
         final z = 42; // should infer `int`
       }
     '''
-    });
   });
 
-  test('infer type on var from top-level', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('infer type on var from top-level', {
+    '/main.dart': '''
       int x = 0;
 
       test1() {
         var a = x;
         a = /*severe:StaticTypeError*/"hi";
         a = 3;
         var b = y;
         b = /*severe:StaticTypeError*/"hi";
         b = 4;
         var c = z;
         c = /*severe:StaticTypeError*/"hi";
         c = 4;
       }
 
       int y = 0; // field def after use
       final z = 42; // should infer `int`
     '''
-    });
   });
 
-  test('do not infer field type when initializer is null', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('do not infer field type when initializer is null', {
+    '/main.dart': '''
       var x = null;
       var y = 3;
       class A {
         static var x = null;
         static var y = 3;
 
         var x2 = null;
         var y2 = 3;
       }
 
       test() {
         x = "hi";
         y = /*severe:StaticTypeError*/"hi";
         A.x = "hi";
         A.y = /*severe:StaticTypeError*/"hi";
         new A().x2 = "hi";
         new A().y2 = /*severe:StaticTypeError*/"hi";
       }
     '''
-    });
   });
 
-  test('do not infer from variables if flag is off', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'do not infer from variables if flag is off',
+      {
+        '/main.dart': '''
           var x = 2;
           var y = x;
 
           test1() {
             x = /*severe:StaticTypeError*/"hi";
             y = "hi";
           }
     '''
-    }, inferTransitively: false);
+      },
+      inferTransitively: false);
 
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'do not infer from variables if flag is off 2',
+      {
+        '/main.dart': '''
           class A {
             static var x = 2;
             static var y = A.x;
           }
 
           test1() {
             A.x = /*severe:StaticTypeError*/"hi";
             A.y = "hi";
           }
     '''
-    }, inferTransitively: false);
-  });
+      },
+      inferTransitively: false);
 
-  test('do not infer from variables in non-cycle imports if flag is off', () {
-    testChecker({
-      '/a.dart': '''
+  testChecker(
+      'do not infer from variables in non-cycle imports if flag is off',
+      {
+        '/a.dart': '''
           var x = 2;
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
           import 'a.dart';
           var y = x;
 
           test1() {
             x = /*severe:StaticTypeError*/"hi";
             y = "hi";
           }
     '''
-    }, inferTransitively: false);
+      },
+      inferTransitively: false);
 
-    testChecker({
-      '/a.dart': '''
+  testChecker(
+      'do not infer from variables in non-cycle imports if flag is off 2',
+      {
+        '/a.dart': '''
           class A { static var x = 2; }
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
           import 'a.dart';
           class B { static var y = A.x; }
 
           test1() {
             A.x = /*severe:StaticTypeError*/"hi";
             B.y = "hi";
           }
     '''
-    }, inferTransitively: false);
-  });
+      },
+      inferTransitively: false);
 
-  test('infer from variables in non-cycle imports with flag', () {
-    testChecker({
-      '/a.dart': '''
+  testChecker(
+      'infer from variables in non-cycle imports with flag',
+      {
+        '/a.dart': '''
           var x = 2;
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
           import 'a.dart';
           var y = x;
 
           test1() {
             x = /*severe:StaticTypeError*/"hi";
             y = /*severe:StaticTypeError*/"hi";
           }
     '''
-    }, inferTransitively: true);
+      },
+      inferTransitively: true);
 
-    testChecker({
-      '/a.dart': '''
+  testChecker(
+      'infer from variables in non-cycle imports with flag 2',
+      {
+        '/a.dart': '''
           class A { static var x = 2; }
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
           import 'a.dart';
           class B { static var y = A.x; }
 
           test1() {
             A.x = /*severe:StaticTypeError*/"hi";
             B.y = /*severe:StaticTypeError*/"hi";
           }
     '''
-    }, inferTransitively: true);
-  });
+      },
+      inferTransitively: true);
 
-  test('do not infer from variables in cycle libs when flag is off', () {
-    testChecker({
-      '/a.dart': '''
+  testChecker(
+      'do not infer from variables in cycle libs when flag is off',
+      {
+        '/a.dart': '''
           import 'main.dart';
           var x = 2; // ok to infer
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
           import 'a.dart';
           var y = x; // not ok to infer yet
 
           test1() {
             int t = 3;
             t = x;
             t = /*info:DynamicCast*/y;
           }
     '''
-    }, inferTransitively: false);
+      },
+      inferTransitively: false);
 
-    testChecker({
-      '/a.dart': '''
+  testChecker(
+      'do not infer from variables in cycle libs when flag is off 2',
+      {
+        '/a.dart': '''
           import 'main.dart';
           class A { static var x = 2; }
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
           import 'a.dart';
           class B { static var y = A.x; }
 
           test1() {
             int t = 3;
             t = A.x;
             t = /*info:DynamicCast*/B.y;
           }
     '''
-    }, inferTransitively: false);
-  });
+      },
+      inferTransitively: false);
 
-  test('infer from variables in cycle libs when flag is on', () {
-    testChecker({
-      '/a.dart': '''
+  testChecker(
+      'infer from variables in cycle libs when flag is on',
+      {
+        '/a.dart': '''
           import 'main.dart';
           var x = 2; // ok to infer
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
           import 'a.dart';
           var y = x; // now ok :)
 
           test1() {
             int t = 3;
             t = x;
             t = y;
           }
     '''
-    }, inferTransitively: true);
+      },
+      inferTransitively: true);
 
-    testChecker({
-      '/a.dart': '''
+  testChecker(
+      'infer from variables in cycle libs when flag is on 2',
+      {
+        '/a.dart': '''
           import 'main.dart';
           class A { static var x = 2; }
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
           import 'a.dart';
           class B { static var y = A.x; }
 
           test1() {
             int t = 3;
             t = A.x;
             t = B.y;
           }
     '''
-    }, inferTransitively: true);
-  });
+      },
+      inferTransitively: true);
 
-  test('do not infer from static and instance fields when flag is off', () {
-    testChecker({
-      '/a.dart': '''
+  testChecker(
+      'do not infer from static and instance fields when flag is off',
+      {
+        '/a.dart': '''
           import 'b.dart';
           class A {
             static final a1 = B.b1;
             final a2 = new B().b2;
           }
       ''',
-      '/b.dart': '''
+        '/b.dart': '''
           class B {
             static final b1 = 1;
             final b2 = 1;
           }
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
           import "a.dart";
 
           test1() {
             int x = 0;
             // inference in A disabled (flag is off)
             x = /*info:DynamicCast*/A.a1;
             x = /*info:DynamicCast*/new A().a2;
           }
     '''
-    }, inferTransitively: false);
-  });
+      },
+      inferTransitively: false);
 
-  test('can infer also from static and instance fields (flag on)', () {
-    testChecker({
-      '/a.dart': '''
+  testChecker(
+      'can infer also from static and instance fields (flag on)',
+      {
+        '/a.dart': '''
           import 'b.dart';
           class A {
             static final a1 = B.b1;
             final a2 = new B().b2;
           }
       ''',
-      '/b.dart': '''
+        '/b.dart': '''
           class B {
             static final b1 = 1;
             final b2 = 1;
           }
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
           import "a.dart";
 
           test1() {
             int x = 0;
             // inference in A now works.
             x = A.a1;
             x = new A().a2;
           }
     '''
-    }, inferTransitively: true);
-  });
+      },
+      inferTransitively: true);
 
-  test('inference in cycles is deterministic', () {
-    testChecker({
-      '/a.dart': '''
+  testChecker(
+      'inference in cycles is deterministic',
+      {
+        '/a.dart': '''
           import 'b.dart';
           class A {
             static final a1 = B.b1;
             final a2 = new B().b2;
           }
       ''',
-      '/b.dart': '''
+        '/b.dart': '''
           class B {
             static final b1 = 1;
             final b2 = 1;
           }
       ''',
-      '/c.dart': '''
+        '/c.dart': '''
           import "main.dart"; // creates a cycle
 
           class C {
             static final c1 = 1;
             final c2 = 1;
           }
       ''',
-      '/e.dart': '''
+        '/e.dart': '''
           import 'a.dart';
           part 'e2.dart';
 
           class E {
             static final e1 = 1;
             static final e2 = F.f1;
             static final e3 = A.a1;
             final e4 = 1;
             final e5 = new F().f2;
             final e6 = new A().a2;
           }
       ''',
-      '/f.dart': '''
+        '/f.dart': '''
           part 'f2.dart';
       ''',
-      '/e2.dart': '''
+        '/e2.dart': '''
           class F {
             static final f1 = 1;
             final f2 = 1;
           }
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
           import "a.dart";
           import "c.dart";
           import "e.dart";
 
           class D {
             static final d1 = A.a1 + 1;
             static final d2 = C.c1 + 1;
             final d3 = new A().a2;
             final d4 = new C().c2;
           }
@@ skipping 18 matching lines @@
             x = E.e1;
             x = E.e2;
             x = E.e3;
             x = new E().e4;
             x = /*info:DynamicCast*/new E().e5;
             x = new E().e6;
             x = F.f1;
             x = new F().f2;
           }
     '''
-    }, inferTransitively: true);
-  });
+      },
+      inferTransitively: true);
 
-  test('infer from complex expressions if the outer-most value is precise', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'infer from complex expressions if the outer-most value is precise', {
+    '/main.dart': '''
         class A { int x; B operator+(other) {} }
         class B extends A { B(ignore); }
         var a = new A();
         // Note: it doesn't matter that some of these refer to 'x'.
         var b = new B(x);       // allocations
         var c1 = [x];           // list literals
         var c2 = const [];
         var d = {'a': 'b'};     // map literals
         var e = new A()..x = 3; // cascades
         var f = 2 + 3;          // binary expressions are OK if the left operand
@@ skipping 22 matching lines @@
           g = 1;
           g = /*severe:StaticTypeError*/false;
           h = /*severe:StaticTypeError*/false;
           h = new B();
           i = false;
           j = new B();
           j = /*severe:StaticTypeError*/false;
           j = /*severe:StaticTypeError*/[];
         }
     '''
-    });
   });
 
-  test('do not infer if complex expressions read possibly inferred field', () {
-    testChecker({
-      '/a.dart': '''
+  testChecker(
+      'do not infer if complex expressions read possibly inferred field',
+      {
+        '/a.dart': '''
         class A {
           var x = 3;
         }
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
         import 'a.dart';
         class B {
           var y = 3;
         }
         final t1 = new A();
         final t2 = new A().x;
         final t3 = new B();
         final t4 = new B().y;
 
         test1() {
           int i = 0;
           A a;
           B b;
           a = t1;
           i = /*info:DynamicCast*/t2;
           b = t3;
           i = /*info:DynamicCast*/t4;
           i = new B().y; // B.y was inferred though
         }
     '''
-    }, inferTransitively: false);
+      },
+      inferTransitively: false);
 
-    // but flags can enable this behavior.
-    testChecker({
-      '/a.dart': '''
+  // but flags can enable this behavior.
+  testChecker(
+      'infer if complex expressions read possibly inferred field',
+      {
+        '/a.dart': '''
         class A {
           var x = 3;
         }
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
         import 'a.dart';
         class B {
           var y = 3;
         }
         final t1 = new A();
         final t2 = new A().x;
         final t3 = new B();
         final t4 = new B().y;
 
         test1() {
           int i = 0;
           A a;
           B b;
           a = t1;
           i = t2;
           b = t3;
           i = /*info:DynamicCast*/t4;
           i = new B().y; // B.y was inferred though
         }
     '''
-    }, inferTransitively: true);
-  });
+      },
+      inferTransitively: true);
 
-  test('infer types on loop indices', () {
-    // foreach loop
-    testChecker({
+  group('infer types on loop indices', () {
+    testChecker('foreach loop', {
       '/main.dart': '''
       class Foo {
         int bar = 42;
       }
 
       test() {
         var list = <Foo>[];
         for (var x in list) {
           String y = /*severe:StaticTypeError*/x;
         }
@@ skipping 29 matching lines @@
 
         // We're not properly inferring that map.keys is an Iterable<String>
         // and that x is a String.
         for (var x in map.keys) {
           String y = x;
         }
       }
       '''
     });
 
-    // for loop, with inference
-    testChecker({
+    testChecker('for loop, with inference', {
       '/main.dart': '''
       test() {
         for (var i = 0; i < 10; i++) {
           int j = i + 1;
         }
       }
       '''
     });
   });
 
-  test('propagate inference to field in class', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('propagate inference to field in class', {
+    '/main.dart': '''
       class A {
         int x = 2;
       }
 
       test() {
         var a = new A();
         A b = a;                      // doesn't require down cast
         print(a.x);     // doesn't require dynamic invoke
         print(a.x + 2); // ok to use in bigger expression
       }
     '''
-    });
+  });
 
-    // Same code with dynamic yields warnings
-    testChecker({
-      '/main.dart': '''
+  testChecker('propagate inference to field in class dynamic warnings', {
+    '/main.dart': '''
       class A {
         int x = 2;
       }
 
       test() {
         dynamic a = new A();
         A b = /*info:DynamicCast*/a;
         print(/*info:DynamicInvoke*/a.x);
         print(/*info:DynamicInvoke*/(/*info:DynamicInvoke*/a.x) + 2);
       }
     '''
-    });
   });
 
-  test('propagate inference transitively ', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker('propagate inference transitively', {
+    '/main.dart': '''
       class A {
         int x = 2;
       }
 
       test5() {
         var a1 = new A();
         a1.x = /*severe:StaticTypeError*/"hi";
 
         A a2 = new A();
         a2.x = /*severe:StaticTypeError*/"hi";
       }
     '''
-    });
+  });
 
-    testChecker({
-      '/main.dart': '''
+  testChecker('propagate inference transitively 2', {
+    '/main.dart': '''
       class A {
         int x = 42;
       }
 
       class B {
         A a = new A();
       }
 
       class C {
         B b = new B();
       }
 
       class D {
         C c = new C();
       }
 
       void main() {
         var d1 = new D();
         print(d1.c.b.a.x);
 
         D d2 = new D();
         print(d2.c.b.a.x);
       }
     '''
-    });
   });
 
-  test('infer type on overridden fields', () {
-    testChecker({
-      '/main.dart': '''
+  group('infer type on overridden fields', () {
+    testChecker(
+        '1',
+        {
+          '/main.dart': '''
         class A {
           int x = 2;
         }
 
         class B extends A {
           /*severe:InferableOverride*/get x => 3;
         }
 
         foo() {
           String y = /*info:DynamicCast*/new B().x;
           int z = /*info:DynamicCast*/new B().x;
         }
     '''
-    }, inferFromOverrides: false);
+        },
+        inferFromOverrides: false);
 
-    testChecker({
-      '/main.dart': '''
+    testChecker(
+        '2',
+        {
+          '/main.dart': '''
         class A {
           int x = 2;
         }
 
         class B extends A {
           get x => 3;
         }
 
         foo() {
           String y = /*severe:StaticTypeError*/new B().x;
           int z = new B().x;
         }
     '''
-    }, inferFromOverrides: true);
+        },
+        inferFromOverrides: true);
 
-    testChecker({
-      '/main.dart': '''
+    testChecker(
+        '3',
+        {
+          '/main.dart': '''
         class A {
           int x = 2;
         }
 
         class B implements A {
           /*severe:InferableOverride*/get x => 3;
         }
 
         foo() {
           String y = /*info:DynamicCast*/new B().x;
           int z = /*info:DynamicCast*/new B().x;
         }
     '''
-    }, inferFromOverrides: false);
+        },
+        inferFromOverrides: false);
 
-    testChecker({
-      '/main.dart': '''
+    testChecker(
+        '4',
+        {
+          '/main.dart': '''
         class A {
           int x = 2;
         }
 
         class B implements A {
           get x => 3;
         }
 
         foo() {
           String y = /*severe:StaticTypeError*/new B().x;
           int z = new B().x;
         }
     '''
-    }, inferFromOverrides: true);
+        },
+        inferFromOverrides: true);
   });
 
-  test('infer types on generic instantiations', () {
+  group('infer types on generic instantiations', () {
     for (bool infer in [true, false]) {
-      testChecker({
-        '/main.dart': '''
+      testChecker(
+          'infer: $infer',
+          {
+            '/main.dart': '''
           class A<T> {
             T x;
           }
 
           class B implements A<int> {
             /*severe:InvalidMethodOverride*/dynamic get x => 3;
           }
 
           foo() {
             String y = /*info:DynamicCast*/new B().x;
             int z = /*info:DynamicCast*/new B().x;
           }
       '''
-      }, inferFromOverrides: infer);
+          },
+          inferFromOverrides: infer);
     }
 
-    testChecker({
-      '/main.dart': '''
+    testChecker(
+        '2',
+        {
+          '/main.dart': '''
         class A<T> {
           T x;
         }
 
         class B implements A<int> {
           /*severe:InferableOverride*/get x => 3;
         }
 
         foo() {
           String y = /*info:DynamicCast*/new B().x;
           int z = /*info:DynamicCast*/new B().x;
         }
     '''
-    }, inferFromOverrides: false);
-    testChecker({
-      '/main.dart': '''
+        },
+        inferFromOverrides: false);
+
+    testChecker(
+        '3',
+        {
+          '/main.dart': '''
         class A<T> {
           T x;
           T w;
         }
 
         class B implements A<int> {
           get x => 3;
           get w => /*severe:StaticTypeError*/"hello";
         }
 
         foo() {
           String y = /*severe:StaticTypeError*/new B().x;
           int z = new B().x;
         }
     '''
-    }, inferFromOverrides: true);
+        },
+        inferFromOverrides: true);
 
-    testChecker({
-      '/main.dart': '''
+    testChecker(
+        '4',
+        {
+          '/main.dart': '''
         class A<T> {
           T x;
         }
 
         class B<E> extends A<E> {
           E y;
           get x => y;
         }
 
         foo() {
           int y = /*severe:StaticTypeError*/new B<String>().x;
           String z = new B<String>().x;
         }
     '''
-    }, inferFromOverrides: true);
+        },
+        inferFromOverrides: true);
 
-    testChecker({
-      '/main.dart': '''
+    testChecker(
+        '5',
+        {
+          '/main.dart': '''
         abstract class I<E> {
           String m(a, String f(v, T e));
         }
 
         abstract class A<E> implements I<E> {
           const A();
           String m(a, String f(v, T e));
         }
 
         abstract class M {
           int y;
         }
 
         class B<E> extends A<E> implements M {
           const B();
           int get y => 0;
 
           m(a, f(v, T e)) {}
         }
 
         foo () {
           int y = /*severe:StaticTypeError*/new B().m(null, null);
           String z = new B().m(null, null);
         }
     '''
-    }, inferFromOverrides: true);
+        },
+        inferFromOverrides: true);
   });
 
-  test('infer type regardless of declaration order or cycles', () {
-    testChecker({
-      '/b.dart': '''
+  testChecker(
+      'infer type regardless of declaration order or cycles',
+      {
+        '/b.dart': '''
         import 'main.dart';
 
         class B extends A { }
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
         import 'b.dart';
         class C extends B {
           get x;
         }
         class A {
           int get x;
         }
         foo () {
           int y = new C().x;
           String y = /*severe:StaticTypeError*/new C().x;
         }
     '''
-    }, inferFromOverrides: true);
-  });
+      },
+      inferFromOverrides: true);
 
   // Note: this is a regression test for a non-deterministic behavior we used to
   // have with inference in library cycles. If you see this test flake out,
   // change `test` to `skip_test` and reopen bug #48.
-  test('infer types on generic instantiations in library cycle', () {
-    testChecker({
-      '/a.dart': '''
+  testChecker(
+      'infer types on generic instantiations in library cycle',
+      {
+        '/a.dart': '''
           import 'main.dart';
         abstract class I<E> {
           A<E> m(a, String f(v, T e));
         }
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
           import 'a.dart';
 
         abstract class A<E> implements I<E> {
           const A();
 
           E value;
         }
 
         abstract class M {
           int y;
         }
 
         class B<E> extends A<E> implements M {
           const B();
           int get y => 0;
 
           m(a, f(v, T e)) {}
         }
 
         foo () {
           int y = /*severe:StaticTypeError*/new B<String>().m(null, null).value;
           String z = new B<String>().m(null, null).value;
         }
     '''
-    }, inferFromOverrides: true);
-  });
+      },
+      inferFromOverrides: true);
 
-  test('do not infer overridden fields that explicitly say dynamic', () {
+  group('do not infer overridden fields that explicitly say dynamic', () {
     for (bool infer in [true, false]) {
-      testChecker({
-        '/main.dart': '''
+      testChecker(
+          'infer: $infer',
+          {
+            '/main.dart': '''
           class A {
             int x = 2;
           }
 
           class B implements A {
             /*severe:InvalidMethodOverride*/dynamic get x => 3;
           }
 
           foo() {
             String y = /*info:DynamicCast*/new B().x;
             int z = /*info:DynamicCast*/new B().x;
           }
       '''
-      }, inferFromOverrides: infer);
+          },
+          inferFromOverrides: infer);
     }
   });
 
-  test('conflicts can happen', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'conflicts can happen',
+      {
+        '/main.dart': '''
         class I1 {
           int x;
         }
         class I2 extends I1 {
           int y;
         }
 
         class A {
           final I1 a;
         }
 
         class B {
           final I2 a;
         }
 
         class C1 extends A implements B {
           /*severe:InvalidMethodOverride*/get a => null;
         }
 
         // Here we infer from B, which is more precise.
         class C2 extends B implements A {
           get a => null;
         }
     '''
-    }, inferFromOverrides: true);
+      },
+      inferFromOverrides: true);
 
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'conflicts can happen 2',
+      {
+        '/main.dart': '''
         class I1 {
           int x;
         }
         class I2 {
           int y;
         }
 
         class I3 implements I1, I2 {
           int x;
           int y;
         }
 
         class A {
           final I1 a;
         }
 
         class B {
           final I2 a;
         }
 
         class C1 extends A implements B {
           I3 get a => null;
         }
 
         class C2 extends A implements B {
           /*severe:InvalidMethodOverride*/get a => null;
         }
     '''
-    }, inferFromOverrides: true);
-  });
+      },
+      inferFromOverrides: true);
 
-  test('infer from RHS only if it wont conflict with overridden fields', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'infer from RHS only if it wont conflict with overridden fields',
+      {
+        '/main.dart': '''
         class A {
           var x;
         }
 
         class B extends A {
           var x = 2;
         }
 
         foo() {
           String y = /*info:DynamicCast*/new B().x;
           int z = /*info:DynamicCast*/new B().x;
         }
     '''
-    }, inferFromOverrides: true);
+      },
+      inferFromOverrides: true);
 
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'infer from RHS only if it wont conflict with overridden fields 2',
+      {
+        '/main.dart': '''
         class A {
           final x;
         }
 
         class B extends A {
           final x = 2;
         }
 
         foo() {
           String y = /*severe:StaticTypeError*/new B().x;
           int z = new B().x;
         }
     '''
-    }, inferFromOverrides: true);
-  });
+      },
+      inferFromOverrides: true);
 
-  test('infer correctly on multiple variables declared together', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'infer correctly on multiple variables declared together',
+      {
+        '/main.dart': '''
         class A {
           var x, y = 2, z = "hi";
         }
 
         class B extends A {
           var x = 2, y = 3, z, w = 2;
         }
 
         foo() {
           String s;
           int i;
 
           s = /*info:DynamicCast*/new B().x;
           s = /*severe:StaticTypeError*/new B().y;
           s = new B().z;
           s = /*severe:StaticTypeError*/new B().w;
 
           i = /*info:DynamicCast*/new B().x;
           i = new B().y;
           i = /*severe:StaticTypeError*/new B().z;
           i = new B().w;
         }
     '''
-    }, inferFromOverrides: true);
-  });
+      },
+      inferFromOverrides: true);
 
-  test('infer consts transitively', () {
-    testChecker({
-      '/b.dart': '''
+  testChecker(
+      'infer consts transitively',
+      {
+        '/b.dart': '''
         const b1 = 2;
       ''',
-      '/a.dart': '''
+        '/a.dart': '''
         import 'main.dart';
         import 'b.dart';
         const a1 = m2;
         const a2 = b1;
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
         import 'a.dart';
         const m1 = a1;
         const m2 = a2;
 
         foo() {
           int i;
           i = m1;
         }
     '''
-    }, inferFromOverrides: true, inferTransitively: true);
-  });
+      },
+      inferFromOverrides: true,
+      inferTransitively: true);
 
-  test('infer statics transitively', () {
-    testChecker({
-      '/b.dart': '''
+  testChecker(
+      'infer statics transitively',
+      {
+        '/b.dart': '''
         final b1 = 2;
       ''',
-      '/a.dart': '''
+        '/a.dart': '''
         import 'main.dart';
         import 'b.dart';
         final a1 = m2;
         class A {
           static final a2 = b1;
         }
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
         import 'a.dart';
         final m1 = a1;
         final m2 = A.a2;
 
         foo() {
           int i;
           i = m1;
         }
     '''
-    }, inferFromOverrides: true, inferTransitively: true);
+      },
+      inferFromOverrides: true,
+      inferTransitively: true);
 
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'infer statics transitively 2',
+      {
+        '/main.dart': '''
         const x1 = 1;
         final x2 = 1;
         final y1 = x1;
         final y2 = x2;
 
         foo() {
           int i;
           i = y1;
           i = y2;
         }
     '''
-    }, inferFromOverrides: true, inferTransitively: true);
+      },
+      inferFromOverrides: true,
+      inferTransitively: true);
 
-    testChecker({
-      '/a.dart': '''
+  testChecker(
+      'infer statics transitively 3',
+      {
+        '/a.dart': '''
         const a1 = 3;
         const a2 = 4;
         class A {
           a3;
         }
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
         import 'a.dart' show a1, A;
         import 'a.dart' as p show a2, A;
         const t1 = 1;
         const t2 = t1;
         const t3 = a1;
         const t4 = p.a2;
         const t5 = A.a3;
         const t6 = p.A.a3;
 
         foo() {
           int i;
           i = t1;
           i = t2;
           i = t3;
           i = t4;
         }
     '''
-    }, inferFromOverrides: true, inferTransitively: true);
-  });
+      },
+      inferFromOverrides: true,
+      inferTransitively: true);
 
-  test('infer statics with method invocations', () {
-    testChecker({
-      '/a.dart': '''
+  testChecker(
+      'infer statics with method invocations',
+      {
+        '/a.dart': '''
         m3(String a, String b, [a1,a2]) {}
       ''',
-      '/main.dart': '''
+        '/main.dart': '''
         import 'a.dart';
         class T {
           static final T foo = m1(m2(m3('', '')));
           static T m1(String m) { return null; }
           static String m2(e) { return ''; }
         }
 
 
     '''
-    }, inferFromOverrides: true, inferTransitively: true);
-  });
+      },
+      inferFromOverrides: true,
+      inferTransitively: true);
 
-  test('downwards inference: miscellaneous', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'downwards inference: miscellaneous',
+      {
+        '/main.dart': '''
       typedef (T x);
       class A<T> {
         Function2<T> x;
         A(this.x);
       }
       void main() {
           {  // Variables, nested literals
             var x = "hello";
             var y = 3;
             void f(List<Map<int, String>> l) {};
             f(/*info:InferredTypeLiteral*/[{y: x}]);
           }
           {
             int f(int x) {};
             A<int> a = /*info:InferredTypeAllocation*/new A(f);
           }
       }
       '''
-    }, inferDownwards: true);
-  });
+      },
+      inferDownwards: true);
 
-  test('downwards inference on instance creations', () {
+  group('downwards inference on instance creations', () {
     String mk(String info) => '''
       class A<S, T> {
         S x;
         T y;
         A(this.x, this.y);
         A.named(this.x, this.y);
       }
 
       class B<S, T> extends A<T, S> {
         B(S y, T x) : super(x, y);
@@ skipping 74 matching lines @@
         { // Check named and optional arguments
           A<int, String> a0 = /*$info*/new F(3, "hello", a: [3], b: ["hello"]);
           A<int, String> a1 = /*severe:StaticTypeError*/new F(3, "hello", a: ["hello"], b:[3]);
           A<int, String> a2 = /*$info*/new F.named(3, "hello", 3, "hello");
           A<int, String> a3 = /*$info*/new F.named(3, "hello");
           A<int, String> a4 = /*severe:StaticTypeError*/new F.named(3, "hello", "hello", 3);
           A<int, String> a5 = /*severe:StaticTypeError*/new F.named(3, "hello", "hello");
         }
       }
         ''';
-    testChecker({'/main.dart': mk("info:InferredTypeAllocation")},
+    testChecker(
+        'infer downwards', {'/main.dart': mk("info:InferredTypeAllocation")},
         inferDownwards: true);
-    testChecker({'/main.dart': mk("severe:StaticTypeError")},
+    testChecker(
+        'no infer downwards', {'/main.dart': mk("severe:StaticTypeError")},
         inferDownwards: false);
   });
 
-  test('downwards inference on list literals', () {
+  group('downwards inference on list literals', () {
     String mk(String info) => '''
       void foo([List<String> list1 = /*$info*/const [],
                 List<String> list2 = /*severe:StaticTypeError*/const [42]]) {
       }
 
       void main() {
         {
           List<int> l0 = /*$info*/[];
           List<int> l1 = /*$info*/[3];
           List<int> l2 = /*severe:StaticTypeError*/["hello"];
@@ skipping 18 matching lines @@
           Iterable<int> i3 = /*severe:StaticTypeError*/["hello", 3];
         }
         {
           const List<int> c0 = /*$info*/const [];
           const List<int> c1 = /*$info*/const [3];
           const List<int> c2 = /*severe:StaticTypeError*/const ["hello"];
           const List<int> c3 = /*severe:StaticTypeError*/const ["hello", 3];
         }
       }
       ''';
-    testChecker({'/main.dart': mk("info:InferredTypeLiteral")},
+    testChecker(
+        'infer downwards', {'/main.dart': mk("info:InferredTypeLiteral")},
         inferDownwards: true);
-    testChecker({'/main.dart': mk("severe:StaticTypeError")},
+    testChecker(
+        'no infer downwards', {'/main.dart': mk("severe:StaticTypeError")},
         inferDownwards: false);
   });
 
-  test('downwards inference on function arguments', () {
+  group('downwards inference on function arguments', () {
     String mk(String info) => '''
       void f0(List<int> a) {};
       void f1({List<int> a}) {};
       void f2(Iterable<int> a) {};
       void f3(Iterable<Iterable<int>> a) {};
       void f4({Iterable<Iterable<int>> a}) {};
       void main() {
         f0(/*$info*/[]);
         f0(/*$info*/[3]);
         f0(/*severe:StaticTypeError*/["hello"]);
@@ skipping 13 matching lines @@
         f3(/*$info*/[[3]]);
         f3(/*severe:StaticTypeError*/[["hello"]]);
         f3(/*severe:StaticTypeError*/[["hello"], [3]]);
 
         f4(a: /*$info*/[]);
         f4(a: /*$info*/[[3]]);
         f4(a: /*severe:StaticTypeError*/[["hello"]]);
         f4(a: /*severe:StaticTypeError*/[["hello"], [3]]);
       }
       ''';
-    testChecker({'/main.dart': mk("info:InferredTypeLiteral")},
+    testChecker(
+        'infer downwards', {'/main.dart': mk("info:InferredTypeLiteral")},
         inferDownwards: true);
-    testChecker({'/main.dart': mk("severe:StaticTypeError")},
+    testChecker(
+        'no infer downwards', {'/main.dart': mk("severe:StaticTypeError")},
         inferDownwards: false);
   });
 
-  test('downwards inference on map literals', () {
+  group('downwards inference on map literals', () {
     String mk(String info) => '''
       void foo([Map<int, String> m1 = /*$info*/const {1: "hello"},
                 Map<int, String> m1 = /*severe:StaticTypeError*/const {"hello": "world"}]) {
       }
       void main() {
         {
           Map<int, String> l0 = /*$info*/{};
           Map<int, String> l1 = /*$info*/{3: "hello"};
           Map<int, String> l2 = /*severe:StaticTypeError*/{"hello": "hello"};
           Map<int, String> l3 = /*severe:StaticTypeError*/{3: 3};
@@ skipping 27 matching lines @@
         }
         {
           const Map<int, String> l0 = /*$info*/const {};
           const Map<int, String> l1 = /*$info*/const {3: "hello"};
           const Map<int, String> l2 = /*severe:StaticTypeError*/const {"hello": "hello"};
           const Map<int, String> l3 = /*severe:StaticTypeError*/const {3: 3};
           const Map<int, String> l4 = /*severe:StaticTypeError*/const {3:"hello", "hello": 3};
         }
       }
       ''';
-    testChecker({'/main.dart': mk("info:InferredTypeLiteral")},
+    testChecker(
+        'infer downwards', {'/main.dart': mk("info:InferredTypeLiteral")},
         inferDownwards: true);
-    testChecker({'/main.dart': mk("severe:StaticTypeError")},
+    testChecker(
+        'no infer downwards', {'/main.dart': mk("severe:StaticTypeError")},
         inferDownwards: false);
   });
 
-  test('downwards inference on function expressions', () {
-    testChecker({
-      '/main.dart': '''
+  testChecker(
+      'downwards inference on function expressions',
+      {
+        '/main.dart': '''
       typedef T Function2<S, T>(S x);
 
       void main () {
         {
           Function2<int, String> l0 = (int x) => null;
           Function2<int, String> l1 = (int x) => "hello";
           Function2<int, String> l2 = /*severe:StaticTypeError*/(String x) => "hello";
           Function2<int, String> l3 = /*severe:StaticTypeError*/(int x) => 3;
           Function2<int, String> l4 = /*warning:UninferredClosure should be severe:StaticTypeError*/(int x) {return 3};
         }
@@ skipping 12 matching lines @@
         }
         {
           Function2<int, int> l0 = /*info:InferredTypeClosure*/(x) => x;
           Function2<int, int> l1 = /*info:InferredTypeClosure*/(x) => /*info:DynamicInvoke should be pass*/x+1;
           Function2<int, String> l2 = /*info:InferredTypeClosure should be severe:StaticTypeError*/(x) => x;
           Function2<int, String> l3 = /*info:InferredTypeClosure should be severe:StaticTypeError*/(x) => /*info:DynamicInvoke should be pass*/x.substring(3);
           Function2<String, String> l4 = /*info:InferredTypeClosure*/(x) => /*info:DynamicInvoke should be pass*/x.substring(3);
         }
       }
       '''
-    }, inferDownwards: true);
-  });
+      },
+      inferDownwards: true);
 
-  test(
-      'inferred initializing formal checks default value',
-      () => testChecker({
-            '/main.dart': '''
+  testChecker('inferred initializing formal checks default value', {
+    '/main.dart': '''
       class Foo {
         var x = 1;
         Foo([this.x = /*severe:StaticTypeError*/"1"]);
       }'''
-          }));
+  });
 }