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

test/runner/engine_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:test/src/backend/group.dart';
 import 'package:test/src/backend/state.dart';
 import 'package:test/src/runner/engine.dart';
 import 'package:test/test.dart';
 
 import '../utils.dart';
 
 void main() {
   test("runs each test in each suite in order", () async {
     var testsRun = 0;
     var tests = declare(() {
       for (var i = 0; i < 4; i++) {
-        test("test ${i + 1}", expectAsync(() {
+        test("test ${i + 1}", expectAsync0(() {
           expect(testsRun, equals(i));
           testsRun++;
         }, max: 1));
       }
     });
 
     var engine = new Engine.withSuites([
       runnerSuite(new Group.root(tests.take(2))),
       runnerSuite(new Group.root(tests.skip(2)))
     ]);
 
     await engine.run();
     expect(testsRun, equals(4));
   });
 
   test("runs tests in a suite added after run() was called", () {
     var testsRun = 0;
     var tests = declare(() {
       for (var i = 0; i < 4; i++) {
-        test("test ${i + 1}", expectAsync(() {
+        test("test ${i + 1}", expectAsync0(() {
           expect(testsRun, equals(i));
           testsRun++;
         }, max: 1));
       }
     });
 
     var engine = new Engine();
     expect(engine.run().then((_) {
       expect(testsRun, equals(4));
     }), completes);
 
     engine.suiteSink.add(runnerSuite(new Group.root(tests)));
     engine.suiteSink.close();
   });
 
   test("emits each test before it starts running and after the previous test "
       "finished", () {
     var testsRun = 0;
     var engine = declareEngine(() {
       for (var i = 0; i < 3; i++) {
-        test("test ${i + 1}", expectAsync(() => testsRun++, max: 1));
+        test("test ${i + 1}", expectAsync0(() => testsRun++, max: 1));
       }
     });
 
-    engine.onTestStarted.listen(expectAsync((liveTest) {
+    engine.onTestStarted.listen(expectAsync1((liveTest) {
       // [testsRun] should be one less than the test currently running.
       expect(liveTest.test.name, equals("test ${testsRun + 1}"));
 
       // [Engine.onTestStarted] is guaranteed to fire before the first
       // [LiveTest.onStateChange].
       expect(liveTest.onStateChange.first,
           completion(equals(const State(Status.running, Result.success))));
     }, count: 3, max: 3));
 
     return engine.run();
@@ skipping 35 matching lines @@
     var engine = new Engine.withSuites([]);
     expect(engine.run(), completes);
     expect(engine.run, throwsStateError);
   });
 
   test("runs tearDown after a test times out", () {
     // Declare this here so the expect is in the context of this test, rather
     // than the inner test.
     var secondTestStarted = false;
     var firstTestFinished = false;
-    var tearDownBody = expectAsync(() {
+    var tearDownBody = expectAsync0(() {
       expect(secondTestStarted, isFalse);
       expect(firstTestFinished, isFalse);
     });
 
     var engine = declareEngine(() {
       // This ensures that the first test doesn't actually finish until the
       // second test runs.
       var firstTestCompleter = new Completer();
 
       group("group", () {
@@ skipping 35 matching lines @@
       expect(bodyRun, isTrue);
     });
 
     test("exposes a LiveTest that emits the correct states", () {
       var tests = declare(() {
         test("test", () {}, skip: true);
       });
 
       var engine = new Engine.withSuites([runnerSuite(new Group.root(tests))]);
 
-      engine.onTestStarted.listen(expectAsync((liveTest) {
+      engine.onTestStarted.listen(expectAsync1((liveTest) {
         expect(liveTest, same(engine.liveTests.single));
         expect(liveTest.test.name, equals(tests.single.name));
 
         var i = 0;
-        liveTest.onStateChange.listen(expectAsync((state) {
+        liveTest.onStateChange.listen(expectAsync1((state) {
           if (i == 0) {
             expect(state, equals(const State(Status.running, Result.success)));
           } else if (i == 1) {
             expect(state, equals(const State(Status.running, Result.skipped)));
           } else if (i == 2) {
             expect(state, equals(const State(Status.complete, Result.skipped)));
           }
           i++;
         }, count: 3));
 
@@ skipping 32 matching lines @@
     test("exposes a LiveTest that emits the correct states", () {
       var entries = declare(() {
         group("group", () {
           test("test", () => bodyRun = true);
         }, skip: true);
       });
 
       var engine = new Engine.withSuites(
           [runnerSuite(new Group.root(entries))]);
 
-      engine.onTestStarted.listen(expectAsync((liveTest) {
+      engine.onTestStarted.listen(expectAsync1((liveTest) {
         expect(liveTest, same(engine.liveTests.single));
         expect(liveTest.test.name, equals("group test"));
 
         var i = 0;
-        liveTest.onStateChange.listen(expectAsync((state) {
+        liveTest.onStateChange.listen(expectAsync1((state) {
           if (i == 0) {
             expect(state, equals(const State(Status.running, Result.success)));
           } else if (i == 1) {
             expect(state, equals(const State(Status.running, Result.skipped)));
           } else if (i == 2) {
             expect(state, equals(const State(Status.complete, Result.skipped)));
           }
           i++;
         }, count: 3));
 
         expect(liveTest.onComplete, completes);
       }));
 
       return engine.run();
     });
   });
 }