Update charted to 0.4.8 and roll

packages/async/test/result_test.dart

Index: packages/async/test/result_test.dart
diff --git a/packages/async/test/result_test.dart b/packages/async/test/result_test.dart
index 848c4552db3ceb03dc5cfc38ca592f92720ab9aa..210ae3fc9efd898452a4d45f441806e05234d1db 100644
--- a/packages/async/test/result_test.dart
+++ b/packages/async/test/result_test.dart
@@ -5,7 +5,7 @@
 import "dart:async";
 import "dart:collection";
 
-import "package:async/result.dart";
+import "package:async/async.dart";
 import "package:stack_trace/stack_trace.dart";
 import "package:test/test.dart";
 
@@ -57,60 +57,66 @@ void main() {
 
   test("complete with value", () {
     Result<int> result = new ValueResult<int>(42);
-    Completer c = new Completer<int>();
-    c.future.then(expectAsync((int v) { expect(v, equals(42)); }),
-                  onError: (e, s) { fail("Unexpected error"); });
+    var c = new Completer<int>();
+    c.future.then(expectAsync1((int v) {
+      expect(v, equals(42));
+    }), onError: (e, s) {
+      fail("Unexpected error");
+    });
     result.complete(c);
   });
 
   test("complete with error", () {
     Result<bool> result = new ErrorResult("BAD", stack);
-    Completer c = new Completer<bool>();
-    c.future.then((bool v) { fail("Unexpected value $v"); },
-                  onError: expectAsync((e, s) {
-                    expect(e, equals("BAD"));
-                    expect(s, same(stack));
-                  }));
+    var c = new Completer<bool>();
+    c.future.then((bool v) {
+      fail("Unexpected value $v");
+    }, onError: expectAsync2((e, s) {
+      expect(e, equals("BAD"));
+      expect(s, same(stack));
+    }));
     result.complete(c);
   });
 
   test("add sink value", () {
-    Result<int> result = new ValueResult<int>(42);
-    EventSink<int> sink = new TestSink(
-        onData: expectAsync((v) { expect(v, equals(42)); })
-    );
+    var result = new ValueResult<int>(42);
+    EventSink<int> sink = new TestSink(onData: expectAsync1((v) {
+      expect(v, equals(42));
+    }));
     result.addTo(sink);
   });
 
   test("add sink error", () {
     Result<bool> result = new ErrorResult("BAD", stack);
-    EventSink<bool> sink = new TestSink(
-        onError: expectAsync((e, s) {
-          expect(e, equals("BAD"));
-          expect(s, same(stack));
-        })
-    );
+    EventSink<bool> sink = new TestSink(onError: expectAsync2((e, s) {
+      expect(e, equals("BAD"));
+      expect(s, same(stack));
+    }));
     result.addTo(sink);
   });
 
   test("value as future", () {
     Result<int> result = new ValueResult<int>(42);
-    result.asFuture.then(expectAsync((int v) { expect(v, equals(42)); }),
-                         onError: (e, s) { fail("Unexpected error"); });
+    result.asFuture.then(expectAsync1((int v) {
+      expect(v, equals(42));
+    }), onError: (e, s) {
+      fail("Unexpected error");
+    });
   });
 
   test("error as future", () {
     Result<bool> result = new ErrorResult("BAD", stack);
-    result.asFuture.then((bool v) { fail("Unexpected value $v"); },
-                         onError: expectAsync((e, s) {
-                           expect(e, equals("BAD"));
-                           expect(s, same(stack));
-                         }));
+    result.asFuture.then((bool v) {
+      fail("Unexpected value $v");
+    }, onError: expectAsync2((e, s) {
+      expect(e, equals("BAD"));
+      expect(s, same(stack));
+    }));
   });
 
   test("capture future value", () {
     Future<int> value = new Future<int>.value(42);
-    Result.capture(value).then(expectAsync((Result result) {
+    Result.capture(value).then(expectAsync1((Result result) {
       expect(result.isValue, isTrue);
       expect(result.isError, isFalse);
       ValueResult value = result.asValue;
@@ -122,7 +128,7 @@ void main() {
 
   test("capture future error", () {
     Future<bool> value = new Future<bool>.error("BAD", stack);
-    Result.capture(value).then(expectAsync((Result result) {
+    Result.capture(value).then(expectAsync1((Result result) {
       expect(result.isValue, isFalse);
       expect(result.isError, isTrue);
       ErrorResult error = result.asError;
@@ -136,7 +142,7 @@ void main() {
   test("release future value", () {
     Future<Result<int>> future =
         new Future<Result<int>>.value(new Result<int>.value(42));
-    Result.release(future).then(expectAsync((v) {
+    Result.release(future).then(expectAsync1((v) {
       expect(v, equals(42));
     }), onError: (e, s) {
       fail("Unexpected error: $e");
@@ -149,7 +155,7 @@ void main() {
         new Future<Result<bool>>.value(new Result<bool>.error("BAD", stack));
     Result.release(future).then((v) {
       fail("Unexpected value: $v");
-    }, onError: expectAsync((e, s) {
+    }, onError: expectAsync2((e, s) {
       expect(e, equals("BAD"));
       expect(s, same(stack));
     }));
@@ -160,7 +166,7 @@ void main() {
     Future<Result<bool>> future = new Future<Result<bool>>.error("BAD", stack);
     Result.release(future).then((v) {
       fail("Unexpected value: $v");
-    }, onError: expectAsync((e, s) {
+    }, onError: expectAsync2((e, s) {
       expect(e, equals("BAD"));
       expect(s, same(stack));
     }));
@@ -169,17 +175,19 @@ void main() {
   test("capture stream", () {
     StreamController<int> c = new StreamController<int>();
     Stream<Result> stream = Result.captureStream(c.stream);
-    var expectedList = new Queue.from([new Result.value(42),
-                                       new Result.error("BAD", stack),
-                                       new Result.value(37)]);
+    var expectedList = new Queue.from([
+      new Result.value(42),
+      new Result.error("BAD", stack),
+      new Result.value(37)
+    ]);
     void listener(Result actual) {
       expect(expectedList.isEmpty, isFalse);
       expectResult(actual, expectedList.removeFirst());
     }
-    stream.listen(expectAsync(listener, count: 3),
-                  onError: (e, s) { fail("Unexpected error: $e"); },
-                  onDone: expectAsync((){}),
-                  cancelOnError: true);
+
+    stream.listen(expectAsync1(listener, count: 3), onError: (e, s) {
+      fail("Unexpected error: $e");
+    }, onDone: expectAsync0(() {}), cancelOnError: true);
     c.add(42);
     c.addError("BAD", stack);
     c.add(37);
@@ -189,12 +197,14 @@ void main() {
   test("release stream", () {
     StreamController<Result<int>> c = new StreamController<Result<int>>();
     Stream<int> stream = Result.releaseStream(c.stream);
-    List events = [new Result<int>.value(42),
-                   new Result<int>.error("BAD", stack),
-                   new Result<int>.value(37)];
+    var events = [
+      new Result<int>.value(42),
+      new Result<int>.error("BAD", stack),
+      new Result<int>.value(37)
+    ];
     // Expect the data events, and an extra error event.
     var expectedList = new Queue.from(events)
-        ..add(new Result.error("BAD2", stack));
+      ..add(new Result.error("BAD2", stack));
 
     void dataListener(int v) {
       expect(expectedList.isEmpty, isFalse);
@@ -211,33 +221,33 @@ void main() {
       expect(stackTrace, same(expected.asError.stackTrace));
     }
 
-    stream.listen(expectAsync(dataListener, count: 2),
-                  onError: expectAsync(errorListener, count: 2),
-                  onDone: expectAsync((){}));
+    stream.listen(expectAsync1(dataListener, count: 2),
+        onError: expectAsync2(errorListener, count: 2),
+        onDone: expectAsync0(() {}));
     for (Result<int> result in events) {
-      c.add(result);  // Result value or error in data line.
+      c.add(result); // Result value or error in data line.
     }
-    c.addError("BAD2", stack);  // Error in error line.
+    c.addError("BAD2", stack); // Error in error line.
     c.close();
   });
 
   test("release stream cancel on error", () {
     StreamController<Result<int>> c = new StreamController<Result<int>>();
     Stream<int> stream = Result.releaseStream(c.stream);
-    stream.listen(expectAsync((v) { expect(v, equals(42)); }),
-                  onError: expectAsync((e, s) {
-                    expect(e, equals("BAD"));
-                    expect(s, same(stack));
-                  }),
-                  onDone: () { fail("Unexpected done event"); },
-                  cancelOnError: true);
+    stream.listen(expectAsync1((v) {
+      expect(v, equals(42));
+    }), onError: expectAsync2((e, s) {
+      expect(e, equals("BAD"));
+      expect(s, same(stack));
+    }), onDone: () {
+      fail("Unexpected done event");
+    }, cancelOnError: true);
     c.add(new Result.value(42));
     c.add(new Result.error("BAD", stack));
     c.add(new Result.value(37));
     c.close();
   });
 
-
   test("flatten error 1", () {
     Result<int> error = new Result<int>.error("BAD", stack);
     Result<int> flattened =
@@ -259,7 +269,7 @@ void main() {
   });
 
   test("handle unary", () {
-    var result = new Result.error("error", stack);
+    ErrorResult result = new Result.error("error", stack);
     bool called = false;
     result.handle((error) {
       called = true;
@@ -269,7 +279,7 @@ void main() {
   });
 
   test("handle binary", () {
-    var result = new Result.error("error", stack);
+    ErrorResult result = new Result.error("error", stack);
     bool called = false;
     result.handle((error, stackTrace) {
       called = true;
@@ -280,7 +290,7 @@ void main() {
   });
 
   test("handle unary and binary", () {
-    var result = new Result.error("error", stack);
+    ErrorResult result = new Result.error("error", stack);
     bool called = false;
     result.handle((error, [stackTrace]) {
       called = true;
@@ -291,19 +301,13 @@ void main() {
   });
 
   test("handle neither unary nor binary", () {
-    var result = new Result.error("error", stack);
-    expect(() => result.handle(() => fail("unreachable")),
-           throws);
-    expect(() => result.handle((a, b, c) => fail("unreachable")),
-           throws);
-    expect(() => result.handle((a, b, {c}) => fail("unreachable")),
-           throws);
-    expect(() => result.handle((a, {b}) => fail("unreachable")),
-           throws);
-    expect(() => result.handle(({a, b}) => fail("unreachable")),
-           throws);
-    expect(() => result.handle(({a}) => fail("unreachable")),
-           throws);
+    ErrorResult result = new Result.error("error", stack);
+    expect(() => result.handle(() => fail("unreachable")), throws);
+    expect(() => result.handle((a, b, c) => fail("unreachable")), throws);
+    expect(() => result.handle((a, b, {c}) => fail("unreachable")), throws);
+    expect(() => result.handle((a, {b}) => fail("unreachable")), throws);
+    expect(() => result.handle(({a, b}) => fail("unreachable")), throws);
+    expect(() => result.handle(({a}) => fail("unreachable")), throws);
   });
 }
 
@@ -323,17 +327,32 @@ class TestSink<T> implements EventSink<T> {
   final Function onError;
   final Function onDone;
 
-  TestSink({void this.onData(T data) : _nullData,
-            void this.onError(e, StackTrace s) : _nullError,
-            void this.onDone() : _nullDone });
+  TestSink(
+      {void this.onData(T data): _nullData,
+      void this.onError(e, StackTrace s): _nullError,
+      void this.onDone(): _nullDone});
+
+  void add(T value) {
+    onData(value);
+  }
+
+  void addError(error, [StackTrace stack]) {
+    onError(error, stack);
+  }
+
+  void close() {
+    onDone();
+  }
 
-  void add(T value) { onData(value); }
-  void addError(error, [StackTrace stack]) { onError(error, stack); }
-  void close() { onDone(); }
+  static void _nullData(value) {
+    fail("Unexpected sink add: $value");
+  }
 
-  static void _nullData(value) { fail("Unexpected sink add: $value"); }
   static void _nullError(e, StackTrace s) {
     fail("Unexpected sink addError: $e");
   }
-  static void _nullDone() { fail("Unepxected sink close"); }
+
+  static void _nullDone() {
+    fail("Unepxected sink close");
+  }
 }