Migrated test block 168 to Dart 2.0.

tests/lib_2/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 103 matching lines @@
   });
 }
 
 void testCompleteManySuccessHandlers() {
   final completer = new Completer<int>();
   final future = completer.future;
   int before;
   int after1;
   int after2;
 
-  var futures = [];
+  var futures = <Future<int>>[];
   futures.add(future.then((int v) {
     before = v;
   }));
   completer.complete(3);
   futures.add(future.then((int v) {
     after1 = v;
   }));
   futures.add(future.then((int v) {
     after2 = v;
   }));
@@ skipping 459 matching lines @@
   completer.future.then((v) {
     Expect.equals(42, v);
     asyncEnd();
   });
   completer2.complete(42);
 }
 
 void testCompleteWithFutureSuccess2() {
   asyncStart();
   final completer = new Completer<int>();
-  Future result = new Future.value(42);
+  final result = new Future<int>.value(42);
   completer.complete(result);
   completer.future.then((v) {
     Expect.equals(42, v);
     asyncEnd();
   });
 }
 
 void testCompleteWithFutureError() {
   asyncStart();
   final completer = new Completer<int>();
   final completer2 = new Completer<int>();
   completer.complete(completer2.future);
   completer.future.then((v) {
     Expect.fail("Should not happen");
     asyncEnd();
   }, onError: (e) {
     Expect.equals("ERROR-tcwfe", e);
     asyncEnd();
   });
   completer2.completeError("ERROR-tcwfe");
 }
 
 void testCompleteWithFutureError2() {
   asyncStart();
   final completer = new Completer<int>();
-  Future result = new Future.error("ERROR-tcwfe2");
+  var result = new Future<int>.error("ERROR-tcwfe2");
   completer.complete(result);
   completer.future.then((v) {
     Expect.fail("Should not happen");
     asyncEnd();
   }, onError: (e) {
     Expect.equals("ERROR-tcwfe2", e);
     asyncEnd();
   });
+
 }
 
 void testCompleteErrorWithFuture() {
   asyncStart();
   final completer = new Completer<int>();
   completer.completeError(new Future.value(42));
   completer.future.then((_) {
     Expect.fail("Shouldn't happen");
   }, onError: (e, s) {
     Future f = e;
@@ skipping 120 matching lines @@
 }
 
 void testWaitCleanUp() {
   asyncStart();
   // Creates three futures with different completion times, and where some fail.
   // The `mask` specifies which futures fail (values 1-7),
   // and `permute` defines the order of completion. values 0-5.
   void doTest(int mask, int permute) {
     asyncStart();
     String stringId = "waitCleanup-$mask-$permute";
-    List futures = new List(3);
+    List<Future> futures = new List(3);
     List cleanup = new List(3);
     int permuteTmp = permute;
     for (int i = 0; i < 3; i++) {
       bool throws = (mask & (1 << i)) != 0;
       var future = new Future.delayed(new Duration(milliseconds: 100 * (i + 1)),
           () => (throws ? throw "Error $i($mask-$permute)" : i));
       int mod = 3 - i;
       int position = permuteTmp % mod;
       permuteTmp = permuteTmp ~/ mod;
       while (futures[position] != null) position++;
@@ skipping 24 matching lines @@
 void testWaitCleanUpEager() {
   asyncStart();
   // Creates three futures with different completion times, and where some fail.
   // The `mask` specifies which futures fail (values 1-7),
   // and `permute` defines the order of completion. values 0-5.
   void doTest(int mask, int permute) {
     asyncStart();
     asyncStart();
     bool done = false;
     String stringId = "waitCleanup-$mask-$permute";
-    List futures = new List(3);
+    List<Future> futures = new List<Future>(3);
     List cleanup = new List(3);
     int permuteTmp = permute;
     for (int i = 0; i < 3; i++) {
       bool throws = (mask & (1 << i)) != 0;
       var future = new Future.delayed(new Duration(milliseconds: 100 * (i + 1)),
           () => (throws ? throw "Error $i($mask-$permute)" : i));
       int mod = 3 - i;
       int position = permuteTmp % mod;
       permuteTmp = permuteTmp ~/ mod;
       while (futures[position] != null) position++;
@@ skipping 152 matching lines @@
       testType(name, future.whenComplete(() {}), depth - 1);
     }
   }
 
   for (var value in [42, null]) {
     testType("Future($value)", new Future<int>(() => value));
     testType("Future.delayed($value)",
         new Future<int>.delayed(Duration.ZERO, () => value));
     testType(
         "Future.microtask($value)", 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(() => new Future<int>.value(value))); //# 01: continued
+    testType(
+        "Future.sync($value)", new Future<int>.sync(() => value)); // #01: ok
+    testType( //# 01: continued
+        "Future.sync(future($value))", //# 01: continued
+        new Future<int>.sync(//# 01: continued
+            () => new Future<int>.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));
@@ skipping 157 matching lines @@
   testAnyIgnoreIncomplete();
   testAnyIgnoreError();
 
   testFutureResult();
 
   asyncEnd();
 }
 
 /// A well-behaved Future that isn't recognizable as a _Future.
 class CustomFuture<T> implements Future<T> {
-  Future _realFuture;
+  Future<T> _realFuture;
   CustomFuture(this._realFuture);
-  Future then(action(result), {Function onError}) =>
+  Future<S> then<S>(action(T result), {Function onError}) =>
       _realFuture.then(action, onError: onError);
-  Future catchError(Function onError, {bool test(e)}) =>
+  Future<T> catchError(Function onError, {bool test(e)}) =>
       _realFuture.catchError(onError, test: test);
-  Future whenComplete(action()) => _realFuture.whenComplete(action);
-  Future timeout(Duration timeLimit, {void onTimeout()}) =>
+  Future<T> whenComplete(action()) => _realFuture.whenComplete(action);
+  Future<T> timeout(Duration timeLimit, {void onTimeout()}) =>
       _realFuture.timeout(timeLimit, onTimeout: onTimeout);
-  Stream asStream() => _realFuture.asStream();
+  Stream<T> asStream() => _realFuture.asStream();
   String toString() => "CustomFuture@${_realFuture.hashCode}";
   int get hashCode => _realFuture.hashCode;
 }
 
 /// A bad future that throws on every method.
 class BadFuture<T> implements Future<T> {
-  Future then(action(T result), {Function onError}) {
+  Future<S> then<S>(action(T result), {Function onError}) {
     throw "then GOTCHA!";
   }
 
-  Future catchError(Function onError, {bool test(e)}) {
+  Future<T> catchError(Function onError, {bool test(Object e)}) {
     throw "catch GOTCHA!";
   }
 
-  Future whenComplete(action()) {
+  Future<T> whenComplete(action()) {
     throw "finally GOTCHA!";
   }
 
   Stream<T> asStream() {
     throw "asStream GOTCHA!";
   }
 
-  Future timeout(Duration duration, {onTimeout()}) {
+  Future<T> timeout(Duration duration, {onTimeout()}) {
     throw "timeout GOTCHA!";
   }
 }
 
 // An evil future that completes with another future.
 class UglyFuture implements Future<dynamic> {
   final _result;
   UglyFuture(int badness)
       : _result = (badness == 0) ? 42 : new UglyFuture(badness - 1);
-  Future then(action(value), {onError(error, StackTrace stack)}) {
+  Future<S> then<S>(action(value), {Function onError}) {
     var c = new Completer();
     c.complete(new Future.microtask(() => action(_result)));
     return c.future;
   }
 
   Future catchError(onError, {test}) => this; // Never an error.
   Future whenComplete(action()) {
     return new Future.microtask(action).then((_) => this);
   }
 
   Stream asStream() {
     return (new StreamController()
           ..add(_result)
           ..close())
         .stream;
   }
 
   Future timeout(Duration duration, {onTimeout()}) {
     return this;
   }
 }