Fix warnings_checker.dart handling of multitests

tests/lib/mirrors/reflected_type_generics_test.dart

Index: tests/lib/mirrors/reflected_type_generics_test.dart
diff --git a/tests/lib/mirrors/reflected_type_generics_test.dart b/tests/lib/mirrors/reflected_type_generics_test.dart
index fa17cd62ad39d8a522eed204a3923373fec39f63..bae1b681f19151cc1f24db0c9ca91a322592fe72 100644
--- a/tests/lib/mirrors/reflected_type_generics_test.dart
+++ b/tests/lib/mirrors/reflected_type_generics_test.dart
@@ -47,7 +47,7 @@ main() {
       reflectType(FBounded, [FBounded]), new FBounded<FBounded>().runtimeType);
 
   var predicateHelper = new Helper<Predicate<P>>();
-  expectReflectedType(reflectType(Predicate, [P]), predicateHelper.param); /// 01: ok
+  expectReflectedType(reflectType(Predicate, [P]), predicateHelper.param); //# 01: ok
   var composite = new Composite<P, int>();
   expectReflectedType(reflectType(Composite, [P, int]), composite.runtimeType);
 
@@ -57,40 +57,40 @@ main() {
       (e) => e is ArgumentError && e.invalidValue is List,
       "Should throw an ArgumentError if reflecting not a generic class with "
       "empty list of type arguments");
-  Expect.throws( //                                                             /// 03: ok
-      () => reflectType(P, [B]), //                                             /// 03: continued
-      (e) => e is Error, //                                                     /// 03: continued
-      "Should throw an ArgumentError if reflecting not a generic class with " /// 03: continued
-      "some type arguments"); //                                                /// 03: continued
+  Expect.throws( //                                                             //# 03: ok
+      () => reflectType(P, [B]), //                                             //# 03: continued
+      (e) => e is Error, //                                                     //# 03: continued
+      "Should throw an ArgumentError if reflecting not a generic class with " //# 03: continued
+      "some type arguments"); //                                                //# 03: continued
   Expect.throws(
       () => reflectType(A, []),
       (e) => e is ArgumentError && e.invalidValue is List,
       "Should throw an ArgumentError if type argument list is empty for a "
       "generic class");
-  Expect.throws( //                                                             /// 04: ok
-      () => reflectType(A, [P, B]), //                                          /// 04: continued
-      (e) => e is ArgumentError && e.invalidValue is List, //                   /// 04: continued
-      "Should throw an ArgumentError if number of type arguments is not " //    /// 04: continued
-      "correct"); //                                                            /// 04: continued
-  Expect.throws(() => reflectType(B, [P]), (e) => e is Error, //            /// 05: ok
-      "Should throw an ArgumentError for non-generic class extending " //   /// 05: continued
-      "generic one"); //                                                    /// 05: continued
+  Expect.throws( //                                                             //# 04: ok
+      () => reflectType(A, [P, B]), //                                          //# 04: continued
+      (e) => e is ArgumentError && e.invalidValue is List, //                   //# 04: continued
+      "Should throw an ArgumentError if number of type arguments is not " //    //# 04: continued
+      "correct"); //                                                            //# 04: continued
+  Expect.throws(() => reflectType(B, [P]), (e) => e is Error, //            //# 05: ok
+      "Should throw an ArgumentError for non-generic class extending " //   //# 05: continued
+      "generic one"); //                                                    //# 05: continued
   Expect.throws(
       () => reflectType(A, ["non-type"]),
       (e) => e is ArgumentError && e.invalidValue is List,
       "Should throw an ArgumentError when any of type arguments is not a Type");
-  Expect.throws( //                                                                /// 06: ok
-      () => reflectType(A, [P, B]), //                                              /// 06: continued
-      (e) => e is ArgumentError && e.invalidValue is List, //                       /// 06: continued
-      "Should throw an ArgumentError if number of type arguments is not correct " /// 06: continued
-      "for generic extending another generic"); //                                  /// 06: continued
+  Expect.throws( //                                                                //# 06: ok
+      () => reflectType(A, [P, B]), //                                              //# 06: continued
+      (e) => e is ArgumentError && e.invalidValue is List, //                       //# 06: continued
+      "Should throw an ArgumentError if number of type arguments is not correct " //# 06: continued
+      "for generic extending another generic"); //                                  //# 06: continued
   Expect.throws(
       () => reflectType(reflectType(F).typeVariables[0].reflectedType, [int]));
-  Expect.throws(() => reflectType(FBounded, [int])); /// 02: ok
+  Expect.throws(() => reflectType(FBounded, [int])); //# 02: ok
   var boundedType =
       reflectType(FBounded).typeVariables[0].upperBound.reflectedType;
-  Expect.throws(() => reflectType(boundedType, [int])); /// 02: ok
-  Expect.throws(() => reflectType(Composite, [int, int])); /// 02: ok
+  Expect.throws(() => reflectType(boundedType, [int])); //# 02: ok
+  Expect.throws(() => reflectType(Composite, [int, int])); //# 02: ok
 
   // Instantiation of a generic class preserves type information:
   ClassMirror m = reflectType(A, [P]) as ClassMirror;