Fix warnings_checker.dart handling of multitests

tests/isolate/message3_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // Dart test program for testing serialization of messages.
 // VMOptions=--enable_type_checks --enable_asserts
 
 library MessageTest;
 import 'dart:async';
 import 'dart:collection';
@@ skipping 133 matching lines @@
     // List must be fixed.
     Expect.throws(() => x.add(42));
   });
 
   List constList = const [1, 2];
   ping.send(constList);
   checks.add((x) {
     Expect.isTrue(x is List);
     Expect.listEquals([1, 2], x);
     // Make sure the list is immutable.
-    Expect.throws(() => x[0] = 0); // /// constList: ok
+    Expect.throws(() => x[0] = 0); // //# constList: ok
     // List must not be extendable.
     Expect.throws(() => x.add(3));
-    Expect.identical(x, constList); // /// constList_identical: ok
+    Expect.identical(x, constList); // //# constList_identical: ok
   });
 
   Uint8List uint8 = new Uint8List(2);
   uint8[0] = 0;
   uint8[1] = 1;
   ping.send(uint8);
   checks.add((x) {
     Expect.isTrue(x is Uint8List);
     Expect.equals(2, x.length);
     Expect.equals(0, x[0]);
     Expect.equals(1, x[1]);
   });
 
   Uint16List uint16 = new Uint16List(2);
   uint16[0] = 0;
   uint16[1] = 1;
   ByteBuffer byteBuffer = uint16.buffer;
-  ping.send(byteBuffer); // /// byteBuffer: ok
-  checks.add( //            /// byteBuffer: ok
+  ping.send(byteBuffer); // //# byteBuffer: ok
+  checks.add( //            //# byteBuffer: ok
   (x) {
     Expect.isTrue(x is ByteBuffer);
     Uint16List uint16View = new Uint16List.view(x);
     Expect.equals(2, uint16View.length);
     Expect.equals(0, uint16View[0]);
     Expect.equals(1, uint16View[1]);
   }
-  ) //                      /// byteBuffer: ok
+  ) //                      //# byteBuffer: ok
   ;
 
   Int32x4List list32x4 = new Int32x4List(2);
   list32x4[0] = new Int32x4(1, 2, 3, 4);
   list32x4[1] = new Int32x4(5, 6, 7, 8);
-  ping.send(list32x4); //   /// int32x4: ok
-  checks.add( //            /// int32x4: ok
+  ping.send(list32x4); //   //# int32x4: ok
+  checks.add( //            //# int32x4: ok
   (x) {
     Expect.isTrue(x is Int32x4List);
     Expect.equals(2, x.length);
     Int32x4 entry1 = x[0];
     Int32x4 entry2 = x[1];
     Expect.equals(1, entry1.x);
     Expect.equals(2, entry1.y);
     Expect.equals(3, entry1.z);
     Expect.equals(4, entry1.w);
     Expect.equals(5, entry2.x);
     Expect.equals(6, entry2.y);
     Expect.equals(7, entry2.z);
     Expect.equals(8, entry2.w);
   }
-  ) //                    /// int32x4: ok
+  ) //                    //# int32x4: ok
   ;
 
   ping.send({"foo": 499, "bar": 32});
   checks.add((x) {
     Expect.isTrue(x is LinkedHashMap);
     Expect.listEquals(["foo", "bar"], x.keys.toList());
     Expect.listEquals([499, 32], x.values.toList());
     Expect.equals(499, x["foo"]);
     Expect.equals(32, x["bar"]);
     // Must be mutable.
@@ skipping 53 matching lines @@
     Expect.equals(499, x["gee"]);
   });
 
   Map constMap = const {'foo': 499};
   ping.send(constMap);
   checks.add((x) {
     Expect.isTrue(x is Map);
     print(x.length);
     Expect.equals(1, x.length);
     Expect.equals(499, x['foo']);
-    Expect.identical(constMap, x); // /// constMap: ok
+    Expect.identical(constMap, x); // //# constMap: ok
     Expect.throws(() => constMap['bar'] = 42);
   });
 
   ping.send(new A());
   checks.add((x) {
     Expect.isTrue(x is A);
     Expect.equals(499, x.field);
   });
 
   ping.send(new A.named(42));
