Upgrading tests with unittest deprecations

tests/lib/async/stream_controller_async_test.dart

 // Copyright (c) 2011, 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.
 
 // Test the basic StreamController and StreamController.singleSubscription.
 library stream_controller_async_test;
 
 import 'dart:async';
 import 'dart:isolate';
 import "package:expect/expect.dart";
 import '../../../pkg/unittest/lib/unittest.dart';
 import 'event_helper.dart';
 import 'stream_state_helper.dart';
 
 void cancelSub(StreamSubscription sub) { sub.cancel(); }
 
 testController() {
   // Test fold
   test("StreamController.fold", () {
     StreamController c = new StreamController();
     Stream stream = c.stream.asBroadcastStream(onCancel: cancelSub);
     stream.fold(0, (a,b) => a + b)
-     .then(expectAsync1((int v) {
+     .then(expectAsync((int v) {
         Expect.equals(42, v);
     }));
     c.add(10);
     c.add(32);
     c.close();
   });
 
   test("StreamController.fold throws", () {
     StreamController c = new StreamController();
     Stream stream = c.stream.asBroadcastStream(onCancel: cancelSub);
     stream.fold(0, (a,b) { throw "Fnyf!"; })
-     .catchError(expectAsync1((error) { Expect.equals("Fnyf!", error); }));
+     .catchError(expectAsync((error) { Expect.equals("Fnyf!", error); }));
     c.add(42);
   });
 }
 
 testSingleController() {
   test("Single-subscription StreamController.fold", () {
     StreamController c = new StreamController();
     Stream stream = c.stream;
     stream.fold(0, (a,b) => a + b)
-    .then(expectAsync1((int v) { Expect.equals(42, v); }));
+    .then(expectAsync((int v) { Expect.equals(42, v); }));
     c.add(10);
     c.add(32);
     c.close();
   });
 
   test("Single-subscription StreamController.fold throws", () {
     StreamController c = new StreamController();
     Stream stream = c.stream;
     stream.fold(0, (a,b) { throw "Fnyf!"; })
-            .catchError(expectAsync1((e) { Expect.equals("Fnyf!", e); }));
+            .catchError(expectAsync((e) { Expect.equals("Fnyf!", e); }));
     c.add(42);
   });
 
   test("Single-subscription StreamController events are buffered when"
        " there is no subscriber",
        () {
     StreamController c = new StreamController();
     EventSink sink = c.sink;
     Stream stream = c.stream;
     int counter = 0;
     sink.add(1);
     sink.add(2);
     sink.close();
     stream.listen(
       (data) {
         counter += data;
       },
-      onDone: expectAsync0(() {
+      onDone: expectAsync(() {
         Expect.equals(3, counter);
       }));
   });
 }
 
 testExtraMethods() {
   Events sentEvents = new Events()..add(7)..add(9)..add(13)..add(87)..close();
 
   test("forEach", () {
     StreamController c = new StreamController();
     Events actualEvents = new Events();
     Future f = c.stream.forEach(actualEvents.add);
-    f.then(expectAsync1((_) {
+    f.then(expectAsync((_) {
       actualEvents.close();
       Expect.listEquals(sentEvents.events, actualEvents.events);
     }));
     sentEvents.replay(c);
   });
 
   test("forEachError", () {
     Events sentEvents = new Events()..add(7)..error("bad")..add(87)..close();
     StreamController c = new StreamController();
     Events actualEvents = new Events();
     Future f = c.stream.forEach(actualEvents.add);
-    f.catchError(expectAsync1((error) {
+    f.catchError(expectAsync((error) {
       Expect.equals("bad", error);
       Expect.listEquals((new Events()..add(7)).events, actualEvents.events);
     }));
     sentEvents.replay(c);
   });
 
   test("forEachError2", () {
     Events sentEvents = new Events()..add(7)..add(9)..add(87)..close();
     StreamController c = new StreamController();
     Events actualEvents = new Events();
     Future f = c.stream.forEach((x) {
       if (x == 9) throw "bad";
       actualEvents.add(x);
     });
-    f.catchError(expectAsync1((error) {
+    f.catchError(expectAsync((error) {
       Expect.equals("bad", error);
       Expect.listEquals((new Events()..add(7)).events, actualEvents.events);
     }));
     sentEvents.replay(c);
   });
 
   test("firstWhere", () {
     StreamController c = new StreamController();
     Future f = c.stream.firstWhere((x) => (x % 3) == 0);
-    f.then(expectAsync1((v) { Expect.equals(9, v); }));
+    f.then(expectAsync((v) { Expect.equals(9, v); }));
     sentEvents.replay(c);
   });
 
   test("firstWhere 2", () {
     StreamController c = new StreamController();
     Future f = c.stream.firstWhere((x) => (x % 4) == 0);
-    f.catchError(expectAsync1((e) {}));
+    f.catchError(expectAsync((e) {}));
     sentEvents.replay(c);
   });
 
   test("firstWhere 3", () {
     StreamController c = new StreamController();
     Future f = c.stream.firstWhere((x) => (x % 4) == 0, defaultValue: () => 999);
-    f.then(expectAsync1((v) { Expect.equals(999, v); }));
+    f.then(expectAsync((v) { Expect.equals(999, v); }));
     sentEvents.replay(c);
   });
 
 
   test("lastWhere", () {
     StreamController c = new StreamController();
     Future f = c.stream.lastWhere((x) => (x % 3) == 0);
-    f.then(expectAsync1((v) { Expect.equals(87, v); }));
+    f.then(expectAsync((v) { Expect.equals(87, v); }));
     sentEvents.replay(c);
   });
 
   test("lastWhere 2", () {
     StreamController c = new StreamController();
     Future f = c.stream.lastWhere((x) => (x % 4) == 0);
-    f.catchError(expectAsync1((e) {}));
+    f.catchError(expectAsync((e) {}));
     sentEvents.replay(c);
   });
 
   test("lastWhere 3", () {
     StreamController c = new StreamController();
     Future f = c.stream.lastWhere((x) => (x % 4) == 0, defaultValue: () => 999);
-    f.then(expectAsync1((v) { Expect.equals(999, v); }));
+    f.then(expectAsync((v) { Expect.equals(999, v); }));
     sentEvents.replay(c);
   });
 
   test("singleWhere", () {
     StreamController c = new StreamController();
     Future f = c.stream.singleWhere((x) => (x % 9) == 0);
-    f.then(expectAsync1((v) { Expect.equals(9, v); }));
+    f.then(expectAsync((v) { Expect.equals(9, v); }));
     sentEvents.replay(c);
   });
 
   test("singleWhere 2", () {
     StreamController c = new StreamController();
     Future f = c.stream.singleWhere((x) => (x % 3) == 0);  // Matches 9 and 87..
-    f.catchError(expectAsync1((error) { Expect.isTrue(error is StateError); }));
+    f.catchError(expectAsync((error) { Expect.isTrue(error is StateError); }));
     sentEvents.replay(c);
   });
 
   test("first", () {
     StreamController c = new StreamController();
     Future f = c.stream.first;
-    f.then(expectAsync1((v) { Expect.equals(7, v);}));
+    f.then(expectAsync((v) { Expect.equals(7, v);}));
     sentEvents.replay(c);
   });
 
   test("first empty", () {
     StreamController c = new StreamController();
     Future f = c.stream.first;
-    f.catchError(expectAsync1((error) { Expect.isTrue(error is StateError); }));
+    f.catchError(expectAsync((error) { Expect.isTrue(error is StateError); }));
     Events emptyEvents = new Events()..close();
     emptyEvents.replay(c);
   });
 
   test("first error", () {
     StreamController c = new StreamController();
     Future f = c.stream.first;
-    f.catchError(expectAsync1((error) { Expect.equals("error", error); }));
+    f.catchError(expectAsync((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..error("error")..close();
     errorEvents.replay(c);
   });
 
   test("first error 2", () {
     StreamController c = new StreamController();
     Future f = c.stream.first;
-    f.catchError(expectAsync1((error) { Expect.equals("error", error); }));
+    f.catchError(expectAsync((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..error("error")..error("error2")..close();
     errorEvents.replay(c);
   });
 
   test("last", () {
     StreamController c = new StreamController();
     Future f = c.stream.last;
-    f.then(expectAsync1((v) { Expect.equals(87, v);}));
+    f.then(expectAsync((v) { Expect.equals(87, v);}));
     sentEvents.replay(c);
   });
 
   test("last empty", () {
     StreamController c = new StreamController();
     Future f = c.stream.last;
-    f.catchError(expectAsync1((error) { Expect.isTrue(error is StateError); }));
+    f.catchError(expectAsync((error) { Expect.isTrue(error is StateError); }));
     Events emptyEvents = new Events()..close();
     emptyEvents.replay(c);
   });
 
   test("last error", () {
     StreamController c = new StreamController();
     Future f = c.stream.last;
-    f.catchError(expectAsync1((error) { Expect.equals("error", error); }));
+    f.catchError(expectAsync((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..error("error")..close();
     errorEvents.replay(c);
   });
 
   test("last error 2", () {
     StreamController c = new StreamController();
     Future f = c.stream.last;
-    f.catchError(expectAsync1((error) { Expect.equals("error", error); }));
+    f.catchError(expectAsync((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..error("error")..error("error2")..close();
     errorEvents.replay(c);
   });
 
   test("elementAt", () {
     StreamController c = new StreamController();
     Future f = c.stream.elementAt(2);
-    f.then(expectAsync1((v) { Expect.equals(13, v);}));
+    f.then(expectAsync((v) { Expect.equals(13, v);}));
     sentEvents.replay(c);
   });
 
   test("elementAt 2", () {
     StreamController c = new StreamController();
     Future f = c.stream.elementAt(20);
-    f.catchError(expectAsync1((error) { Expect.isTrue(error is RangeError); }));
+    f.catchError(expectAsync((error) { Expect.isTrue(error is RangeError); }));
     sentEvents.replay(c);
   });
 
   test("drain", () {
     StreamController c = new StreamController();
     Future f = c.stream.drain();
-    f.then(expectAsync1((v) { Expect.equals(null, v);}));
+    f.then(expectAsync((v) { Expect.equals(null, v);}));
     sentEvents.replay(c);
   });
 
   test("drain error", () {
     StreamController c = new StreamController();
     Future f = c.stream.drain();
-    f.catchError(expectAsync1((error) { Expect.equals("error", error); }));
+    f.catchError(expectAsync((error) { Expect.equals("error", error); }));
     Events errorEvents = new Events()..error("error")..error("error2")..close();
     errorEvents.replay(c);
   });
 
 }
 
 testPause() {
   test("pause event-unpause", () {
 
     StreamProtocolTest test = new StreamProtocolTest();
@@ skipping 86 matching lines @@
 
 class TestError { const TestError(); }
 
 testRethrow() {
   TestError error = const TestError();
 
   testStream(name, streamValueTransform) {
     test("rethrow-$name-value", () {
       StreamController c = new StreamController();
       Stream s = streamValueTransform(c.stream, (v) { throw error; });
-      s.listen((_) { Expect.fail("unexpected value"); }, onError: expectAsync1(
+      s.listen((_) { Expect.fail("unexpected value"); }, onError: expectAsync(
           (e) { Expect.identical(error, e); }));
       c.add(null);
       c.close();
     });
   }
 
   testStreamError(name, streamErrorTransform) {
     test("rethrow-$name-error", () {
       StreamController c = new StreamController();
       Stream s = streamErrorTransform(c.stream, (e) { throw error; });
-      s.listen((_) { Expect.fail("unexpected value"); }, onError: expectAsync1(
+      s.listen((_) { Expect.fail("unexpected value"); }, onError: expectAsync(
           (e) { Expect.identical(error, e); }));
       c.addError(null);
       c.close();
     });
   }
 
   testFuture(name, streamValueTransform) {
     test("rethrow-$name-value", () {
       StreamController c = new StreamController();
       Future f = streamValueTransform(c.stream, (v) { throw error; });
       f.then((v) { Expect.fail("unreachable"); },
-             onError: expectAsync1((e) { Expect.identical(error, e); }));
+             onError: expectAsync((e) { Expect.identical(error, e); }));
       // Need two values to trigger compare for reduce.
       c.add(0);
       c.add(1);
       c.close();
     });
   }
 
   testStream("where", (s, act) => s.where(act));
   testStream("map", (s, act) => s.map(act));
   testStream("expand", (s, act) => s.expand(act));
@@ skipping 159 matching lines @@
         ..expectCancel()
         ..expectDone()
         ..expectBroadcastCancel((_) => test.terminate());
     sub = test.listen();
   });
 }
 
 void testSink({bool sync, bool broadcast, bool asBroadcast}) {
   String type = "${sync?"S":"A"}${broadcast?"B":"S"}${asBroadcast?"aB":""}";
   test("$type-controller-sink", () {
-    var done = expectAsync0((){});
+    var done = expectAsync((){});
     var c = broadcast ? new StreamController.broadcast(sync: sync)
                       : new StreamController(sync: sync);
     var expected = new Events()
         ..add(42)..error("error")
         ..add(1)..add(2)..add(3)..add(4)..add(5)
         ..add(43)..close();
     var actual = new Events.capture(asBroadcast ? c.stream.asBroadcastStream()
                                                 : c.stream);
     var sink = c.sink;
     sink.add(42);
     sink.addError("error");
     sink.addStream(new Stream.fromIterable([1, 2, 3, 4, 5]))
         .then((_) {
           sink.add(43);
           return sink.close();
         })
         .then((_) {
           Expect.listEquals(expected.events, actual.events);
           done();
         });
   });
 
   test("$type-controller-sink-canceled", () {
-    var done = expectAsync0((){});
+    var done = expectAsync((){});
     var c = broadcast ? new StreamController.broadcast(sync: sync)
                       : new StreamController(sync: sync);
     var expected = new Events()
         ..add(42)..error("error")
         ..add(1)..add(2)..add(3);
     var stream = asBroadcast ? c.stream.asBroadcastStream() : c.stream;
     var actual = new Events();
     var sub;
     // Cancel subscription after receiving "3" event.
     sub = stream.listen((v) {
@@ skipping 14 matching lines @@
           return doneFuture;
         })
         .then((_) {
           // No change in events.
           Expect.listEquals(expected.events, actual.events);
           done();
         });
   });
 
   test("$type-controller-sink-paused", () {
-    var done = expectAsync0((){});
+    var done = expectAsync((){});
     var c = broadcast ? new StreamController.broadcast(sync: sync)
                       : new StreamController(sync: sync);
     var expected = new Events()
         ..add(42)..error("error")
         ..add(1)..add(2)..add(3)
         ..add(4)..add(5)..add(43)..close();
     var stream = asBroadcast ? c.stream.asBroadcastStream() : c.stream;
     var actual = new Events();
     var sub;
     var pauseIsDone = false;
@@ skipping 28 matching lines @@
             });
           } else {
             Expect.listEquals(expected.events, actual.events);
             done();
           }
         });
   });
 
   test("$type-controller-addstream-error-stop", () {
     // Check that addStream defaults to ending after the first error.
-    var done = expectAsync0((){});
+    var done = expectAsync((){});
     StreamController c = broadcast
         ? new StreamController.broadcast(sync: sync)
         : new StreamController(sync: sync);
     Stream stream = asBroadcast ? c.stream.asBroadcastStream() : c.stream;
     var actual = new Events.capture(stream);
 
     var source = new Events();
     source..add(1)..add(2)..error("BAD")..add(3)..error("FAIL")..close();
 
     var expected = new Events()..add(1)..add(2)..error("BAD")..close();
     StreamController sourceController = new StreamController();
     c.addStream(sourceController.stream).then((_) {
       c.close().then((_) {
         Expect.listEquals(expected.events, actual.events);
         done();
       });
     });
 
     source.replay(sourceController);
   });
 
   test("$type-controller-addstream-error-forward", () {
     // Check that addStream with cancelOnError:false passes all data and errors
     // to the controller.
-    var done = expectAsync0((){});
+    var done = expectAsync((){});
     StreamController c = broadcast
         ? new StreamController.broadcast(sync: sync)
         : new StreamController(sync: sync);
     Stream stream = asBroadcast ? c.stream.asBroadcastStream() : c.stream;
     var actual = new Events.capture(stream);
 
     var source = new Events();
     source..add(1)..add(2)..addError("BAD")..add(3)..addError("FAIL")..close();
 
     StreamController sourceController = new StreamController();
     c.addStream(sourceController.stream, cancelOnError: false).then((_) {
       c.close().then((_) {
         Expect.listEquals(source.events, actual.events);
         done();
       });
     });
 
     source.replay(sourceController);
   });
 
   test("$type-controller-addstream-twice", () {
     // Using addStream twice on the same stream
-    var done = expectAsync0((){});
+    var done = expectAsync((){});
     StreamController c = broadcast
         ? new StreamController.broadcast(sync: sync)
         : new StreamController(sync: sync);
     Stream stream = asBroadcast ? c.stream.asBroadcastStream() : c.stream;
     var actual = new Events.capture(stream);
 
     // Streams of five events, throws on 3.
     Stream s1 = new Stream.fromIterable([1,2,3,4,5])
                     .map((x) => (x == 3 ? throw x : x));
     Stream s2 = new Stream.fromIterable([1,2,3,4,5])
@@ skipping 23 matching lines @@
   testRethrow();
   testBroadcastController();
   testAsBroadcast();
   testSink(sync: true, broadcast: false, asBroadcast: false);
   testSink(sync: true, broadcast: false, asBroadcast: true);
   testSink(sync: true, broadcast: true, asBroadcast: false);
   testSink(sync: false, broadcast: false, asBroadcast: false);
   testSink(sync: false, broadcast: false, asBroadcast: true);
   testSink(sync: false, broadcast: true, asBroadcast: false);
 }