Fix Dart 1.17 strong-mode warnings.

test/stream_queue_test.dart

 // Copyright (c) 2015, 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 filevents.
 
 import "dart:async";
 
 import "package:async/async.dart" show StreamQueue;
 import "package:test/test.dart";
 
 import "utils.dart";
 
 main() {
   group("source stream", () {
     test("is listened to on first request, paused between requests", () async {
-      var controller = new StreamController();
+      var controller = new StreamController<int>();
       var events = new StreamQueue<int>(controller.stream);
       await flushMicrotasks();
       expect(controller.hasListener, isFalse);
 
       var next = events.next;
       expect(controller.hasListener, isTrue);
       expect(controller.isPaused, isFalse);
 
       controller.add(1);
 
@@ skipping 255 matching lines @@
       expect(() => events.next, throwsStateError);
       expect(() => events.skip(1), throwsStateError);
       expect(() => events.take(1), throwsStateError);
       expect(() => events.rest, throwsStateError);
       expect(() => events.cancel(), throwsStateError);
       expect(stream.toList(), completion([1, 2, 3, 4]));
     });
 
     test("forwards to underlying stream", () async {
       var cancel = new Completer();
-      var controller = new StreamController(onCancel: () => cancel.future);
+      var controller = new StreamController<int>(onCancel: () => cancel.future);
       var events = new StreamQueue<int>(controller.stream);
       expect(controller.hasListener, isFalse);
       var next = events.next;
       expect(controller.hasListener, isTrue);
       expect(controller.isPaused, isFalse);
 
       controller.add(1);
       expect(await next, 1);
       expect(controller.isPaused, isTrue);
 
@@ skipping 38 matching lines @@
       expect(() => events.next, throwsStateError);
       expect(() => events.skip(1), throwsStateError);
       expect(() => events.take(1), throwsStateError);
       expect(() => events.rest, throwsStateError);
       expect(() => events.cancel(), throwsStateError);
     });
 
     test("cancels underlying subscription when called before any event",
         () async {
       var cancelFuture = new Future.value(42);
-      var controller = new StreamController(onCancel: () => cancelFuture);
+      var controller = new StreamController<int>(onCancel: () => cancelFuture);
       var events = new StreamQueue<int>(controller.stream);
       expect(await events.cancel(), 42);
     });
 
     test("cancels underlying subscription, returns result", () async {
       var cancelFuture = new Future.value(42);
-      var controller = new StreamController(onCancel: () => cancelFuture);
+      var controller = new StreamController<int>(onCancel: () => cancelFuture);
       var events = new StreamQueue<int>(controller.stream);
       controller.add(1);
       expect(await events.next, 1);
       expect(await events.cancel(), 42);
     });
 
     group("with immediate: true", () {
       test("closes the events, prevents any other operation", () async {
         var events = new StreamQueue<int>(createStream());
         await events.cancel(immediate: true);
         expect(() => events.next, throwsStateError);
         expect(() => events.skip(1), throwsStateError);
         expect(() => events.take(1), throwsStateError);
         expect(() => events.rest, throwsStateError);
         expect(() => events.cancel(), throwsStateError);
       });
 
       test("cancels the underlying subscription immediately", () async {
-        var controller = new StreamController();
+        var controller = new StreamController<int>();
         controller.add(1);
 
         var events = new StreamQueue<int>(controller.stream);
         expect(await events.next, 1);
         expect(controller.hasListener, isTrue);
 
         events.cancel(immediate: true);
         await expect(controller.hasListener, isFalse);
       });
 
       test("cancels the underlying subscription when called before any event",
           () async {
         var cancelFuture = new Future.value(42);
-        var controller = new StreamController(onCancel: () => cancelFuture);
+        var controller = new StreamController<int>(onCancel: () => cancelFuture);
 
         var events = new StreamQueue<int>(controller.stream);
         expect(await events.cancel(immediate: true), 42);
       });
 
       test("closes pending requests", () async {
         var events = new StreamQueue<int>(createStream());
         expect(await events.next, 1);
         expect(events.next, throwsStateError);
         expect(events.hasNext, completion(isFalse));
 
         await events.cancel(immediate: true);
       });
 
       test("returns the result of closing the underlying subscription",
           () async {
-        var controller = new StreamController(
+        var controller = new StreamController<int>(
             onCancel: () => new Future.value(42));
         var events = new StreamQueue<int>(controller.stream);
         expect(await events.cancel(immediate: true), 42);
       });
 
       test("listens and then cancels a stream that hasn't been listened to yet",
           () async {
         var wasListened = false;
-        var controller = new StreamController(
+        var controller = new StreamController<int>(
             onListen: () => wasListened = true);
         var events = new StreamQueue<int>(controller.stream);
         expect(wasListened, isFalse);
         expect(controller.hasListener, isFalse);
 
         await events.cancel(immediate: true);
         expect(wasListened, isTrue);
         expect(controller.hasListener, isFalse);
       });
     });
@@ skipping 14 matching lines @@
     test("true at end", () async {
       var events = new StreamQueue<int>(createStream());
       for (int i = 1; i <= 4; i++) {
         expect(await events.next, i);
       }
       expect(await events.hasNext, isFalse);
     });
 
     test("true when enqueued", () async {
       var events = new StreamQueue<int>(createStream());
-      var values = [];
+      var values = <int>[];
       for (int i = 1; i <= 3; i++) {
         events.next.then(values.add);
       }
       expect(values, isEmpty);
       expect(await events.hasNext, isTrue);
       expect(values, [1, 2, 3]);
     });
 
     test("false when enqueued", () async {
       var events = new StreamQueue<int>(createStream());
-      var values = [];
+      var values = <int>[];
       for (int i = 1; i <= 4; i++) {
         events.next.then(values.add);
       }
       expect(values, isEmpty);
       expect(await events.hasNext, isFalse);
       expect(values, [1, 2, 3, 4]);
     });
 
     test("true when data event", () async {
-      var controller = new StreamController();
+      var controller = new StreamController<int>();
       var events = new StreamQueue<int>(controller.stream);
 
       var hasNext;
       events.hasNext.then((result) { hasNext = result; });
       await flushMicrotasks();
       expect(hasNext, isNull);
       controller.add(42);
       expect(hasNext, isNull);
       await flushMicrotasks();
       expect(hasNext, isTrue);
     });
 
     test("true when error event", () async {
-      var controller = new StreamController();
+      var controller = new StreamController<int>();
       var events = new StreamQueue<int>(controller.stream);
 
       var hasNext;
       events.hasNext.then((result) { hasNext = result; });
       await flushMicrotasks();
       expect(hasNext, isNull);
       controller.addError("BAD");
       expect(hasNext, isNull);
       await flushMicrotasks();
       expect(hasNext, isTrue);
@@ skipping 21 matching lines @@
     test("- next after true", () async {
       var events = new StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
       expect(await events.next, 2);
       expect(await events.next, 3);
     });
 
     test("- next after true, enqueued", () async {
       var events = new StreamQueue<int>(createStream());
-      var responses = [];
+      var responses = <Object>[];
       events.next.then(responses.add);
       events.hasNext.then(responses.add);
       events.next.then(responses.add);
       do {
         await flushMicrotasks();
       } while (responses.length < 3);
       expect(responses, [1, true, 2]);
     });
 
     test("- skip 0 after true", () async {
@@ skipping 137 matching lines @@
   yield 1;
   await flushMicrotasks();
   yield 2;
   await flushMicrotasks();
   yield 3;
   await flushMicrotasks();
   yield 4;
 }
 
 Stream<int> createErrorStream() {
-  StreamController controller = new StreamController<int>();
+  var controller = new StreamController<int>();
   () async {
     controller.add(1);
     await flushMicrotasks();
     controller.add(2);
     await flushMicrotasks();
     controller.addError("To err is divine!");
     await flushMicrotasks();
     controller.add(4);
     await flushMicrotasks();
     controller.close();
   }();
   return controller.stream;
 }
 
 Stream<int> createLongStream(int eventCount) async* {
   for (int i = 0; i < eventCount; i++) yield i;
 }