#2398. Make asyncStart/End() safe in LibTest/async (#2416)

LibTest/async/Completer/completeError_A01_t01.dart

@@ -34,11 +34,14 @@ check(value) {
 }
 
 main() {
+  asyncStart();
   check(0);
   check(-5);
-  //check(null); // null is disallowed as an argument to completeError()
   check('string');
   check(true);
   check(const {'k1': 1, 'k2': 2});
-  Future.wait(futures).whenComplete(() => Expect.equals(5, count));
+  Future.wait(futures).whenComplete(() {
+    Expect.equals(5, count);
+    asyncEnd();
+  });
 }

LibTest/async/Completer/completeError_A01_t02.dart

@@ -15,26 +15,20 @@ import "dart:async";
 main() {
   var completer = new Completer();
   var future = completer.future;
-
   var error = new Error();
   var stackTrace;
 
   asyncStart();
-
   try {
     throw error;
-  } catch(e, st) {
+  } catch (e, st) {
     stackTrace = st;
     completer.completeError(e, st);
   }
 
-  future.then(
-          (fValue) => Expect.fail('should not get here'),
-          onError:(e, st) {
-            Expect.identical(error, e);
-            Expect.identical(stackTrace, st);
-            asyncEnd();
-          }
-    );
+  future.then((fValue) => Expect.fail('should not get here'), onError: (e, st) {
+    Expect.identical(error, e);
+    Expect.identical(stackTrace, st);
+    asyncEnd();
+  });
 }
-

LibTest/async/Completer/completeError_A01_t03.dart

@@ -16,21 +16,16 @@ import "dart:async";
 main() {
   var completer = new Completer();
   var future = completer.future;
-
-  var v = [1,2,3];
+  var v = [1, 2, 3];
 
   asyncStart(2);
-
   var f = new Future.value(v).then((x) {
     asyncEnd();
     return x;
   });
-
-  future
-    .catchError((e) {
-      Expect.identical(f, e);
-      asyncEnd();
-    });
-
+  future.catchError((e) {
+    Expect.identical(f, e);
+    asyncEnd();
+  });
   completer.completeError(f);
 }

LibTest/async/Completer/completeError_A01_t04.dart

@@ -16,21 +16,16 @@ import "dart:async";
 main() {
   var completer = new Completer();
   var future = completer.future;
-
   var e = new Error();
 
   asyncStart(2);
-
   var f = new Future.error(e).catchError((x) {
     asyncEnd();
     return x;
   });
-
-  future
-    .catchError((e) {
-      Expect.identical(f, e);
-      asyncEnd();
-    });
-
+  future.catchError((e) {
+    Expect.identical(f, e);
+    asyncEnd();
+  });
   completer.completeError(f);
 }

LibTest/async/Completer/complete_A01_t01.dart

@@ -31,10 +31,12 @@ check(value) {
 }
 
 main() {
+  asyncStart();
   check(0);
   check(-5);
   check(null);
   check('string');
   check(true);
   check(const {'k1': 1, 'k2': 2});
+  asyncEnd();
 }

LibTest/async/Completer/complete_A01_t04.dart

