Remove warnings in tests, and even fix analyzer hints.

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";
@@ skipping 19 matching lines @@
       next = events.next;
       expect(controller.hasListener, isTrue);
       expect(controller.isPaused, isFalse);
 
       controller.add(2);
 
       expect(await next, 2);
       expect(controller.hasListener, isTrue);
       expect(controller.isPaused, isTrue);
 
-      var cancel = events.cancel();
+      events.cancel();
       expect(controller.hasListener, isFalse);
     });
   });
 
   group("next operation", () {
     test("simple sequence of requests", () async {
       var events = new StreamQueue<int>(createStream());
       for (int i = 1; i <= 4; i++) {
         expect(await events.next, i);
       }
@@ skipping 225 matching lines @@
     });
 
     test("closes the events, prevents other operations", () async {
       var events = new StreamQueue<int>(createStream());
       var stream = events.rest;
       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 events = new StreamQueue<int>(controller.stream);
       expect(controller.hasListener, isFalse);
       var next = events.next;
       expect(controller.hasListener, isTrue);
       expect(controller.isPaused, isFalse);
@@ skipping 151 matching lines @@
       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 first = events.next.then(responses.add);
-      var hasSecond = events.hasNext.then(responses.add);
-      var second = events.next.then(responses.add);
+      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 {
       var events = new StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
@@ skipping 152 matching lines @@
     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;
 }