Fix Dart 1.17 strong-mode warnings.

test/typed_wrapper/future_test.dart

 // Copyright (c) 2016, 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 "package:async/async.dart";
 import "package:async/src/typed/future.dart";
 import "package:test/test.dart";
 
 import '../utils.dart';
 
 void main() {
   group("with valid types, forwards", () {
     var wrapper;
-    var errorWrapper;
+    TypeSafeFuture<int> errorWrapper;
     setUp(() {
       wrapper = new TypeSafeFuture<int>(new Future<Object>.value(12));
 
       var error = new Future<Object>.error("oh no");
       error.catchError((_) {}); // Don't let the error cause the test to fail.
       errorWrapper = new TypeSafeFuture<int>(error);
     });
 
     test("asStream()", () {
       expect(wrapper.asStream().toList(), completion(equals([12])));
       expect(errorWrapper.asStream().first, throwsA("oh no"));
     });
 
     test("catchError()", () {
       expect(
           wrapper.catchError(expectAsync((_) {}, count: 0),
               test: expectAsync((_) {}, count: 0)),
           completion(equals(12)));
 
       expect(errorWrapper.catchError(expectAsync((error) {
         expect(error, equals("oh no"));
-        return "value";
+        return 42;
       }), test: expectAsync((error) {
         expect(error, equals("oh no"));
         return true;
-      })), completion(equals("value")));
+      })), completion(equals(42)));
     });
 
     test("then()", () {
       expect(wrapper.then((value) => value.toString()),
           completion(equals("12")));
       expect(errorWrapper.then(expectAsync((_) {}, count: 0)),
           throwsA("oh no"));
     });
 
     test("whenComplete()", () {
@@ skipping 11 matching lines @@
           throwsA(new isInstanceOf<TimeoutException>()));
 
       expect(
           new TypeSafeFuture<int>(new Completer<Object>().future)
               .timeout(Duration.ZERO, onTimeout: expectAsync(() => 15)),
           completion(equals(15)));
     });
   });
 
   group("with invalid types", () {
-    var wrapper;
+    TypeSafeFuture<int> wrapper;
     setUp(() {
       wrapper = new TypeSafeFuture<int>(new Future<Object>.value("foo"));
     });
 
     group("throws a CastError for", () {
       test("asStream()", () {
         expect(wrapper.asStream().first, throwsCastError);
       });
 
       test("then()", () {
@@ skipping 12 matching lines @@
         expect(wrapper.timeout(new Duration(seconds: 3)).then((_) {}),
             throwsCastError);
 
       expect(
           new TypeSafeFuture<int>(new Completer<Object>().future)
               .timeout(Duration.ZERO, onTimeout: expectAsync(() => "foo"))
               .then((_) {}),
           throwsCastError);
       });
     });
-
-    group("doesn't throw a CastError for", () {
-      test("catchError()", () {
-        // catchError has a Future<dynamic> return type, so even if there's no
-        // error we don't re-wrap the returned future.
-        expect(wrapper.catchError(expectAsync((_) {}, count: 0)),
-            completion(equals("foo")));
-      });
-    });
   });
 }