@@ -24,6 +24,7 @@ main() {
   var completer = new Completer();
   var future = completer.future;
 
+  asyncStart();
   for (int k = 0; k < N; k++) {
     asyncStart();
     futures.add(future.then((fValue) {
@@ -32,7 +33,9 @@ main() {
       asyncEnd();
     }));
   }
-  Future.wait(futures).whenComplete(() => Expect.equals(N, count));
-
+  Future.wait(futures).whenComplete(() {
+    Expect.equals(N, count);
+    asyncEnd();
+  });
   completer.complete(v);
 }

LibTest/async/Completer/complete_A01_t05.dart

@@ -19,15 +19,12 @@ import "../../../Utils/expect.dart";
 main() {
   var completer = new Completer();
   var future = completer.future;
-
   var value = [1, 2, 3];
 
   asyncStart();
-
   future.then((x) {
     Expect.identical(value, x);
     asyncEnd();
   });
-
   completer.complete(new Future.value(value));
 }

LibTest/async/Completer/complete_A01_t06.dart

@@ -19,15 +19,12 @@ import "../../../Utils/expect.dart";
 main() {
   var completer = new Completer();
   var future = completer.future;
-
   var error = new Error();
 
   asyncStart();
-
   future.catchError((x) {
     Expect.identical(error, x);
     asyncEnd();
   });
-
   completer.complete(new Future.error(error));
 }

LibTest/async/DeferredLibrary/DeferredLibrary_A01_t01.dart

@@ -9,16 +9,14 @@
 /// @author kaigorodov
 /// @todo move from LibTest to Language
 
-
 import "../../../Utils/expect.dart";
 
 import 'DeferredLibrary_A01_t01.lib.dart' deferred as lazy;
 
 void main() {
   try {
     lazy.method(); // foo is not loaded yet.
-//    Expect.fail("NoSuchMethodError expected"); -- #11507: do not insist on lazy loading
-  } on NoSuchMethodError  catch(ok) {
+  } on NoSuchMethodError  catch(_) {
   }
   asyncStart();
   lazy.loadLibrary().then(onFooLoaded);

LibTest/async/EventSink/all_tests.lib.dart

@@ -11,6 +11,7 @@
 library all_tests_eventsink;
 import "dart:async";
 
+import "../../../Utils/expect.dart";
 import "EventSink_A01_t01.test.dart" as EventSink_A01_t01;
 import "hashCode_A01_t01.test.dart" as hashCode_A01_t01;
 import "runtimeType_A01_t01.test.dart" as runtimeType_A01_t01;
@@ -22,6 +23,7 @@ import "noSuchMethodError_A01_t01.test.dart" as noSuchMethodError_A01_t01;
 import "toString_A01_t01.test.dart" as toString_A01_t01;
 
 test(EventSink create()) {
+  asyncStart();
   EventSink_A01_t01.test(create);
   hashCode_A01_t01.test(create);
   runtimeType_A01_t01.test(create);
@@ -31,4 +33,5 @@ test(EventSink create()) {
   close_A01_t01.test(create);
   noSuchMethodError_A01_t01.test(create);
   toString_A01_t01.test(create);
+  asyncEnd();
 }

LibTest/async/Future/Future.delayed_A01_t01.dart

@@ -24,6 +24,7 @@ void check(delay, value) {
 }
 
 main() {
+  asyncStart();
   check(0, 0);
   check(10, 1);
   check(0, -5);
@@ -33,4 +34,5 @@ main() {
   check(0, true);
   check(10, const []);
   check(0, const {'k1': 1, 'k2': 2});
+  asyncEnd();
 }

LibTest/async/Future/Future.delayed_A01_t02.dart

@@ -36,9 +36,11 @@ check(delayms) {
 }
 
 main() {
+  asyncStart();
   check(0);
   check(30);
   check(50);
   check(100);
   check(150);
+  asyncEnd();
 }

LibTest/async/Future/Future.delayed_A03_t01.dart

@@ -27,7 +27,9 @@ check(delay, value) {
 }
 
 main() {
+  asyncStart();
   check(100, 3);
   check(50, '');
   check(0, []);
+  asyncEnd();
 }

LibTest/async/Future/Future.error_A01_t01.dart

@@ -27,6 +27,7 @@ check(value) {
 }
 
 main() {
+  asyncStart();
   check(0);
   check(1);
   check(-5);
@@ -35,4 +36,5 @@ main() {
   check(true);
   check(const []);
   check(const {'k1': 1, 'k2': 2});
+  asyncEnd();
 }

LibTest/async/Future/Future.sync_A01_t01.dart

@@ -29,6 +29,7 @@ check(value) {
 }
 
 main() {
+  asyncStart();
   check(0);
   check(1);
   check(-5);
@@ -38,4 +39,5 @@ main() {
   check(true);
   check(const []);
   check(const {'k1': 1, 'k2': 2});
+  asyncEnd();
 }

LibTest/async/Future/Future.sync_A01_t03.dart

@@ -37,6 +37,7 @@ check(value) {
 }
 
 main() {
+  asyncStart();
   check(0);
   check(1);
   check(-5);
@@ -46,4 +47,5 @@ main() {
   check(true);
   check(const []);
   check(const {'k1': 1, 'k2': 2});
+  asyncEnd();
 }

LibTest/async/Future/Future.value_A01_t01.dart

@@ -24,6 +24,7 @@ check(value) {
 }
 
 main() {
+  asyncStart();
   check(0);
   check(1);
   check(-5);
@@ -33,4 +34,5 @@ main() {
   check(true);
   check(const []);
   check(const {'k1': 1, 'k2': 2});
+  asyncEnd();
 }

LibTest/async/Future/any_A01_t01.dart

@@ -41,7 +41,6 @@ main() {
       c.complete(null);
     }
   }
-
   Future f = Future.any(futures);
 
   asyncStart();

LibTest/async/Future/any_A01_t03.dart

@@ -41,7 +41,6 @@ main() {
       c.complete(true);
     }
   }
-
   Future f = Future.any(futures);
 
   asyncStart();

LibTest/async/Future/any_A01_t04.dart

@@ -38,7 +38,6 @@ main() {
       c.complete(true);
     }
   }
-
   Future f = Future.any(futures);
 
   asyncStart();

LibTest/async/Future/asStream_A01_t01.dart

@@ -25,6 +25,7 @@ check(var value) {
 }
 
 main() {
+  asyncStart();
   check(0);
   check(1);
   check(-5);
@@ -34,4 +35,5 @@ main() {
   check(true);
   check(const []);
   check(const {'k1': 1, 'k2': 2});
+  asyncEnd();
 }

LibTest/async/Future/catchError_A02_t01.dart

@@ -17,25 +17,23 @@ check(value) {
   Future f = completer.future;
 
   asyncStart();
-  f.catchError(
-    (Object error) {
-      Expect.fail("onError should not be called");
-    }
-  ).then(
-    (x) {
-      Expect.identical(value, x);
-      asyncEnd();
-    }
-  );
+  f.catchError((Object error) {
+    Expect.fail("onError should not be called");
+  }).then((x) {
+    Expect.identical(value, x);
+    asyncEnd();
+  });
 
   completer.complete(value);
 }
 
 main() {
+  asyncStart();
   check(0);
   check('');
   check(false);
   check([]);
   check(new Object());
   check(new Exception());
+  asyncEnd();
 }