Add expectAsyncX and expectAsyncUntilX methods, and deprecate the old methods.

test/util/forkable_stream_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.
 
 // TODO(nweiz): Get rid of this when https://codereview.chromium.org/1241723003/
 // lands.
 
 import 'dart:async';
 
 import 'package:test/test.dart';
@@ skipping 195 matching lines @@
 
       for (var i = 0; i < 4; i++) {
         controller.add(i);
 
         var queue1Fired = false;
         var queue2Fired = false;
         var queue3Fired = false;
         var queue4Fired = false;
         var queue5Fired = false;
 
-        queue5.next.then(expectAsync((_) {
+        queue5.next.then(expectAsync1((_) {
           queue5Fired = true;
           expect(queue1Fired, isTrue);
           expect(queue2Fired, isTrue);
           expect(queue3Fired, isTrue);
           expect(queue4Fired, isTrue);
         }));
 
-        queue1.next.then(expectAsync((_) {
+        queue1.next.then(expectAsync1((_) {
           queue1Fired = true;
           expect(queue2Fired, isFalse);
           expect(queue3Fired, isFalse);
           expect(queue4Fired, isFalse);
           expect(queue5Fired, isFalse);
         }));
 
-        queue4.next.then(expectAsync((_) {
+        queue4.next.then(expectAsync1((_) {
           queue4Fired = true;
           expect(queue1Fired, isTrue);
           expect(queue2Fired, isTrue);
           expect(queue3Fired, isTrue);
           expect(queue5Fired, isFalse);
         }));
 
-        queue2.next.then(expectAsync((_) {
+        queue2.next.then(expectAsync1((_) {
           queue2Fired = true;
           expect(queue1Fired, isTrue);
           expect(queue3Fired, isFalse);
           expect(queue4Fired, isFalse);
           expect(queue5Fired, isFalse);
         }));
 
-        queue3.next.then(expectAsync((_) {
+        queue3.next.then(expectAsync1((_) {
           queue3Fired = true;
           expect(queue1Fired, isTrue);
           expect(queue2Fired, isTrue);
           expect(queue4Fired, isFalse);
           expect(queue5Fired, isFalse);
         }));
       }
     });
 
     test("pauses the source when all forks are paused and/or not listening",
@@ skipping 45 matching lines @@
       expect(controller.hasListener, isTrue);
 
       expect(fork4.listen(null).cancel(), completion(equals(42)));
       await flushMicrotasks();
       expect(controller.hasListener, isFalse);
     });
   });
 
   group("modification during dispatch:", () {
     test("forking during onCancel", () {
-      controller = new StreamController<int>(onCancel: expectAsync(() {
+      controller = new StreamController<int>(onCancel: expectAsync0(() {
         expect(stream.fork().toList(), completion(isEmpty));
       }));
       stream = new ForkableStream<int>(controller.stream);
 
       stream.listen(null).cancel();
     });
 
     test("forking during onPause", () {
-      controller = new StreamController<int>(onPause: expectAsync(() {
+      controller = new StreamController<int>(onPause: expectAsync0(() {
         stream.fork().listen(null);
       }));
       stream = new ForkableStream<int>(controller.stream);
 
       stream.listen(null).pause();
 
       // The fork created in onPause should have resumed the stream.
       expect(controller.isPaused, isFalse);
     });
 
     test("forking during onData", () {
       var sub;
-      sub = stream.listen(expectAsync((value1) {
+      sub = stream.listen(expectAsync1((value1) {
         expect(value1, equals(1));
-        stream.fork().listen(expectAsync((value2) {
+        stream.fork().listen(expectAsync1((value2) {
           expect(value2, equals(2));
         }));
         sub.cancel();
       }));
 
       controller.add(1);
       controller.add(2);
     });
 
     test("canceling a fork during onData", () {
       var fork = stream.fork();
-      var forkSub = fork.listen(expectAsync((_) {}, count: 0));
+      var forkSub = fork.listen(expectAsync1((_) {}, count: 0));
 
-      stream.listen(expectAsync((_) => forkSub.cancel()));
+      stream.listen(expectAsync1((_) => forkSub.cancel()));
       controller.add(null);
     });
 
     test("forking during onError", () {
       var sub;
-      sub = stream.listen(null, onError: expectAsync((error1) {
+      sub = stream.listen(null, onError: expectAsync1((error1) {
         expect(error1, equals("error 1"));
-        stream.fork().listen(null, onError: expectAsync((error2) {
+        stream.fork().listen(null, onError: expectAsync1((error2) {
           expect(error2, equals("error 2"));
         }));
         sub.cancel();
       }));
 
       controller.addError("error 1");
       controller.addError("error 2");
     });
 
     test("canceling a fork during onError", () {
       var fork = stream.fork();
-      var forkSub = fork.listen(expectAsync((_) {}, count: 0));
+      var forkSub = fork.listen(expectAsync1((_) {}, count: 0));
 
-      stream.listen(null, onError: expectAsync((_) => forkSub.cancel()));
+      stream.listen(null, onError: expectAsync1((_) => forkSub.cancel()));
       controller.addError("error");
     });
 
     test("forking during onDone", () {
-      stream.listen(null, onDone: expectAsync(() {
+      stream.listen(null, onDone: expectAsync0(() {
         expect(stream.fork().toList(), completion(isEmpty));
       }));
 
       controller.close();
     });
 
     test("canceling a fork during onDone", () {
       var fork = stream.fork();
-      var forkSub = fork.listen(null, onDone: expectAsync(() {}, count: 0));
+      var forkSub = fork.listen(null, onDone: expectAsync0(() {}, count: 0));
 
-      stream.listen(null, onDone: expectAsync(() => forkSub.cancel()));
+      stream.listen(null, onDone: expectAsync0(() => forkSub.cancel()));
       controller.close();
     });
   });
 
   group("throws an error when", () {
     test("a cancelled stream is forked", () {
       stream.listen(null).cancel();
       expect(stream.fork().toList(), completion(isEmpty));
     });
 
     test("a cancelled stream is forked even when other forks are alive", () {
       stream.fork().listen(null);
       stream.listen(null).cancel();
 
       expect(controller.hasListener, isTrue);
       expect(stream.fork().toList(), completion(isEmpty));
     });
 
     test("a closed stream is forked", () async {
       controller.close();
       await stream.listen(null).asFuture();
       expect(stream.fork().toList(), completion(isEmpty));
     });
   });
 }
 
 Future flushMicrotasks() => new Future.delayed(Duration.ZERO);