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

test/util/stream_queue_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 filevents.
 
 // TODO(nweiz): Get rid of this when https://codereview.chromium.org/1241723003/
 // lands.
 
 import "dart:async";
 
 import "package:test/src/util/stream_queue.dart";
@@ skipping 725 matching lines @@
       var queue4 = queue1.fork();
       var queue5 = queue1.fork();
 
       for (var i = 0; i < 4; 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("forks can be created from forks", () async {
@@ skipping 199 matching lines @@
 
         controller.add(3);
         await flushMicrotasks();
         expect(controller.isPaused, isTrue);
       });
 
       test("pausing a fork doesn't pause its source", () async {
         var queue1 = new StreamQueue<int>(createStream());
         var queue2 = queue1.fork();
 
-        queue2.rest.listen(expectAsync((_) {}, count: 0)).pause();
+        queue2.rest.listen(expectAsync1((_) {}, count: 0)).pause();
 
         expect(await queue1.next, 1);
         expect(await queue1.next, 2);
         expect(await queue1.next, 3);
         expect(await queue1.next, 4);
         expect(await queue1.hasNext, isFalse);
       });
 
       test("pausing a source doesn't pause its fork", () async {
         var queue1 = new StreamQueue<int>(createStream());
         var queue2 = queue1.fork();
 
-        queue1.rest.listen(expectAsync((_) {}, count: 0)).pause();
+        queue1.rest.listen(expectAsync1((_) {}, count: 0)).pause();
 
         expect(await queue2.next, 1);
         expect(await queue2.next, 2);
         expect(await queue2.next, 3);
         expect(await queue2.next, 4);
         expect(await queue2.hasNext, isFalse);
       });
 
       test("the underlying stream is only paused when all forks are paused",
           () async {
@@ skipping 103 matching lines @@
     controller.close();
   }();
   return controller.stream;
 }
 
 Stream<int> createLongStream(int eventCount) async* {
   for (int i = 0; i < eventCount; i++) yield i;
 }
 
 Future flushMicrotasks() => new Future.delayed(Duration.ZERO);