Remove warnings in tests, and even fix analyzer hints.

test/stream_completer_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 file.
 
 import "dart:async";
 
 import "package:async/async.dart" show StreamCompleter;
 import "package:test/test.dart";
 
 import "utils.dart";
@@ skipping 57 matching lines @@
       await flushMicrotasks();
       expect(events, []);
       subscription.resume();
     }
     await done;
     expect(events, [1, 2, 3, 4]);
   });
 
   test("cancel new stream before source is done", () async {
     var completer = new StreamCompleter();
-    var listened = false;
     var lastEvent = -1;
     var controller = new StreamController();
     var subscription;
     subscription = completer.stream.listen(
         (value) {
           expect(value, lessThan(3));
           lastEvent = value;
           if (value == 2) {
             subscription.cancel();
           }
@@ skipping 50 matching lines @@
     completer.setSourceStream(controller.stream);
     await flushMicrotasks();
     expect(controller.hasListener, isFalse);
     var subscription = completer.stream.listen(null);
     expect(controller.hasListener, isTrue);
     await subscription.asFuture();
   });
 
   test("cancelOnError true when listening before linking stream", () async {
     var completer = new StreamCompleter();
-    var listened = false;
-    var canceled = false;
     var lastEvent = -1;
     var controller = new StreamController();
-    var subscription = completer.stream.listen(
+    completer.stream.listen(
         (value) {
           expect(value, lessThan(3));
           lastEvent = value;
         },
         onError: (value) {
           expect(value, "3");
           lastEvent = value;
         },
         onDone: unreachable("done"),
         cancelOnError: true);
@@ skipping 20 matching lines @@
   });
 
   test("cancelOnError true when listening after linking stream", () async {
     var completer = new StreamCompleter();
     var lastEvent = -1;
     var controller = new StreamController();
     completer.setSourceStream(controller.stream);
     controller.add(1);
     expect(controller.hasListener, isFalse);
 
-    var subscription = completer.stream.listen(
+    completer.stream.listen(
         (value) {
           expect(value, lessThan(3));
           lastEvent = value;
         },
         onError: (value) {
           expect(value, "3");
           lastEvent = value;
         },
         onDone: unreachable("done"),
         cancelOnError: true);
@@ skipping 10 matching lines @@
     expect(controller.hasListener, isTrue);
     controller.addError("3");
 
     await flushMicrotasks();
     expect(controller.hasListener, isFalse);
   });
 
   test("linking a stream after setSourceStream before listen", () async {
     var completer = new StreamCompleter();
     completer.setSourceStream(createStream());
-    expect(() => completer.setSourceStream(createStream()), throws);
-    expect(() => completer.setEmpty(createStream()), throws);
+    expect(() => completer.setSourceStream(createStream()), throwsStateError);
+    expect(() => completer.setEmpty(), throwsStateError);
     await completer.stream.toList();
     // Still fails after source is done
-    expect(() => completer.setSourceStream(createStream()), throws);
-    expect(() => completer.setEmpty(createStream()), throws);
+    expect(() => completer.setSourceStream(createStream()), throwsStateError);
+    expect(() => completer.setEmpty(), throwsStateError);
   });
 
   test("linking a stream after setSourceStream after listen", () async {
     var completer = new StreamCompleter();
     var list = completer.stream.toList();
     completer.setSourceStream(createStream());
-    expect(() => completer.setSoureStream(createStream()), throws);
-    expect(() => completer.stEmpty(createStream()), throws);
+    expect(() => completer.setSourceStream(createStream()), throwsStateError);
+    expect(() => completer.setEmpty(), throwsStateError);
     await list;
     // Still fails after source is done.
-    expect(() => completer.setSoureStream(createStream()), throws);
-    expect(() => completer.stEmpty(createStream()), throws);
+    expect(() => completer.setSourceStream(createStream()), throwsStateError);
+    expect(() => completer.setEmpty(), throwsStateError);
   });
 
   test("linking a stream after setEmpty before listen", () async {
     var completer = new StreamCompleter();
     completer.setEmpty();
-    expect(() => completer.setSoureStream(createStream()), throws);
-    expect(() => completer.stEmpty(createStream()), throws);
+    expect(() => completer.setSourceStream(createStream()), throwsStateError);
+    expect(() => completer.setEmpty(), throwsStateError);
     await completer.stream.toList();
     // Still fails after source is done
-    expect(() => completer.setSoureStream(createStream()), throws);
-    expect(() => completer.stEmpty(createStream()), throws);
+    expect(() => completer.setSourceStream(createStream()), throwsStateError);
+    expect(() => completer.setEmpty(), throwsStateError);
   });
 
   test("linking a stream after setEmpty() after listen", () async {
     var completer = new StreamCompleter();
     var list = completer.stream.toList();
     completer.setEmpty();
-    expect(() => completer.setSoureStream(createStream()), throws);
-    expect(() => completer.stEmpty(createStream()), throws);
+    expect(() => completer.setSourceStream(createStream()), throwsStateError);
+    expect(() => completer.setEmpty(), throwsStateError);
     await list;
     // Still fails after source is done.
-    expect(() => completer.setSoureStream(createStream()), throws);
-    expect(() => completer.stEmpty(createStream()), throws);
+    expect(() => completer.setSourceStream(createStream()), throwsStateError);
+    expect(() => completer.setEmpty(), throwsStateError);
   });
 
   test("listening more than once after setting stream", () async {
     var completer = new StreamCompleter();
     completer.setSourceStream(createStream());
     var list = completer.stream.toList();
-    expect(() => completer.stream.oList(), throws);
+    expect(() => completer.stream.toList(), throwsStateError);
     await list;
-    expect(() => completer.stream.oList(), throws);
+    expect(() => completer.stream.toList(), throwsStateError);
   });
 
   test("listening more than once before setting stream", () async {
     var completer = new StreamCompleter();
-    var list = completer.stream.toList();
-    expect(() => completer.stream.oList(), throws);
+    completer.stream.toList();
+    expect(() => completer.stream.toList(), throwsStateError);
   });
 
   test("setting onData etc. before and after setting stream", () async {
     var completer = new StreamCompleter();
     var controller = new StreamController();
     var subscription = completer.stream.listen(null);
     var lastEvent = 0;
     subscription.onData((value) => lastEvent = value);
     subscription.onError((value) => lastEvent = "$value");
     subscription.onDone(() => lastEvent = -1);
@@ skipping 15 matching lines @@
     expect(lastEvent, "-2");
     controller.close();
     await flushMicrotasks();
     expect(lastEvent, -1);
   });
 
   test("pause w/ resume future accross setting stream", () async {
     var completer = new StreamCompleter();
     var resume = new Completer();
     var subscription = completer.stream.listen(unreachable("data"));
-    var lastEvent = 0;
     subscription.pause(resume.future);
     await flushMicrotasks();
     completer.setSourceStream(createStream());
     await flushMicrotasks();
     resume.complete();
     var events = [];
     subscription.onData(events.add);
     await subscription.asFuture();
     expect(events, [1, 2, 3, 4]);
   });
@@ skipping 18 matching lines @@
 
 Stream<int> createStream() async* {
   yield 1;
   await flushMicrotasks();
   yield 2;
   await flushMicrotasks();
   yield 3;
   await flushMicrotasks();
   yield 4;
 }
-
-/// A zero-millisecond timer should wait until after all microtasks.
-Future flushMicrotasks() => new Future.delayed(Duration.ZERO);
-
-/// A generic unreachable callback function.
-///
-/// Returns a function that fails the test if it is ever called.
-unreachable(String name) => ([a, b]) => fail("Unreachable: $name");
-
-/// A badly behaved stream which throws if it's ever listened to.
-///
-/// Can be used to test cases where a stream should not be used.
-class UnusableStream extends Stream {
-  listen(onData, {onError, onDone, cancelOnError}) {
-    throw new UnimplementedError("Gotcha!");
-  }
-}