Update all tests

tests/language_strong/async_throw_in_catch_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.
 
 import "dart:async";
 import "package:expect/expect.dart";
 import "package:async_helper/async_helper.dart";
 
 class Tracer {
   final String expected;
@@ skipping 14 matching lines @@
   void done() {
     Expect.equals(expected.length, counter, "Received too few traces");
   }
 }
 
 foo1(Tracer tracer) async {
   try {
     tracer.trace("a");
     // This await forces dart2js to rewrite the try into a state machine
     // instead of relying on the existing structure.
-    await new Future.value(3); /// forceAwait: ok
+    await new Future.value(3); //# forceAwait: ok
     tracer.trace("b");
     throw "Error";
   } catch (error) {
     tracer.trace("c");
     Expect.equals("Error", error);
     throw "Error2";
     tracer.trace("d");
   } finally {
     tracer.trace("e");
   }
   tracer.trace("f");
 }
 
 foo2(Tracer tracer) async {
   try {
     tracer.trace("a");
-    await new Future.value(3); /// forceAwait: continued
+    await new Future.value(3); //# forceAwait: continued
     tracer.trace("b");
     throw "Error";
     tracer.trace("c");
   } catch (error) {
     tracer.trace("d");
     Expect.equals("Error", error);
     await new Future.error("Error2");
   } finally {
     tracer.trace("e");
   }
   tracer.trace("f");
 }
 
 foo3(Tracer tracer) async {
   try {
     tracer.trace("a");
-    await new Future.value(3); /// forceAwait: continued
+    await new Future.value(3); //# forceAwait: continued
     tracer.trace("b");
     throw "Error";
     tracer.trace("c");
   } catch (error) {
     Expect.equals("Error", error);
     tracer.trace("d");
     return;
   } finally {
     tracer.trace("e");
   }
   tracer.trace("f");
 }
 
 foo4(Tracer tracer) async {
   try {
     try {
-      await new Future.value(3); /// forceAwait: continued
+      await new Future.value(3); //# forceAwait: continued
       tracer.trace("a");
       throw "Error";
     } catch(error) {
       tracer.trace("b");
       Expect.equals("Error", error);
       throw "Error2";
     }
   } catch(error) {
     Expect.equals("Error2", error);
     tracer.trace("c");
   }
   tracer.trace("d");
 
 }
 
 foo5(Tracer tracer) async {
   try {
     tracer.trace("a");
     try {
-      await new Future.value(3); /// forceAwait: continued
+      await new Future.value(3); //# forceAwait: continued
       tracer.trace("b");
       throw "Error";
     } catch(error) {
       tracer.trace("c");
       Expect.equals("Error", error);
       throw "Error2";
     }
   } finally {
     tracer.trace("d");
   }
   tracer.trace("e");
 
 }
 
 foo6(Tracer tracer) async {
   try {
     try {
-      await new Future.value(3); /// forceAwait: continued
+      await new Future.value(3); //# forceAwait: continued
       tracer.trace("a");
       throw "Error";
     } catch(error) {
       tracer.trace("b");
       Expect.equals("Error", error);
       throw "Error2";
     } finally {
       tracer.trace("c");
       throw "Error3";
     }
   } catch(error) {
     tracer.trace("d");
     Expect.equals("Error3", error);
   }
   tracer.trace("e");
 }
 
 foo7(Tracer tracer) async {
   try {
     try {
-      await new Future.value(3); /// forceAwait: continued
+      await new Future.value(3); //# forceAwait: continued
       tracer.trace("a");
       throw "Error";
     } catch(error) {
       Expect.equals("Error", error);
       tracer.trace("b");
       throw "Error2";
     } finally {
       tracer.trace("c");
       throw "Error3";
     }
   } finally {
     tracer.trace("d");
   }
   tracer.trace("e");
 }
 
 foo8(Tracer tracer) async {
   try {
     try {
-      await new Future.value(3); /// forceAwait: continued
+      await new Future.value(3); //# forceAwait: continued
       tracer.trace("a");
       throw "Error";
     } catch(error) {
       Expect.equals("Error", error);
       tracer.trace("b");
       return;
     } finally {
       tracer.trace("c");
       throw "Error3";
     }
   } finally {
     tracer.trace("d");
   }
   tracer.trace("e");
 }
 
 foo9(Tracer tracer) async {
   try {
     while(true) {
       try {
-        await new Future.value(3); /// forceAwait: continued
+        await new Future.value(3); //# forceAwait: continued
         tracer.trace("a");
         throw "Error";
       } catch(error) {
         Expect.equals("Error", error);
         tracer.trace("b");
         return;
       } finally {
         tracer.trace("c");
         break;
       }
       tracer.trace("d");
     }
   } finally {
     tracer.trace("e");
   }
   tracer.trace("f");
 }
 
 foo10(Tracer tracer) async {
   try {
     int i = 0;
     while (true) {
       try {
         try {
           tracer.trace("a");
           throw "Error";
         } catch (error) {
           tracer.trace("b");
           try {
-            await new Future.value(3);  /// forceAwait: continued
+            await new Future.value(3);  //# forceAwait: continued
             throw "Error2";
           } catch(error) {
             tracer.trace("c");
           } finally {
             tracer.trace("d");
           }
           tracer.trace("e");
           throw "Error3";
         } finally {
           tracer.trace("f");
@@ skipping 12 matching lines @@
   tracer.trace("i");
 }
 
 foo11(Tracer tracer) async {
   try {
     bool firstTime = true;
     while(true) {
       tracer.trace("a");
       if (firstTime) {
         try {
-          await new Future.value(3); /// forceAwait: continued
+          await new Future.value(3); //# forceAwait: continued
           tracer.trace("b");
           throw "Error";
         } catch(error) {
           Expect.equals("Error", error);
           tracer.trace("c");
           firstTime = false;
           continue;
         } finally {
           tracer.trace("d");
         }
       } else {
         tracer.trace("e");
         return;
       }
     }
   } finally {
     tracer.trace("f");
   }
   tracer.trace("g");
 }
 
 foo12(Tracer tracer) async {
   try {
     bool firstTime = true;
     while(true) {
       tracer.trace("a");
       if (firstTime) {
         try {
-          await new Future.value(3); /// forceAwait: continued
+          await new Future.value(3); //# forceAwait: continued
           tracer.trace("b");
           throw "Error";
         } catch(error) {
           Expect.equals("Error", error);
           tracer.trace("c");
           firstTime = false;
           continue;
         } finally {
           tracer.trace("d");
           break;
@@ skipping 13 matching lines @@
   try {
     try {
       tracer.trace("a");
       return;
     } catch (error) {
       tracer.trace("b");
     } finally {
       tracer.trace("c");
       try {
         try {
-          await new Future.value(3);  /// forceAwait: continued
+          await new Future.value(3);  //# forceAwait: continued
           tracer.trace("d");
           throw "Error";
         } finally {
           tracer.trace("e");
         }
       } finally {
         tracer.trace("f");
       }
     }
   } finally {
     tracer.trace("g");
   }
   tracer.trace("h");
 }
 
 foo14(Tracer tracer) async {
   try {
     try {
       tracer.trace("a");
       throw "Error";
     } catch (error) {
       tracer.trace("b");
       try {
-        await new Future.value(3);  /// forceAwait: continued
+        await new Future.value(3);  //# forceAwait: continued
         throw "Error2";
       } catch(error) {
         tracer.trace("c");
       } finally {
         tracer.trace("d");
       }
       tracer.trace("e");
       throw "Error3";
     } finally {
       tracer.trace("f");
     }
   } finally {
     tracer.trace("g");
   }
   tracer.trace("h");
 }
 
 foo15(Tracer tracer) async {
   try {
     try {
       tracer.trace("a");
       throw "Error";
     } catch (error) {
       tracer.trace("b");
       try {
-        await new Future.value(3);  /// forceAwait: continued
+        await new Future.value(3);  //# forceAwait: continued
         throw "Error2";
       } catch(error) {
         tracer.trace("c");
       } finally {
         tracer.trace("d");
       }
       tracer.trace("e");
       throw "Error3";
     } finally {
       tracer.trace("f");
       return;
     }
   } finally {
     tracer.trace("g");
   }
   tracer.trace("h");
 }
 
 foo16(Tracer tracer) async {
   try {
     try {
       tracer.trace("a");
       throw "Error";
     } catch (error) {
       tracer.trace("b");
       try {
-        await new Future.value(3);  /// forceAwait: continued
+        await new Future.value(3);  //# forceAwait: continued
         throw "Error2";
       } catch(error) {
         tracer.trace("c");
       } finally {
         tracer.trace("d");
         return;
       }
       tracer.trace("e");
       throw "Error3";
     } finally {
       tracer.trace("f");
     }
   } finally {
     tracer.trace("g");
   }
   tracer.trace("h");
 }
 
 foo17(Tracer tracer) async {
   try {
     tracer.trace("a");
   } finally {
     try {
       tracer.trace("b");
       throw "Error";
     } catch (error) {
-      await new Future.value(3);  /// forceAwait: continued
+      await new Future.value(3);  //# forceAwait: continued
       Expect.equals("Error", error);
       tracer.trace("c");
     } finally {
       tracer.trace("d");
     }
     tracer.trace("e");
   }
   tracer.trace("f");
 }
 
 foo18(Tracer tracer) async {
   try {
       tracer.trace("a");
   } finally {
     try {
       tracer.trace("b");
     } finally {
-      await new Future.value(3);  /// forceAwait: continued
+      await new Future.value(3);  //# forceAwait: continued
       tracer.trace("c");
     }
     tracer.trace("d");
   }
   tracer.trace("e");
 }
 
 runTest(expectedTrace, fun, [expectedError]) async {
   Tracer tracer = new Tracer(expectedTrace, expectedTrace);
   try {
@@ skipping 23 matching lines @@
   await runTest("abcdefgX", foo14, "Error3");
   await runTest("abcdefg", foo15);
   await runTest("abcdfg", foo16);
   await runTest("abcdef", foo17);
   await runTest("abcde", foo18);
 }
 
 void main() {
   asyncTest(test);
 }