@@ skipping 54 matching lines @@
     Expect.isTrue(x is C);
     Expect.isTrue(x is D);
     Expect.isTrue(x is M);
     Expect.identical(x, x.field);
     Expect.equals(11, x.field2);
     Expect.equals(499, x.superField);
     Expect.equals(99, x.superField2);
     Expect.throws(() => x.field2 = 22);
   });
 
-  ping.send(new E(E.fooFun)); //       /// fun: ok
-  checks.add((x) { //                  /// fun: continued
-    Expect.equals(E.fooFun, x.fun); // /// fun: continued
-    Expect.equals(499, x.fun()); //    /// fun: continued
-  }); //                               /// fun: continued
+  ping.send(new E(E.fooFun)); //       //# fun: ok
+  checks.add((x) { //                  //# fun: continued
+    Expect.equals(E.fooFun, x.fun); // //# fun: continued
+    Expect.equals(499, x.fun()); //    //# fun: continued
+  }); //                               //# fun: continued
 
-  ping.send(new E(barFun)); //         /// fun: continued
-  checks.add((x) { //                  /// fun: continued
-    Expect.equals(barFun, x.fun); //   /// fun: continued
-    Expect.equals(42, x.fun()); //     /// fun: continued
-  }); //                               /// fun: continued
+  ping.send(new E(barFun)); //         //# fun: continued
+  checks.add((x) { //                  //# fun: continued
+    Expect.equals(barFun, x.fun); //   //# fun: continued
+    Expect.equals(42, x.fun()); //     //# fun: continued
+  }); //                               //# fun: continued
 
   Expect.throws(() => ping.send(new E(new E(null).instanceFun)));
 
   F nonConstF = new F();
   ping.send(nonConstF);
   checks.add((x) {
     Expect.equals("field", x.field);
     Expect.isFalse(identical(nonConstF, x));
   });
 
   const F constF = const F();
   ping.send(constF);
   checks.add((x) {
     Expect.equals("field", x.field);
-    Expect.identical(constF, x); // /// constInstance: ok
+    Expect.identical(constF, x); // //# constInstance: ok
   });
 
   G g1 = new G(nonConstF);
   G g2 = new G(constF);
   G g3 = const G(constF);
   ping.send(g1);
   ping.send(g2);
   ping.send(g3);
 
   checks.add((x) {  // g1.
     Expect.isTrue(x is G);
     Expect.isFalse(identical(g1, x));
     F f = x.field;
     Expect.equals("field", f.field);
     Expect.isFalse(identical(nonConstF, f));
   });
   checks.add((x) {  // g2.
     Expect.isTrue(x is G);
     Expect.isFalse(identical(g1, x));
     F f = x.field;
     Expect.equals("field", f.field);
-    Expect.identical(constF, f); // /// constInstance: continued
+    Expect.identical(constF, f); // //# constInstance: continued
   });
   checks.add((x) {  // g3.
     Expect.isTrue(x is G);
-    Expect.identical(g3, x); // /// constInstance: continued
+    Expect.identical(g3, x); // //# constInstance: continued
     F f = x.field;
     Expect.equals("field", f.field);
-    Expect.identical(constF, f); // /// constInstance: continued
+    Expect.identical(constF, f); // //# constInstance: continued
   });
 
   // Make sure objects in a map are serialized and deserialized in the correct
   // order.
   Map m = new Map();
   Value val1 = new Value(1);
   Value val2 = new Value(2);
   m[val1] = val2;
   m[val2] = val1;
   // Possible bug we want to catch:
@@ skipping 33 matching lines @@
     .spawn(echoMain, [initialReplyPort.sendPort, testPort.sendPort])
     .then((_) => initialReplyPort.first)
     .then((SendPort ping) {
       runTests(ping, checks);
       Expect.isTrue(checks.length > 0);
       completer.future
         .then((_) => ping.send("halt"))
         .then((_) => asyncEnd());
     });
 }