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

test/backend/invoker_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:fake_async/fake_async.dart';
 import 'package:test/src/backend/group.dart';
 import 'package:test/src/backend/invoker.dart';
 import 'package:test/src/backend/message.dart';
@@ skipping 15 matching lines @@
     var invoker = Invoker.current;
     test("returns null outside of a test body", () {
       expect(invoker, isNull);
     });
 
     test("returns the current invoker in a test body", () async {
       var invoker;
       var liveTest = _localTest(() {
         invoker = Invoker.current;
       }).load(suite);
-      liveTest.onError.listen(expectAsync((_) {}, count: 0));
+      liveTest.onError.listen(expectAsync1((_) {}, count: 0));
 
       await liveTest.run();
       expect(invoker.liveTest, equals(liveTest));
     });
 
     test("returns the current invoker in a test body after the test completes",
         () async {
       var status;
       var completer = new Completer();
       var liveTest = _localTest(() {
         // Use [new Future] in particular to wait longer than a microtask for
         // the test to complete.
         new Future(() {
           status = Invoker.current.liveTest.state.status;
           completer.complete(Invoker.current);
         });
       }).load(suite);
-      liveTest.onError.listen(expectAsync((_) {}, count: 0));
+      liveTest.onError.listen(expectAsync1((_) {}, count: 0));
 
       expect(liveTest.run(), completes);
       var invoker = await completer.future;
       expect(invoker.liveTest, equals(liveTest));
       expect(status, equals(Status.complete));
     });
   });
 
   group("in a successful test,", () {
     test("the state changes from pending to running to complete", () async {
       var stateInTest;
       var liveTest;
       liveTest = _localTest(() {
         stateInTest = liveTest.state;
       }).load(suite);
-      liveTest.onError.listen(expectAsync((_) {}, count: 0));
+      liveTest.onError.listen(expectAsync1((_) {}, count: 0));
 
       expect(liveTest.state.status, equals(Status.pending));
       expect(liveTest.state.result, equals(Result.success));
 
       var future = liveTest.run();
 
       expect(liveTest.state.status, equals(Status.running));
       expect(liveTest.state.result, equals(Result.success));
 
       await future;
 
       expect(stateInTest.status, equals(Status.running));
       expect(stateInTest.result, equals(Result.success));
 
       expect(liveTest.state.status, equals(Status.complete));
       expect(liveTest.state.result, equals(Result.success));
     });
 
     test("onStateChange fires for each state change", () {
       var liveTest = _localTest(() {}).load(suite);
-      liveTest.onError.listen(expectAsync((_) {}, count: 0));
+      liveTest.onError.listen(expectAsync1((_) {}, count: 0));
 
       var first = true;
-      liveTest.onStateChange.listen(expectAsync((state) {
+      liveTest.onStateChange.listen(expectAsync1((state) {
         if (first) {
           expect(state.status, equals(Status.running));
           first = false;
         } else {
           expect(state.status, equals(Status.complete));
         }
         expect(state.result, equals(Result.success));
       }, count: 2, max: 2));
 
       return liveTest.run();
@@ skipping 256 matching lines @@
       Invoker.current.addOutstandingCallback();
 
       // Pump the event queue to make sure the test isn't coincidentally
       // completing after the outstanding callback is removed.
       pumpEventQueue().then((_) {
         outstandingCallbackRemoved = true;
         Invoker.current.removeOutstandingCallback();
       });
     }).load(suite);
 
-    liveTest.onError.listen(expectAsync((_) {}, count: 0));
+    liveTest.onError.listen(expectAsync1((_) {}, count: 0));
 
     await liveTest.run();
     expect(outstandingCallbackRemoved, isTrue);
   });
 
   test("a test's prints are captured and reported", () {
     expect(() {
       var liveTest = _localTest(() {
         print("Hello,");
         return new Future(() => print("world!"));
@@ skipping 99 matching lines @@
         functionCompleted = true;
       });
 
       expect(functionCompleted, isTrue);
     });
 
     test("waits for registered callbacks in the wrapped function to run",
         () async {
       var callbackRun = false;
       await Invoker.current.waitForOutstandingCallbacks(() {
-        pumpEventQueue().then(expectAsync((_) {
+        pumpEventQueue().then(expectAsync1((_) {
           callbackRun = true;
         }));
       });
 
       expect(callbackRun, isTrue);
     });
 
     test("doesn't automatically block the enclosing context", () async {
       var innerFunctionCompleted = false;
       await Invoker.current.waitForOutstandingCallbacks(() {
@@ skipping 26 matching lines @@
       expect(liveTest.state.status, equals(Status.complete));
       expect(isComplete, isFalse);
     });
   });
 }
 
 LocalTest _localTest(body(), {Metadata metadata}) {
   if (metadata == null) metadata = new Metadata();
   return new LocalTest("test", metadata, body);
 }