Add Future.any and Stream.fromFutures.

tests/lib/async/future_test.dart

 // Copyright (c) 2012, 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.
 
 library future_test;
 
 import 'package:async_helper/async_helper.dart';
 import "package:expect/expect.dart";
 import 'dart:async';
 
@@ skipping 908 matching lines @@
              new Future<int>.microtask(() => value));
     testType("Future.sync($value)", new Future<int>.sync(() => value));  /// 01: ok
     testType("Future.sync(future($value))",                              /// 01: continued
              new Future<int>.sync(() async => new Future.value(value))); /// 01: continued
     testType("Future.value($value)", new Future<int>.value(value));
   }
   testType("Completer.future", new Completer<int>().future);
   testType("Future.error", new Future<int>.error("ERR")..catchError((_){}));
 }
 
+void testAnyValue() {
+  asyncStart();
+  var cs = new List.generate(3, (_) => new Completer());
+  var result = Future.any(cs.map((x) => x.future));
+
+  result.then((v) {
+    Expect.equals(42, v);
+    asyncEnd();
+  }, onError: (e, s) {
+    Expect.fail("Unexpected error: $e");
+  });
+
+  cs[1].complete(42);
+  cs[2].complete(10);
+  cs[0].complete(20);
+}
+
+void testAnyError() {
+  asyncStart();
+  var cs = new List.generate(3, (_) => new Completer());
+  var result = Future.any(cs.map((x) => x.future));
+
+  result.then((v) {
+    Expect.fail("Unexpected value: $v");
+  }, onError: (e, s) {
+    Expect.equals(42, e);
+    asyncEnd();
+  });
+
+  cs[1].completeError(42);
+  cs[2].complete(10);
+  cs[0].complete(20);
+}
+
+void testAnyIgnoreIncomplete() {
+  asyncStart();
+  var cs = new List.generate(3, (_) => new Completer());
+  var result = Future.any(cs.map((x) => x.future));
+
+  result.then((v) {
+    Expect.equals(42, v);
+    asyncEnd();
+  }, onError: (e, s) {
+    Expect.fail("Unexpected error: $e");
+  });
+
+  cs[1].complete(42);
+  // The other two futures never complete.
+}
+
+void testAnyIgnoreError() {
+  asyncStart();
+  var cs = new List.generate(3, (_) => new Completer());
+  var result = Future.any(cs.map((x) => x.future));
+
+  result.then((v) {
+    Expect.equals(42, v);
+    asyncEnd();
+  }, onError: (e, s) {
+    Expect.fail("Unexpected error: $e");
+  });
+
+  cs[1].complete(42);
+  // The errors are ignored, not uncaught.
+  cs[2].completeError("BAD");
+  cs[0].completeError("BAD");
+}
+
 main() {
   asyncStart();
 
   testValue();
   testSync();
   testNeverComplete();
 
   testComplete();
   testCompleteWithSuccessHandlerBeforeComplete();
   testCompleteWithSuccessHandlerAfterComplete();
@@ skipping 43 matching lines @@
 
   testSyncFuture_i13368();
 
   testWaitCleanUp();
   testWaitCleanUpError();
 
   testBadFuture();
 
   testTypes();
 
+  testAnyValue();
+  testAnyError();
+  testAnyIgnoreIncomplete();
+  testAnyIgnoreError();
+
   asyncEnd();
 }
 
 /// A Future that isn't recognizable as a _Future.
 class CustomFuture<T> implements Future<T> {
   Future _realFuture;
   CustomFuture(this._realFuture);
   Future then(action(result), {Function onError}) =>
       _realFuture.then(action, onError: onError);
   Future catchError(Function onError, {bool test(e)}) =>
@@ skipping 16 matching lines @@
   Future whenComplete(action()) {
     throw "finally GOTCHA!";
   }
   Stream<T> asStream() {
     throw "asStream GOTCHA!";
   }
   Future timeout(Duration duration, {onTimeout()}) {
     throw "timeout GOTCHA!";
   }
 }