Add methods to Result. Bump version to 2.0 and remove deprecated features.

test/result/result_captureAll_test.dart

Index: test/result/result_captureAll_test.dart
diff --git a/test/result/result_captureAll_test.dart b/test/result/result_captureAll_test.dart
new file mode 100644
index 0000000000000000000000000000000000000000..172e38a9f469e5e9262398dc2c017dbc0558788b
--- /dev/null
+++ b/test/result/result_captureAll_test.dart
@@ -0,0 +1,187 @@
+// Copyright (c) 2017, 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 "dart:math" show Random;
+import "package:async/async.dart";
+import "package:test/test.dart";
+
+final someStack = StackTrace.current;
+Result<int> res(int n) => new Result<int>.value(n);
+Result err(n) => new ErrorResult("$n", someStack);
+
+/// Helper function creating an iterable of futures.
+Iterable<Future<int>> futures(int count, {bool throwWhen(int index)}) sync* {
+  for (int i = 0; i < count; i++) {
+    if (throwWhen != null && throwWhen(i)) {
+      yield new Future<int>.error("$i", someStack);
+    } else {
+      yield new Future<int>.value(i);
+    }
+  }
+}
+
+main() {
+  test("empty", () async {
+    var all = await Result.captureAll<int>(futures(0));
+    expect(all, []);
+  });
+
+  group("futures only,", () {
+    test("single", () async {
+      var all = await Result.captureAll<int>(futures(1));
+      expect(all, [res(0)]);
+    });
+
+    test("multiple", () async {
+      var all = await Result.captureAll<int>(futures(3));
+      expect(all, [res(0), res(1), res(2)]);
+    });
+
+    test("error only", () async {
+      var all =
+          await Result.captureAll<int>(futures(1, throwWhen: (_) => true));
+      expect(all, [err(0)]);
+    });
+
+    test("multiple error only", () async {
+      var all =
+          await Result.captureAll<int>(futures(3, throwWhen: (_) => true));
+      expect(all, [err(0), err(1), err(2)]);
+    });
+
+    test("mixed error and value", () async {
+      var all =
+          await Result.captureAll<int>(futures(4, throwWhen: (x) => x.isOdd));
+      expect(all, [res(0), err(1), res(2), err(3)]);
+    });
+
+    test("completion permutation 1-2-3", () async {
+      var cs = new List.generate(3, (_) => new Completer<int>());
+      var all = Result.captureAll<int>(cs.map((c) => c.future));
+      expect(all, completion([res(1), res(2), err(3)]));
+      await 0;
+      cs[0].complete(1);
+      await 0;
+      cs[1].complete(2);
+      await 0;
+      cs[2].completeError("3", someStack);
+    });
+
+    test("completion permutation 1-3-2", () async {
+      var cs = new List.generate(3, (_) => new Completer<int>());
+      var all = Result.captureAll<int>(cs.map((c) => c.future));
+      expect(all, completion([res(1), res(2), err(3)]));
+      await 0;
+      cs[0].complete(1);
+      await 0;
+      cs[2].completeError("3", someStack);
+      await 0;
+      cs[1].complete(2);
+    });
+
+    test("completion permutation 2-1-3", () async {
+      var cs = new List.generate(3, (_) => new Completer<int>());
+      var all = Result.captureAll<int>(cs.map((c) => c.future));
+      expect(all, completion([res(1), res(2), err(3)]));
+      await 0;
+      cs[1].complete(2);
+      await 0;
+      cs[0].complete(1);
+      await 0;
+      cs[2].completeError("3", someStack);
+    });
+
+    test("completion permutation 2-3-1", () async {
+      var cs = new List.generate(3, (_) => new Completer<int>());
+      var all = Result.captureAll<int>(cs.map((c) => c.future));
+      expect(all, completion([res(1), res(2), err(3)]));
+      await 0;
+      cs[1].complete(2);
+      await 0;
+      cs[2].completeError("3", someStack);
+      await 0;
+      cs[0].complete(1);
+    });
+
+    test("completion permutation 3-1-2", () async {
+      var cs = new List.generate(3, (_) => new Completer<int>());
+      var all = Result.captureAll<int>(cs.map((c) => c.future));
+      expect(all, completion([res(1), res(2), err(3)]));
+      await 0;
+      cs[2].completeError("3", someStack);
+      await 0;
+      cs[0].complete(1);
+      await 0;
+      cs[1].complete(2);
+    });
+
+    test("completion permutation 3-2-1", () async {
+      var cs = new List.generate(3, (_) => new Completer<int>());
+      var all = Result.captureAll<int>(cs.map((c) => c.future));
+      expect(all, completion([res(1), res(2), err(3)]));
+      await 0;
+      cs[2].completeError("3", someStack);
+      await 0;
+      cs[1].complete(2);
+      await 0;
+      cs[0].complete(1);
+    });
+
+    var seed = new Random().nextInt(0x100000000);
+    int n = 25; // max 32, otherwise rnd.nextInt(1<<n) won't work.
+    test("randomized #$n seed:${seed.toRadixString(16)}", () async {
+      var cs = new List.generate(n, (_) => new Completer<int>());
+      var all = Result.captureAll<int>(cs.map((c) => c.future));
+      var rnd = new Random(seed);
+      var throwFlags = rnd.nextInt(1 << n); // Bit-flag for throwing.
+      bool throws(index) => (throwFlags & (1 << index)) != 0;
+      var expected = new List.generate(n, (x) => throws(x) ? err(x) : res(x));
+
+      expect(all, completion(expected));
+
+      var completeFunctions = new List<Function()>.generate(n, (i) {
+        var c = cs[i];
+        return () =>
+            throws(i) ? c.completeError("$i", someStack) : c.complete(i);
+      });
+      completeFunctions.shuffle(rnd);
+      for (int i = 0; i < n; i++) {
+        await 0;
+        completeFunctions[i]();
+      }
+    });
+  });
+  group("values only,", () {
+    test("single", () async {
+      var all = await Result.captureAll<int>(<int>[1]);
+      expect(all, [res(1)]);
+    });
+    test("multiple", () async {
+      var all = await Result.captureAll<int>(<int>[1, 2, 3]);
+      expect(all, [res(1), res(2), res(3)]);
+    });
+  });
+  group("mixed futures and values,", () {
+    test("no error", () async {
+      var all = await Result.captureAll<int>(<FutureOr<int>>[
+        1,
+        new Future<int>(() => 2),
+        3,
+        new Future<int>.value(4),
+      ]);
+      expect(all, [res(1), res(2), res(3), res(4)]);
+    });
+    test("error", () async {
+      var all = await Result.captureAll<int>(<FutureOr<int>>[
+        1,
+        new Future<int>(() => 2),
+        3,
+        new Future<int>(() async => await new Future.error("4", someStack)),
+        new Future<int>.value(5)
+      ]);
+      expect(all, [res(1), res(2), res(3), err(4), res(5)]);
+    });
+  });
+}