diff --git a/.travis.yml b/.travis.yml
index dd151e8..ccc0864 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -2,7 +2,7 @@
 
 dart:
   - dev
-  - 2.0.0
+  - 2.2.0
 
 dart_task:
   - test: --platform vm
diff --git a/lib/async.dart b/lib/async.dart
index 25fc0fd..2af006b 100644
--- a/lib/async.dart
+++ b/lib/async.dart
@@ -2,33 +2,33 @@
 // 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.
 
-export "src/async_cache.dart";
-export "src/async_memoizer.dart";
-export "src/byte_collector.dart";
-export "src/cancelable_operation.dart";
-export "src/delegate/event_sink.dart";
-export "src/delegate/future.dart";
-export "src/delegate/sink.dart";
-export "src/delegate/stream.dart";
-export "src/delegate/stream_consumer.dart";
-export "src/delegate/stream_sink.dart";
-export "src/delegate/stream_subscription.dart";
-export "src/future_group.dart";
-export "src/lazy_stream.dart";
-export "src/null_stream_sink.dart";
-export "src/restartable_timer.dart";
-export "src/result/result.dart";
-export "src/result/error.dart";
-export "src/result/future.dart";
-export "src/result/value.dart";
-export "src/single_subscription_transformer.dart";
-export "src/stream_completer.dart";
-export "src/stream_group.dart";
-export "src/stream_queue.dart";
-export "src/stream_sink_completer.dart";
-export "src/stream_sink_transformer.dart";
-export "src/stream_splitter.dart";
-export "src/stream_subscription_transformer.dart";
-export "src/stream_zip.dart";
-export "src/subscription_stream.dart";
-export "src/typed_stream_transformer.dart";
+export 'src/async_cache.dart';
+export 'src/async_memoizer.dart';
+export 'src/byte_collector.dart';
+export 'src/cancelable_operation.dart';
+export 'src/delegate/event_sink.dart';
+export 'src/delegate/future.dart';
+export 'src/delegate/sink.dart';
+export 'src/delegate/stream.dart';
+export 'src/delegate/stream_consumer.dart';
+export 'src/delegate/stream_sink.dart';
+export 'src/delegate/stream_subscription.dart';
+export 'src/future_group.dart';
+export 'src/lazy_stream.dart';
+export 'src/null_stream_sink.dart';
+export 'src/restartable_timer.dart';
+export 'src/result/result.dart';
+export 'src/result/error.dart';
+export 'src/result/future.dart';
+export 'src/result/value.dart';
+export 'src/single_subscription_transformer.dart';
+export 'src/stream_completer.dart';
+export 'src/stream_group.dart';
+export 'src/stream_queue.dart';
+export 'src/stream_sink_completer.dart';
+export 'src/stream_sink_transformer.dart';
+export 'src/stream_splitter.dart';
+export 'src/stream_subscription_transformer.dart';
+export 'src/stream_zip.dart';
+export 'src/subscription_stream.dart';
+export 'src/typed_stream_transformer.dart';
diff --git a/lib/src/async_cache.dart b/lib/src/async_cache.dart
index 4b02304..e0a6f49 100644
--- a/lib/src/async_cache.dart
+++ b/lib/src/async_cache.dart
@@ -56,7 +56,7 @@
   ///
   /// If [fetch] has been called recently enough, returns its previous return
   /// value. Otherwise, runs [callback] and returns its new return value.
-  Future<T> fetch(Future<T> callback()) async {
+  Future<T> fetch(Future<T> Function() callback) async {
     if (_cachedStreamSplitter != null) {
       throw StateError('Previously used to cache via `fetchStream`');
     }
@@ -74,17 +74,15 @@
   /// If [fetchStream] has been called recently enough, returns a copy of its
   /// previous return value. Otherwise, runs [callback] and returns its new
   /// return value.
-  Stream<T> fetchStream(Stream<T> callback()) {
+  Stream<T> fetchStream(Stream<T> Function() callback) {
     if (_cachedValueFuture != null) {
       throw StateError('Previously used to cache via `fetch`');
     }
-    if (_cachedStreamSplitter == null) {
-      _cachedStreamSplitter = StreamSplitter(callback()
-          .transform(StreamTransformer.fromHandlers(handleDone: (sink) {
-        _startStaleTimer();
-        sink.close();
-      })));
-    }
+    _cachedStreamSplitter ??= StreamSplitter(
+        callback().transform(StreamTransformer.fromHandlers(handleDone: (sink) {
+      _startStaleTimer();
+      sink.close();
+    })));
     return _cachedStreamSplitter.split();
   }
 
diff --git a/lib/src/async_memoizer.dart b/lib/src/async_memoizer.dart
index 5e83400..7e545fe 100644
--- a/lib/src/async_memoizer.dart
+++ b/lib/src/async_memoizer.dart
@@ -39,7 +39,7 @@
   /// Runs the function, [computation], if it hasn't been run before.
   ///
   /// If [runOnce] has already been called, this returns the original result.
-  Future<T> runOnce(FutureOr<T> computation()) {
+  Future<T> runOnce(FutureOr<T> Function() computation) {
     if (!hasRun) _completer.complete(Future.sync(computation));
     return future;
   }
diff --git a/lib/src/byte_collector.dart b/lib/src/byte_collector.dart
index f01cc2a..0226dea 100644
--- a/lib/src/byte_collector.dart
+++ b/lib/src/byte_collector.dart
@@ -2,9 +2,9 @@
 // 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 "dart:typed_data";
-import "cancelable_operation.dart";
+import 'dart:async';
+import 'dart:typed_data';
+import 'cancelable_operation.dart';
 
 /// Collects an asynchronous sequence of byte lists into a single list of bytes.
 ///
@@ -40,10 +40,8 @@
 /// Performs all the same operations, but the final result is created
 /// by the [result] function, which has access to the stream subscription
 /// so it can cancel the operation.
-T _collectBytes<T>(
-    Stream<List<int>> source,
-    T result(
-        StreamSubscription<List<int>> subscription, Future<Uint8List> result)) {
+T _collectBytes<T>(Stream<List<int>> source,
+    T Function(StreamSubscription<List<int>>, Future<Uint8List>) result) {
   var byteLists = <List<int>>[];
   var length = 0;
   var completer = Completer<Uint8List>.sync();
@@ -63,7 +61,7 @@
 // Join a lists of bytes with a known total length into a single [Uint8List].
 Uint8List _collect(int length, List<List<int>> byteLists) {
   var result = Uint8List(length);
-  int i = 0;
+  var i = 0;
   for (var byteList in byteLists) {
     var end = i + byteList.length;
     result.setRange(i, end, byteList);
diff --git a/lib/src/cancelable_operation.dart b/lib/src/cancelable_operation.dart
index 94601c9..bac8f9b 100644
--- a/lib/src/cancelable_operation.dart
+++ b/lib/src/cancelable_operation.dart
@@ -30,7 +30,7 @@
   /// [onCancel] will be called synchronously when the operation is canceled.
   /// It's guaranteed to only be called once.
   factory CancelableOperation.fromFuture(Future<T> inner,
-      {FutureOr onCancel()}) {
+      {FutureOr Function() onCancel}) {
     var completer = CancelableCompleter<T>(onCancel: onCancel);
     completer.complete(inner);
     return completer.operation;
@@ -145,7 +145,7 @@
   ///
   /// [onCancel] will be called synchronously when the operation is canceled.
   /// It's guaranteed to only be called once.
-  CancelableCompleter({FutureOr onCancel()})
+  CancelableCompleter({FutureOr Function() onCancel})
       : _onCancel = onCancel,
         _inner = Completer<T>() {
     _operation = CancelableOperation<T>._(this);
@@ -171,7 +171,7 @@
   /// If [value] is a [Future], this will complete to the result of that
   /// [Future] once it completes.
   void complete([value]) {
-    if (_isCompleted) throw StateError("Operation already completed");
+    if (_isCompleted) throw StateError('Operation already completed');
     _isCompleted = true;
 
     if (value is! Future) {
@@ -197,7 +197,7 @@
 
   /// Completes [operation] to [error].
   void completeError(Object error, [StackTrace stackTrace]) {
-    if (_isCompleted) throw StateError("Operation already completed");
+    if (_isCompleted) throw StateError('Operation already completed');
     _isCompleted = true;
 
     if (_isCanceled) return;
diff --git a/lib/src/delegate/event_sink.dart b/lib/src/delegate/event_sink.dart
index 95d7841..977ee64 100644
--- a/lib/src/delegate/event_sink.dart
+++ b/lib/src/delegate/event_sink.dart
@@ -25,14 +25,17 @@
   static EventSink<T> typed<T>(EventSink sink) =>
       sink is EventSink<T> ? sink : DelegatingEventSink._(sink);
 
+  @override
   void add(T data) {
     _sink.add(data);
   }
 
+  @override
   void addError(error, [StackTrace stackTrace]) {
     _sink.addError(error, stackTrace);
   }
 
+  @override
   void close() {
     _sink.close();
   }
diff --git a/lib/src/delegate/future.dart b/lib/src/delegate/future.dart
index 62ff96f..8c5dd04 100644
--- a/lib/src/delegate/future.dart
+++ b/lib/src/delegate/future.dart
@@ -21,16 +21,21 @@
   static Future<T> typed<T>(Future future) =>
       future is Future<T> ? future : future.then((v) => v as T);
 
+  @override
   Stream<T> asStream() => _future.asStream();
 
-  Future<T> catchError(Function onError, {bool test(Object error)}) =>
+  @override
+  Future<T> catchError(Function onError, {bool Function(Object error) test}) =>
       _future.catchError(onError, test: test);
 
-  Future<S> then<S>(FutureOr<S> onValue(T value), {Function onError}) =>
+  @override
+  Future<S> then<S>(FutureOr<S> Function(T) onValue, {Function onError}) =>
       _future.then(onValue, onError: onError);
 
-  Future<T> whenComplete(action()) => _future.whenComplete(action);
+  @override
+  Future<T> whenComplete(FutureOr action) => _future.whenComplete(action);
 
-  Future<T> timeout(Duration timeLimit, {onTimeout()}) =>
+  @override
+  Future<T> timeout(Duration timeLimit, {FutureOr<T> Function() onTimeout}) =>
       _future.timeout(timeLimit, onTimeout: onTimeout);
 }
diff --git a/lib/src/delegate/sink.dart b/lib/src/delegate/sink.dart
index b8ba76d..c1e01d7 100644
--- a/lib/src/delegate/sink.dart
+++ b/lib/src/delegate/sink.dart
@@ -23,10 +23,12 @@
   static Sink<T> typed<T>(Sink sink) =>
       sink is Sink<T> ? sink : DelegatingSink._(sink);
 
+  @override
   void add(T data) {
     _sink.add(data);
   }
 
+  @override
   void close() {
     _sink.close();
   }
diff --git a/lib/src/delegate/stream_consumer.dart b/lib/src/delegate/stream_consumer.dart
index ad53182..591f903 100644
--- a/lib/src/delegate/stream_consumer.dart
+++ b/lib/src/delegate/stream_consumer.dart
@@ -27,7 +27,9 @@
           ? consumer
           : DelegatingStreamConsumer._(consumer);
 
+  @override
   Future addStream(Stream<T> stream) => _consumer.addStream(stream);
 
+  @override
   Future close() => _consumer.close();
 }
diff --git a/lib/src/delegate/stream_sink.dart b/lib/src/delegate/stream_sink.dart
index 67eb33c..3971189 100644
--- a/lib/src/delegate/stream_sink.dart
+++ b/lib/src/delegate/stream_sink.dart
@@ -11,6 +11,7 @@
 class DelegatingStreamSink<T> implements StreamSink<T> {
   final StreamSink _sink;
 
+  @override
   Future get done => _sink.done;
 
   /// Create delegating sink forwarding calls to [sink].
@@ -27,15 +28,19 @@
   static StreamSink<T> typed<T>(StreamSink sink) =>
       sink is StreamSink<T> ? sink : DelegatingStreamSink._(sink);
 
+  @override
   void add(T data) {
     _sink.add(data);
   }
 
+  @override
   void addError(error, [StackTrace stackTrace]) {
     _sink.addError(error, stackTrace);
   }
 
+  @override
   Future addStream(Stream<T> stream) => _sink.addStream(stream);
 
+  @override
   Future close() => _sink.close();
 }
diff --git a/lib/src/delegate/stream_subscription.dart b/lib/src/delegate/stream_subscription.dart
index 07af08e..7d258a8 100644
--- a/lib/src/delegate/stream_subscription.dart
+++ b/lib/src/delegate/stream_subscription.dart
@@ -28,29 +28,37 @@
           ? subscription
           : TypeSafeStreamSubscription<T>(subscription);
 
-  void onData(void handleData(T data)) {
+  @override
+  void onData(void Function(T) handleData) {
     _source.onData(handleData);
   }
 
+  @override
   void onError(Function handleError) {
     _source.onError(handleError);
   }
 
-  void onDone(void handleDone()) {
+  @override
+  void onDone(void Function() handleDone) {
     _source.onDone(handleDone);
   }
 
+  @override
   void pause([Future resumeFuture]) {
     _source.pause(resumeFuture);
   }
 
+  @override
   void resume() {
     _source.resume();
   }
 
+  @override
   Future cancel() => _source.cancel();
 
+  @override
   Future<E> asFuture<E>([E futureValue]) => _source.asFuture(futureValue);
 
+  @override
   bool get isPaused => _source.isPaused;
 }
diff --git a/lib/src/future_group.dart b/lib/src/future_group.dart
index 7e17494..a6abff0 100644
--- a/lib/src/future_group.dart
+++ b/lib/src/future_group.dart
@@ -41,12 +41,8 @@
   ///
   /// Once this group isn't waiting on any futures *and* [close] has been
   /// called, this stream will close.
-  Stream get onIdle {
-    if (_onIdleController == null) {
-      _onIdleController = StreamController.broadcast(sync: true);
-    }
-    return _onIdleController.stream;
-  }
+  Stream get onIdle =>
+      (_onIdleController ??= StreamController.broadcast(sync: true)).stream;
 
   StreamController _onIdleController;
 
@@ -54,11 +50,12 @@
   /// the order they were added.
   ///
   /// The slots for futures that haven't completed yet are `null`.
-  final _values = List<T>();
+  final _values = <T>[];
 
   /// Wait for [task] to complete.
+  @override
   void add(Future<T> task) {
-    if (_closed) throw StateError("The FutureGroup is closed.");
+    if (_closed) throw StateError('The FutureGroup is closed.');
 
     // Ensure that future values are put into [values] in the same order they're
     // added to the group by pre-allocating a slot for them and recording its
@@ -87,6 +84,7 @@
 
   /// Signals to the group that the caller is done adding futures, and so
   /// [future] should fire once all added futures have completed.
+  @override
   void close() {
     _closed = true;
     if (_pending != 0) return;
diff --git a/lib/src/lazy_stream.dart b/lib/src/lazy_stream.dart
index 278957a..d2ac33c 100644
--- a/lib/src/lazy_stream.dart
+++ b/lib/src/lazy_stream.dart
@@ -2,11 +2,11 @@
 // 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 'dart:async';
 
-import "delegate/stream.dart";
-import "stream_completer.dart";
-import "utils.dart";
+import 'delegate/stream.dart';
+import 'stream_completer.dart';
+import 'utils.dart';
 
 /// A [Stream] wrapper that forwards to another [Stream] that's initialized
 /// lazily.
@@ -20,15 +20,16 @@
 
   /// Creates a single-subscription `Stream` that calls [callback] when it gets
   /// a listener and forwards to the returned stream.
-  LazyStream(FutureOr<Stream<T>> callback()) : _callback = callback {
+  LazyStream(FutureOr<Stream<T>> Function() callback) : _callback = callback {
     // Explicitly check for null because we null out [_callback] internally.
     if (_callback == null) throw ArgumentError.notNull('callback');
   }
 
-  StreamSubscription<T> listen(void onData(T event),
-      {Function onError, void onDone(), bool cancelOnError}) {
+  @override
+  StreamSubscription<T> listen(void Function(T) onData,
+      {Function onError, void Function() onDone, bool cancelOnError}) {
     if (_callback == null) {
-      throw StateError("Stream has already been listened to.");
+      throw StateError('Stream has already been listened to.');
     }
 
     // Null out the callback before we invoke it to ensure that even while
diff --git a/lib/src/null_stream_sink.dart b/lib/src/null_stream_sink.dart
index c9d3d5d..f820328 100644
--- a/lib/src/null_stream_sink.dart
+++ b/lib/src/null_stream_sink.dart
@@ -26,6 +26,7 @@
 /// }
 /// ```
 class NullStreamSink<T> implements StreamSink<T> {
+  @override
   final Future done;
 
   /// Whether the sink has been closed.
@@ -54,14 +55,17 @@
           // experiencing an error.
           ..catchError((_) {});
 
+  @override
   void add(T data) {
     _checkEventAllowed();
   }
 
+  @override
   void addError(error, [StackTrace stackTrace]) {
     _checkEventAllowed();
   }
 
+  @override
   Future addStream(Stream<T> stream) {
     _checkEventAllowed();
 
@@ -75,12 +79,13 @@
   /// Throws a [StateError] if [close] has been called or an [addStream] call is
   /// pending.
   void _checkEventAllowed() {
-    if (_closed) throw StateError("Cannot add to a closed sink.");
+    if (_closed) throw StateError('Cannot add to a closed sink.');
     if (_addingStream) {
-      throw StateError("Cannot add to a sink while adding a stream.");
+      throw StateError('Cannot add to a sink while adding a stream.');
     }
   }
 
+  @override
   Future close() {
     _closed = true;
     return done;
diff --git a/lib/src/restartable_timer.dart b/lib/src/restartable_timer.dart
index 4720bcd..9ecf443 100644
--- a/lib/src/restartable_timer.dart
+++ b/lib/src/restartable_timer.dart
@@ -28,6 +28,7 @@
   RestartableTimer(this._duration, this._callback)
       : _timer = Timer(_duration, _callback);
 
+  @override
   bool get isActive => _timer.isActive;
 
   /// Restarts the timer so that it counts down from its original duration
@@ -39,6 +40,7 @@
     _timer = Timer(_duration, _callback);
   }
 
+  @override
   void cancel() {
     _timer.cancel();
   }
@@ -48,5 +50,6 @@
   ///
   /// Calls to [reset] will also reset the tick so subsequent tick values may
   /// not be strictly larger than previous values.
+  @override
   int get tick => _timer.tick;
 }
diff --git a/lib/src/result/capture_sink.dart b/lib/src/result/capture_sink.dart
index 0477a19..a7c3a59 100644
--- a/lib/src/result/capture_sink.dart
+++ b/lib/src/result/capture_sink.dart
@@ -12,14 +12,17 @@
 
   CaptureSink(EventSink<Result<T>> sink) : _sink = sink;
 
+  @override
   void add(T value) {
     _sink.add(Result<T>.value(value));
   }
 
+  @override
   void addError(Object error, [StackTrace stackTrace]) {
     _sink.add(Result.error(error, stackTrace));
   }
 
+  @override
   void close() {
     _sink.close();
   }
diff --git a/lib/src/result/capture_transformer.dart b/lib/src/result/capture_transformer.dart
index a727a8e..1f58d06 100644
--- a/lib/src/result/capture_transformer.dart
+++ b/lib/src/result/capture_transformer.dart
@@ -14,6 +14,7 @@
 class CaptureStreamTransformer<T> extends StreamTransformerBase<T, Result<T>> {
   const CaptureStreamTransformer();
 
+  @override
   Stream<Result<T>> bind(Stream<T> source) =>
       Stream<Result<T>>.eventTransformed(
           source, (sink) => CaptureSink<T>(sink));
diff --git a/lib/src/result/error.dart b/lib/src/result/error.dart
index 8f29d13..76e0275 100644
--- a/lib/src/result/error.dart
+++ b/lib/src/result/error.dart
@@ -15,21 +15,28 @@
   /// The stack trace corresponding to where [error] was thrown.
   final StackTrace stackTrace;
 
+  @override
   bool get isValue => false;
+  @override
   bool get isError => true;
+  @override
   ValueResult<Null> get asValue => null;
+  @override
   ErrorResult get asError => this;
 
   ErrorResult(this.error, this.stackTrace);
 
+  @override
   void complete(Completer completer) {
     completer.completeError(error, stackTrace);
   }
 
+  @override
   void addTo(EventSink sink) {
     sink.addError(error, stackTrace);
   }
 
+  @override
   Future<Null> get asFuture => Future<Null>.error(error, stackTrace);
 
   /// Calls an error handler with the error and stacktrace.
@@ -46,9 +53,11 @@
     }
   }
 
+  @override
   int get hashCode => error.hashCode ^ stackTrace.hashCode ^ 0x1d61823f;
 
   /// This is equal only to an error result with equal [error] and [stackTrace].
+  @override
   bool operator ==(Object other) =>
       other is ErrorResult &&
       error == other.error &&
diff --git a/lib/src/result/release_sink.dart b/lib/src/result/release_sink.dart
index a0715a1..78d0f42 100644
--- a/lib/src/result/release_sink.dart
+++ b/lib/src/result/release_sink.dart
@@ -12,16 +12,19 @@
 
   ReleaseSink(EventSink<T> sink) : _sink = sink;
 
+  @override
   void add(Result<T> result) {
     result.addTo(_sink);
   }
 
+  @override
   void addError(Object error, [StackTrace stackTrace]) {
     // Errors may be added by intermediate processing, even if it is never
     // added by CaptureSink.
     _sink.addError(error, stackTrace);
   }
 
+  @override
   void close() {
     _sink.close();
   }
diff --git a/lib/src/result/release_transformer.dart b/lib/src/result/release_transformer.dart
index 1aead30..2548ac9 100644
--- a/lib/src/result/release_transformer.dart
+++ b/lib/src/result/release_transformer.dart
@@ -11,6 +11,7 @@
 class ReleaseStreamTransformer<T> extends StreamTransformerBase<Result<T>, T> {
   const ReleaseStreamTransformer();
 
+  @override
   Stream<T> bind(Stream<Result<T>> source) {
     return Stream<T>.eventTransformed(source, _createSink);
   }
diff --git a/lib/src/result/result.dart b/lib/src/result/result.dart
index 28799fa..e04da9f 100644
--- a/lib/src/result/result.dart
+++ b/lib/src/result/result.dart
@@ -60,7 +60,7 @@
   /// This generates either a [ValueResult] with the value returned by
   /// calling `computation`, or an [ErrorResult] with an error thrown by
   /// the call.
-  factory Result(T computation()) {
+  factory Result(T Function() computation) {
     try {
       return ValueResult<T>(computation());
     } catch (e, s) {
@@ -97,11 +97,11 @@
   /// The returned future will never have an error.
   static Future<List<Result<T>>> captureAll<T>(Iterable<FutureOr<T>> elements) {
     var results = <Result<T>>[];
-    int pending = 0;
+    var pending = 0;
     Completer<List<Result<T>>> completer;
     for (var element in elements) {
       if (element is Future<T>) {
-        int i = results.length;
+        var i = results.length;
         results.add(null);
         pending++;
         Result.capture<T>(element).then((result) {
diff --git a/lib/src/result/value.dart b/lib/src/result/value.dart
index dddc9fe..5c1a60f 100644
--- a/lib/src/result/value.dart
+++ b/lib/src/result/value.dart
@@ -12,25 +12,34 @@
   /// The result of a successful computation.
   final T value;
 
+  @override
   bool get isValue => true;
+  @override
   bool get isError => false;
+  @override
   ValueResult<T> get asValue => this;
+  @override
   ErrorResult get asError => null;
 
   ValueResult(this.value);
 
+  @override
   void complete(Completer<T> completer) {
     completer.complete(value);
   }
 
+  @override
   void addTo(EventSink<T> sink) {
     sink.add(value);
   }
 
+  @override
   Future<T> get asFuture => Future.value(value);
 
+  @override
   int get hashCode => value.hashCode ^ 0x323f1d61;
 
+  @override
   bool operator ==(Object other) =>
       other is ValueResult && value == other.value;
 }
diff --git a/lib/src/single_subscription_transformer.dart b/lib/src/single_subscription_transformer.dart
index 8007a42..fe939fc 100644
--- a/lib/src/single_subscription_transformer.dart
+++ b/lib/src/single_subscription_transformer.dart
@@ -16,6 +16,7 @@
 class SingleSubscriptionTransformer<S, T> extends StreamTransformerBase<S, T> {
   const SingleSubscriptionTransformer();
 
+  @override
   Stream<T> bind(Stream<S> stream) {
     StreamSubscription<S> subscription;
     var controller =
diff --git a/lib/src/stream_completer.dart b/lib/src/stream_completer.dart
index bbb2155..5128d57 100644
--- a/lib/src/stream_completer.dart
+++ b/lib/src/stream_completer.dart
@@ -2,7 +2,7 @@
 // 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 'dart:async';
 
 /// A single-subscription [stream] where the contents are provided later.
 ///
@@ -75,7 +75,7 @@
   /// most once. Trying to call any of them again will fail.
   void setSourceStream(Stream<T> sourceStream) {
     if (_stream._isSourceStreamSet) {
-      throw StateError("Source stream already set");
+      throw StateError('Source stream already set');
     }
     _stream._setSourceStream(sourceStream);
   }
@@ -86,7 +86,7 @@
   /// most once. Trying to call any of them again will fail.
   void setEmpty() {
     if (_stream._isSourceStreamSet) {
-      throw StateError("Source stream already set");
+      throw StateError('Source stream already set');
     }
     _stream._setEmpty();
   }
@@ -116,8 +116,9 @@
   /// or [_setEmpty].
   Stream<T> _sourceStream;
 
-  StreamSubscription<T> listen(onData(T data),
-      {Function onError, void onDone(), bool cancelOnError}) {
+  @override
+  StreamSubscription<T> listen(void Function(T) onData,
+      {Function onError, void Function() onDone, bool cancelOnError}) {
     if (_controller == null) {
       if (_sourceStream != null && !_sourceStream.isBroadcast) {
         // If the source stream is itself single subscription,
diff --git a/lib/src/stream_group.dart b/lib/src/stream_group.dart
index 1a6d15d..8ea95f3 100644
--- a/lib/src/stream_group.dart
+++ b/lib/src/stream_group.dart
@@ -47,7 +47,7 @@
   /// subscriptions will be canceled and set to null again. Single-subscriber
   /// stream subscriptions will be left intact, since they can't be
   /// re-subscribed.
-  final _subscriptions = Map<Stream<T>, StreamSubscription<T>>();
+  final _subscriptions = <Stream<T>, StreamSubscription<T>>{};
 
   /// Merges the events from [streams] into a single single-subscription stream.
   ///
@@ -99,6 +99,7 @@
   /// `null`.
   ///
   /// Throws a [StateError] if this group is closed.
+  @override
   Future add(Stream<T> stream) {
     if (_closed) {
       throw StateError("Can't add a Stream to a closed StreamGroup.");
@@ -214,6 +215,7 @@
   /// Otherwise, [stream] will close once all streams in the group close.
   ///
   /// Returns a [Future] that completes once [stream] has actually been closed.
+  @override
   Future close() {
     if (_closed) return _controller.done;
 
@@ -230,12 +232,12 @@
   ///
   /// New streams added to the group will be listened once the group has a
   /// listener.
-  static const dormant = _StreamGroupState("dormant");
+  static const dormant = _StreamGroupState('dormant');
 
   /// The group has one or more listeners and is actively firing events.
   ///
   /// New streams added to the group will be immediately listeners.
-  static const listening = _StreamGroupState("listening");
+  static const listening = _StreamGroupState('listening');
 
   /// The group is paused and no more events will be fired until it resumes.
   ///
@@ -243,7 +245,7 @@
   /// will be resumed once the group itself is resumed.
   ///
   /// This state is only used by single-subscriber groups.
-  static const paused = _StreamGroupState("paused");
+  static const paused = _StreamGroupState('paused');
 
   /// The group is canceled and no more events will be fired ever.
   ///
@@ -251,7 +253,7 @@
   /// discarded.
   ///
   /// This state is only used by single-subscriber groups.
-  static const canceled = _StreamGroupState("canceled");
+  static const canceled = _StreamGroupState('canceled');
 
   /// The name of the state.
   ///
@@ -260,5 +262,6 @@
 
   const _StreamGroupState(this.name);
 
+  @override
   String toString() => name;
 }
diff --git a/lib/src/stream_queue.dart b/lib/src/stream_queue.dart
index fd3186e..cf75a6d 100644
--- a/lib/src/stream_queue.dart
+++ b/lib/src/stream_queue.dart
@@ -7,11 +7,11 @@
 
 import 'package:collection/collection.dart';
 
-import "cancelable_operation.dart";
-import "result/result.dart";
-import "subscription_stream.dart";
-import "stream_completer.dart";
-import "stream_splitter.dart";
+import 'cancelable_operation.dart';
+import 'result/result.dart';
+import 'subscription_stream.dart';
+import 'stream_completer.dart';
+import 'stream_splitter.dart';
 
 /// An asynchronous pull-based interface for accessing stream events.
 ///
@@ -146,7 +146,7 @@
   /// If one of the next [count] events is an error, the returned future
   /// completes with this error, and the error is still left in the queue.
   Future<List<T>> lookAhead(int count) {
-    if (count < 0) throw RangeError.range(count, 0, null, "count");
+    if (count < 0) throw RangeError.range(count, 0, null, 'count');
     if (!_isClosed) {
       var request = _LookAheadRequest<T>(count);
       _addRequest(request);
@@ -226,7 +226,7 @@
   /// then all events were succssfully skipped. If the value
   /// is greater than zero then the stream ended early.
   Future<int> skip(int count) {
-    if (count < 0) throw RangeError.range(count, 0, null, "count");
+    if (count < 0) throw RangeError.range(count, 0, null, 'count');
     if (!_isClosed) {
       var request = _SkipRequest<T>(count);
       _addRequest(request);
@@ -251,7 +251,7 @@
   /// of data collected so far. That is, the returned
   /// list may have fewer than [count] elements.
   Future<List<T>> take(int count) {
-    if (count < 0) throw RangeError.range(count, 0, null, "count");
+    if (count < 0) throw RangeError.range(count, 0, null, 'count');
     if (!_isClosed) {
       var request = _TakeRequest<T>(count);
       _addRequest(request);
@@ -324,7 +324,7 @@
   ///   }
   /// }
   /// ```
-  Future<bool> withTransaction(Future<bool> callback(StreamQueue<T> queue)) {
+  Future<bool> withTransaction(Future<bool> Function(StreamQueue<T>) callback) {
     var transaction = startTransaction();
 
     /// Avoid async/await to ensure that [startTransaction] is called
@@ -363,7 +363,7 @@
   ///     _stdinQueue.cancelable((queue) => queue.next);
   /// ```
   CancelableOperation<S> cancelable<S>(
-      Future<S> callback(StreamQueue<T> queue)) {
+      Future<S> Function(StreamQueue<T>) callback) {
     var transaction = startTransaction();
     var completer = CancelableCompleter<S>(onCancel: () {
       transaction.reject();
@@ -486,7 +486,7 @@
         _addResult(Result.error(error, stackTrace));
       }, onDone: () {
         _subscription = null;
-        this._close();
+        _close();
       });
     } else {
       _subscription.resume();
@@ -529,7 +529,7 @@
   /// Returns a [StateError] with a message saying that either
   /// [cancel] or [rest] have already been called.
   Error _failClosed() {
-    return StateError("Already cancelled");
+    return StateError('Already cancelled');
   }
 
   /// Adds a new request to the queue.
@@ -558,7 +558,7 @@
   final StreamSplitter<T> _splitter;
 
   /// Queues created using [newQueue].
-  final _queues = Set<StreamQueue>();
+  final _queues = <StreamQueue>{};
 
   /// Whether [commit] has been called.
   var _committed = false;
@@ -639,9 +639,9 @@
   /// Throws a [StateError] if [accept] or [reject] has already been called.
   void _assertActive() {
     if (_committed) {
-      throw StateError("This transaction has already been accepted.");
+      throw StateError('This transaction has already been accepted.');
     } else if (_rejected) {
-      throw StateError("This transaction has already been rejected.");
+      throw StateError('This transaction has already been rejected.');
     }
   }
 }
@@ -696,13 +696,14 @@
 
   Future<T> get future => _completer.future;
 
+  @override
   bool update(QueueList<Result<T>> events, bool isDone) {
     if (events.isNotEmpty) {
       events.removeFirst().complete(_completer);
       return true;
     }
     if (isDone) {
-      _completer.completeError(StateError("No elements"), StackTrace.current);
+      _completer.completeError(StateError('No elements'), StackTrace.current);
       return true;
     }
     return false;
@@ -721,13 +722,14 @@
 
   Future<T> get future => _completer.future;
 
+  @override
   bool update(QueueList<Result<T>> events, bool isDone) {
     if (events.isNotEmpty) {
       events.first.complete(_completer);
       return true;
     }
     if (isDone) {
-      _completer.completeError(StateError("No elements"), StackTrace.current);
+      _completer.completeError(StateError('No elements'), StackTrace.current);
       return true;
     }
     return false;
@@ -752,6 +754,7 @@
   /// The future completed when the correct number of events have been skipped.
   Future<int> get future => _completer.future;
 
+  @override
   bool update(QueueList<Result<T>> events, bool isDone) {
     while (_eventsToSkip > 0) {
       if (events.isEmpty) {
@@ -795,6 +798,7 @@
 class _TakeRequest<T> extends _ListRequest<T> {
   _TakeRequest(int eventsToTake) : super(eventsToTake);
 
+  @override
   bool update(QueueList<Result<T>> events, bool isDone) {
     while (_list.length < _eventsToTake) {
       if (events.isEmpty) {
@@ -818,6 +822,7 @@
 class _LookAheadRequest<T> extends _ListRequest<T> {
   _LookAheadRequest(int eventsToTake) : super(eventsToTake);
 
+  @override
   bool update(QueueList<Result<T>> events, bool isDone) {
     while (_list.length < _eventsToTake) {
       if (events.length == _list.length) {
@@ -855,6 +860,7 @@
   /// The future completed when the cancel request is completed.
   Future get future => _completer.future;
 
+  @override
   bool update(QueueList<Result<T>> events, bool isDone) {
     if (_streamQueue._isDone) {
       _completer.complete();
@@ -886,6 +892,7 @@
   /// The stream which will contain the remaining events of [_streamQueue].
   Stream<T> get stream => _completer.stream;
 
+  @override
   bool update(QueueList<Result<T>> events, bool isDone) {
     if (events.isEmpty) {
       if (_streamQueue._isDone) {
@@ -920,6 +927,7 @@
 
   Future<bool> get future => _completer.future;
 
+  @override
   bool update(QueueList<Result<T>> events, bool isDone) {
     if (events.isNotEmpty) {
       _completer.complete(true);
@@ -954,6 +962,7 @@
     _transaction = StreamQueueTransaction._(parent, _controller.stream);
   }
 
+  @override
   bool update(QueueList<Result<T>> events, bool isDone) {
     while (_eventsSent < events.length) {
       events[_eventsSent++].addTo(_controller);
diff --git a/lib/src/stream_sink_completer.dart b/lib/src/stream_sink_completer.dart
index c7fdd03..3b31576 100644
--- a/lib/src/stream_sink_completer.dart
+++ b/lib/src/stream_sink_completer.dart
@@ -59,7 +59,7 @@
   /// Trying to call either of them again will fail.
   void setDestinationSink(StreamSink<T> destinationSink) {
     if (_sink._destinationSink != null) {
-      throw StateError("Destination sink already set");
+      throw StateError('Destination sink already set');
     }
     _sink._setDestinationSink(destinationSink);
   }
@@ -98,6 +98,7 @@
   /// to going through [_controller].
   bool get _canSendDirectly => _controller == null && _destinationSink != null;
 
+  @override
   Future get done {
     if (_doneCompleter != null) return _doneCompleter.future;
     if (_destinationSink == null) {
@@ -107,6 +108,7 @@
     return _destinationSink.done;
   }
 
+  @override
   void add(T event) {
     if (_canSendDirectly) {
       _destinationSink.add(event);
@@ -116,6 +118,7 @@
     }
   }
 
+  @override
   void addError(error, [StackTrace stackTrace]) {
     if (_canSendDirectly) {
       _destinationSink.addError(error, stackTrace);
@@ -125,6 +128,7 @@
     }
   }
 
+  @override
   Future addStream(Stream<T> stream) {
     if (_canSendDirectly) return _destinationSink.addStream(stream);
 
@@ -132,6 +136,7 @@
     return _controller.addStream(stream, cancelOnError: false);
   }
 
+  @override
   Future close() {
     if (_canSendDirectly) {
       _destinationSink.close();
@@ -144,7 +149,7 @@
 
   /// Create [_controller] if it doesn't yet exist.
   void _ensureController() {
-    if (_controller == null) _controller = StreamController(sync: true);
+    _controller ??= StreamController(sync: true);
   }
 
   /// Sets the destination sink to which events from this sink will be provided.
diff --git a/lib/src/stream_sink_transformer.dart b/lib/src/stream_sink_transformer.dart
index b01132e..c50cf17 100644
--- a/lib/src/stream_sink_transformer.dart
+++ b/lib/src/stream_sink_transformer.dart
@@ -34,9 +34,9 @@
   /// they're passed are forwarded to the inner sink. If a handler is omitted,
   /// the event is passed through unaltered.
   factory StreamSinkTransformer.fromHandlers(
-      {void handleData(S data, EventSink<T> sink),
-      void handleError(Object error, StackTrace stackTrace, EventSink<T> sink),
-      void handleDone(EventSink<T> sink)}) {
+      {void Function(S, EventSink<T>) handleData,
+      void Function(Object, StackTrace, EventSink<T>) handleError,
+      void Function(EventSink<T>) handleDone}) {
     return HandlerTransformer<S, T>(handleData, handleError, handleDone);
   }
 
diff --git a/lib/src/stream_sink_transformer/handler_transformer.dart b/lib/src/stream_sink_transformer/handler_transformer.dart
index 3137003..8d37ce3 100644
--- a/lib/src/stream_sink_transformer/handler_transformer.dart
+++ b/lib/src/stream_sink_transformer/handler_transformer.dart
@@ -30,6 +30,7 @@
 
   HandlerTransformer(this._handleData, this._handleError, this._handleDone);
 
+  @override
   StreamSink<S> bind(StreamSink<T> sink) => _HandlerSink<S, T>(this, sink);
 }
 
@@ -45,12 +46,14 @@
   /// errors.
   final StreamSink<T> _safeCloseInner;
 
+  @override
   Future get done => _inner.done;
 
   _HandlerSink(this._transformer, StreamSink<T> inner)
       : _inner = inner,
         _safeCloseInner = _SafeCloseSink<T>(inner);
 
+  @override
   void add(S event) {
     if (_transformer._handleData == null) {
       _inner.add(event as T);
@@ -59,6 +62,7 @@
     }
   }
 
+  @override
   void addError(error, [StackTrace stackTrace]) {
     if (_transformer._handleError == null) {
       _inner.addError(error, stackTrace);
@@ -67,6 +71,7 @@
     }
   }
 
+  @override
   Future addStream(Stream<S> stream) {
     return _inner.addStream(stream.transform(
         StreamTransformer<S, T>.fromHandlers(
@@ -75,6 +80,7 @@
             handleDone: _closeSink)));
   }
 
+  @override
   Future close() {
     if (_transformer._handleDone == null) return _inner.close();
 
@@ -91,6 +97,7 @@
 class _SafeCloseSink<T> extends DelegatingStreamSink<T> {
   _SafeCloseSink(StreamSink<T> inner) : super(inner);
 
+  @override
   Future close() => super.close().catchError((_) {});
 }
 
diff --git a/lib/src/stream_sink_transformer/stream_transformer_wrapper.dart b/lib/src/stream_sink_transformer/stream_transformer_wrapper.dart
index 1010f9f..1df7e5a 100644
--- a/lib/src/stream_sink_transformer/stream_transformer_wrapper.dart
+++ b/lib/src/stream_sink_transformer/stream_transformer_wrapper.dart
@@ -13,6 +13,7 @@
 
   const StreamTransformerWrapper(this._transformer);
 
+  @override
   StreamSink<S> bind(StreamSink<T> sink) =>
       _StreamTransformerWrapperSink<S, T>(_transformer, sink);
 }
@@ -28,6 +29,7 @@
   /// The original sink that's being transformed.
   final StreamSink<T> _inner;
 
+  @override
   Future get done => _inner.done;
 
   _StreamTransformerWrapperSink(
@@ -42,16 +44,20 @@
     });
   }
 
+  @override
   void add(S event) {
     _controller.add(event);
   }
 
+  @override
   void addError(error, [StackTrace stackTrace]) {
     _controller.addError(error, stackTrace);
   }
 
+  @override
   Future addStream(Stream<S> stream) => _controller.addStream(stream);
 
+  @override
   Future close() {
     _controller.close();
     return _inner.done;
diff --git a/lib/src/stream_sink_transformer/typed.dart b/lib/src/stream_sink_transformer/typed.dart
index 303bc08..c27bd24 100644
--- a/lib/src/stream_sink_transformer/typed.dart
+++ b/lib/src/stream_sink_transformer/typed.dart
@@ -15,6 +15,7 @@
 
   TypeSafeStreamSinkTransformer(this._inner);
 
+  @override
   StreamSink<S> bind(StreamSink<T> sink) =>
       DelegatingStreamSink.typed(_inner.bind(sink));
 }
diff --git a/lib/src/stream_splitter.dart b/lib/src/stream_splitter.dart
index df0ff44..e9f326e 100644
--- a/lib/src/stream_splitter.dart
+++ b/lib/src/stream_splitter.dart
@@ -32,14 +32,14 @@
 
   /// The buffer of events or errors that have already been emitted by
   /// [_stream].
-  final _buffer = List<Result<T>>();
+  final _buffer = <Result<T>>[];
 
   /// The controllers for branches that are listening for future events from
   /// [_stream].
   ///
   /// Once a branch is canceled, it's removed from this list. When [_stream] is
   /// done, all branches are removed.
-  final _controllers = Set<StreamController<T>>();
+  final _controllers = <StreamController<T>>{};
 
   /// A group of futures returned by [close].
   ///
@@ -58,7 +58,7 @@
   /// [count] defaults to 2. This is the same as creating [count] branches and
   /// then closing the [StreamSplitter].
   static List<Stream<T>> splitFrom<T>(Stream<T> stream, [int count]) {
-    if (count == null) count = 2;
+    count ??= 2;
     var splitter = StreamSplitter<T>(stream);
     var streams = List<Stream<T>>.generate(count, (_) => splitter.split());
     splitter.close();
diff --git a/lib/src/stream_subscription_transformer.dart b/lib/src/stream_subscription_transformer.dart
index bee96a5..0e28972 100644
--- a/lib/src/stream_subscription_transformer.dart
+++ b/lib/src/stream_subscription_transformer.dart
@@ -28,9 +28,9 @@
 /// [StreamSubscription]: [handleCancel] must call `cancel()`, [handlePause]
 /// must call `pause()`, and [handleResume] must call `resume()`.
 StreamTransformer<T, T> subscriptionTransformer<T>(
-    {Future handleCancel(StreamSubscription<T> inner),
-    void handlePause(StreamSubscription<T> inner),
-    void handleResume(StreamSubscription<T> inner)}) {
+    {Future Function(StreamSubscription<T>) handleCancel,
+    void Function(StreamSubscription<T>) handlePause,
+    void Function(StreamSubscription<T>) handleResume}) {
   return StreamTransformer((stream, cancelOnError) {
     return _TransformedSubscription(
         stream.listen(null, cancelOnError: cancelOnError),
@@ -61,23 +61,28 @@
   /// The callback to run when [resume] is called.
   final _VoidHandler<T> _handleResume;
 
+  @override
   bool get isPaused => _inner?.isPaused ?? false;
 
   _TransformedSubscription(
       this._inner, this._handleCancel, this._handlePause, this._handleResume);
 
-  void onData(void handleData(T data)) {
+  @override
+  void onData(void Function(T) handleData) {
     _inner?.onData(handleData);
   }
 
+  @override
   void onError(Function handleError) {
     _inner?.onError(handleError);
   }
 
-  void onDone(void handleDone()) {
+  @override
+  void onDone(void Function() handleDone) {
     _inner?.onDone(handleDone);
   }
 
+  @override
   Future cancel() => _cancelMemoizer.runOnce(() {
         var inner = _inner;
         _inner.onData(null);
@@ -90,17 +95,20 @@
       });
   final _cancelMemoizer = AsyncMemoizer();
 
+  @override
   void pause([Future resumeFuture]) {
     if (_cancelMemoizer.hasRun) return;
     if (resumeFuture != null) resumeFuture.whenComplete(resume);
     _handlePause(_inner);
   }
 
+  @override
   void resume() {
     if (_cancelMemoizer.hasRun) return;
     _handleResume(_inner);
   }
 
+  @override
   Future<E> asFuture<E>([E futureValue]) =>
       _inner?.asFuture(futureValue) ?? Completer<E>().future;
 }
diff --git a/lib/src/stream_zip.dart b/lib/src/stream_zip.dart
index ef14c3e..e319746 100644
--- a/lib/src/stream_zip.dart
+++ b/lib/src/stream_zip.dart
@@ -2,7 +2,7 @@
 // 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 'dart:async';
 
 /// A stream that combines the values of other streams.
 ///
@@ -17,13 +17,14 @@
 
   StreamZip(Iterable<Stream<T>> streams) : _streams = streams;
 
-  StreamSubscription<List<T>> listen(void onData(List<T> data),
-      {Function onError, void onDone(), bool cancelOnError}) {
+  @override
+  StreamSubscription<List<T>> listen(void Function(List<T>) onData,
+      {Function onError, void Function() onDone, bool cancelOnError}) {
     cancelOnError = identical(true, cancelOnError);
     var subscriptions = <StreamSubscription<T>>[];
     StreamController<List<T>> controller;
     List<T> current;
-    int dataCount = 0;
+    var dataCount = 0;
 
     /// Called for each data from a subscription in [subscriptions].
     void handleData(int index, T data) {
@@ -33,7 +34,7 @@
         var data = current;
         current = List(subscriptions.length);
         dataCount = 0;
-        for (int i = 0; i < subscriptions.length; i++) {
+        for (var i = 0; i < subscriptions.length; i++) {
           if (i != index) subscriptions[i].resume();
         }
         controller.add(data);
@@ -54,14 +55,14 @@
     /// Prematurely cancels all subscriptions since we know that we won't
     /// be needing any more values.
     void handleErrorCancel(Object error, StackTrace stackTrace) {
-      for (int i = 0; i < subscriptions.length; i++) {
+      for (var i = 0; i < subscriptions.length; i++) {
         subscriptions[i].cancel();
       }
       controller.addError(error, stackTrace);
     }
 
     void handleDone() {
-      for (int i = 0; i < subscriptions.length; i++) {
+      for (var i = 0; i < subscriptions.length; i++) {
         subscriptions[i].cancel();
       }
       controller.close();
@@ -69,7 +70,7 @@
 
     try {
       for (var stream in _streams) {
-        int index = subscriptions.length;
+        var index = subscriptions.length;
         subscriptions.add(stream.listen((data) {
           handleData(index, data);
         },
@@ -78,7 +79,7 @@
             cancelOnError: cancelOnError));
       }
     } catch (e) {
-      for (int i = subscriptions.length - 1; i >= 0; i--) {
+      for (var i = subscriptions.length - 1; i >= 0; i--) {
         subscriptions[i].cancel();
       }
       rethrow;
@@ -87,18 +88,18 @@
     current = List(subscriptions.length);
 
     controller = StreamController<List<T>>(onPause: () {
-      for (int i = 0; i < subscriptions.length; i++) {
+      for (var i = 0; i < subscriptions.length; i++) {
         // This may pause some subscriptions more than once.
         // These will not be resumed by onResume below, but must wait for the
         // next round.
         subscriptions[i].pause();
       }
     }, onResume: () {
-      for (int i = 0; i < subscriptions.length; i++) {
+      for (var i = 0; i < subscriptions.length; i++) {
         subscriptions[i].resume();
       }
     }, onCancel: () {
-      for (int i = 0; i < subscriptions.length; i++) {
+      for (var i = 0; i < subscriptions.length; i++) {
         // Canceling more than once is safe.
         subscriptions[i].cancel();
       }
diff --git a/lib/src/subscription_stream.dart b/lib/src/subscription_stream.dart
index 347c346..b428619 100644
--- a/lib/src/subscription_stream.dart
+++ b/lib/src/subscription_stream.dart
@@ -4,7 +4,7 @@
 
 import 'dart:async';
 
-import "delegate/stream_subscription.dart";
+import 'delegate/stream_subscription.dart';
 
 /// A [Stream] adapter for a [StreamSubscription].
 ///
@@ -38,10 +38,11 @@
     _source.onDone(null);
   }
 
-  StreamSubscription<T> listen(void onData(T event),
-      {Function onError, void onDone(), bool cancelOnError}) {
+  @override
+  StreamSubscription<T> listen(void Function(T) onData,
+      {Function onError, void Function() onDone, bool cancelOnError}) {
     if (_source == null) {
-      throw StateError("Stream has already been listened to.");
+      throw StateError('Stream has already been listened to.');
     }
     cancelOnError = (true == cancelOnError);
     var subscription = _source;
@@ -69,6 +70,7 @@
   _CancelOnErrorSubscriptionWrapper(StreamSubscription<T> subscription)
       : super(subscription);
 
+  @override
   void onError(Function handleError) {
     // Cancel when receiving an error.
     super.onError((error, StackTrace stackTrace) {
diff --git a/lib/src/typed/stream_subscription.dart b/lib/src/typed/stream_subscription.dart
index 0fab039..d85b776 100644
--- a/lib/src/typed/stream_subscription.dart
+++ b/lib/src/typed/stream_subscription.dart
@@ -7,31 +7,39 @@
 class TypeSafeStreamSubscription<T> implements StreamSubscription<T> {
   final StreamSubscription _subscription;
 
+  @override
   bool get isPaused => _subscription.isPaused;
 
   TypeSafeStreamSubscription(this._subscription);
 
-  void onData(void handleData(T data)) {
+  @override
+  void onData(void Function(T) handleData) {
     _subscription.onData((data) => handleData(data as T));
   }
 
+  @override
   void onError(Function handleError) {
     _subscription.onError(handleError);
   }
 
-  void onDone(void handleDone()) {
+  @override
+  void onDone(void Function() handleDone) {
     _subscription.onDone(handleDone);
   }
 
+  @override
   void pause([Future resumeFuture]) {
     _subscription.pause(resumeFuture);
   }
 
+  @override
   void resume() {
     _subscription.resume();
   }
 
+  @override
   Future cancel() => _subscription.cancel();
 
+  @override
   Future<E> asFuture<E>([E futureValue]) => _subscription.asFuture(futureValue);
 }
diff --git a/lib/src/typed_stream_transformer.dart b/lib/src/typed_stream_transformer.dart
index 9750eb4..2366505 100644
--- a/lib/src/typed_stream_transformer.dart
+++ b/lib/src/typed_stream_transformer.dart
@@ -25,6 +25,7 @@
 
   _TypeSafeStreamTransformer(this._inner);
 
+  @override
   Stream<T> bind(Stream<S> stream) =>
       DelegatingStream.typed(_inner.bind(stream));
 }
diff --git a/pubspec.yaml b/pubspec.yaml
index f2439a8..e472203 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -6,7 +6,7 @@
 homepage: https://www.github.com/dart-lang/async
 
 environment:
-  sdk: '>=2.0.0 <3.0.0'
+  sdk: '>=2.2.0 <3.0.0'
 
 dependencies:
   collection: ^1.5.0
diff --git a/test/async_cache_test.dart b/test/async_cache_test.dart
index b7f7b8e..4efbb69 100644
--- a/test/async_cache_test.dart
+++ b/test/async_cache_test.dart
@@ -39,7 +39,7 @@
   test('should fetch via a callback again when cache expires', () {
     FakeAsync().run((fakeAsync) async {
       var timesCalled = 0;
-      call() async => 'Called ${++timesCalled}';
+      Future<String> call() async => 'Called ${++timesCalled}';
       expect(await cache.fetch(call), 'Called 1');
       expect(await cache.fetch(call), 'Called 1', reason: 'Cache still fresh');
 
@@ -57,7 +57,7 @@
 
   test('should fetch via a callback when manually invalidated', () async {
     var timesCalled = 0;
-    call() async => 'Called ${++timesCalled}';
+    Future<String> call() async => 'Called ${++timesCalled}';
     expect(await cache.fetch(call), 'Called 1');
     cache.invalidate();
     expect(await cache.fetch(call), 'Called 2');
diff --git a/test/async_memoizer_test.dart b/test/async_memoizer_test.dart
index 785f9a5..982f7c9 100644
--- a/test/async_memoizer_test.dart
+++ b/test/async_memoizer_test.dart
@@ -5,11 +5,11 @@
 import 'package:async/async.dart';
 import 'package:test/test.dart';
 
-main() {
+void main() {
   AsyncMemoizer cache;
   setUp(() => cache = AsyncMemoizer());
 
-  test("runs the function only the first time runOnce() is called", () async {
+  test('runs the function only the first time runOnce() is called', () async {
     var count = 0;
     expect(await cache.runOnce(() => count++), equals(0));
     expect(count, equals(1));
@@ -18,21 +18,21 @@
     expect(count, equals(1));
   });
 
-  test("forwards the return value from the function", () async {
-    expect(cache.future, completion(equals("value")));
-    expect(cache.runOnce(() => "value"), completion(equals("value")));
-    expect(cache.runOnce(() {}), completion(equals("value")));
+  test('forwards the return value from the function', () async {
+    expect(cache.future, completion(equals('value')));
+    expect(cache.runOnce(() => 'value'), completion(equals('value')));
+    expect(cache.runOnce(() {}), completion(equals('value')));
   });
 
-  test("forwards the return value from an async function", () async {
-    expect(cache.future, completion(equals("value")));
-    expect(cache.runOnce(() async => "value"), completion(equals("value")));
-    expect(cache.runOnce(() {}), completion(equals("value")));
+  test('forwards the return value from an async function', () async {
+    expect(cache.future, completion(equals('value')));
+    expect(cache.runOnce(() async => 'value'), completion(equals('value')));
+    expect(cache.runOnce(() {}), completion(equals('value')));
   });
 
-  test("forwards the error from an async function", () async {
-    expect(cache.future, throwsA("error"));
-    expect(cache.runOnce(() async => throw "error"), throwsA("error"));
-    expect(cache.runOnce(() {}), throwsA("error"));
+  test('forwards the error from an async function', () async {
+    expect(cache.future, throwsA('error'));
+    expect(cache.runOnce(() async => throw 'error'), throwsA('error'));
+    expect(cache.runOnce(() {}), throwsA('error'));
   });
 }
diff --git a/test/byte_collection_test.dart b/test/byte_collection_test.dart
index 24d218b..7f2ecc6 100644
--- a/test/byte_collection_test.dart
+++ b/test/byte_collection_test.dart
@@ -2,14 +2,14 @@
 // 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 'dart:async';
 
-import "package:test/test.dart";
-import "package:async/async.dart";
+import 'package:test/test.dart';
+import 'package:async/async.dart';
 
 void main() {
-  group("collectBytes", () {
-    test("simple list and overflow", () {
+  group('collectBytes', () {
+    test('simple list and overflow', () {
       var result = collectBytes(Stream.fromIterable([
         [0],
         [1],
@@ -19,25 +19,25 @@
       expect(result, completion([0, 1, 2, 0]));
     });
 
-    test("no events", () {
+    test('no events', () {
       var result = collectBytes(Stream.fromIterable([]));
       expect(result, completion([]));
     });
 
-    test("empty events", () {
+    test('empty events', () {
       var result = collectBytes(Stream.fromIterable([[], []]));
       expect(result, completion([]));
     });
 
-    test("error event", () {
+    test('error event', () {
       var result = collectBytes(Stream.fromIterable(
-          Iterable.generate(3, (n) => n == 2 ? throw "badness" : [n])));
-      expect(result, throwsA("badness"));
+          Iterable.generate(3, (n) => n == 2 ? throw 'badness' : [n])));
+      expect(result, throwsA('badness'));
     });
   });
 
-  group("collectBytes", () {
-    test("simple list and overflow", () {
+  group('collectBytes', () {
+    test('simple list and overflow', () {
       var result = collectBytesCancelable(Stream.fromIterable([
         [0],
         [1],
@@ -47,23 +47,23 @@
       expect(result.value, completion([0, 1, 2, 0]));
     });
 
-    test("no events", () {
+    test('no events', () {
       var result = collectBytesCancelable(Stream.fromIterable([]));
       expect(result.value, completion([]));
     });
 
-    test("empty events", () {
+    test('empty events', () {
       var result = collectBytesCancelable(Stream.fromIterable([[], []]));
       expect(result.value, completion([]));
     });
 
-    test("error event", () {
+    test('error event', () {
       var result = collectBytesCancelable(Stream.fromIterable(
-          Iterable.generate(3, (n) => n == 2 ? throw "badness" : [n])));
-      expect(result.value, throwsA("badness"));
+          Iterable.generate(3, (n) => n == 2 ? throw 'badness' : [n])));
+      expect(result.value, throwsA('badness'));
     });
 
-    test("cancelled", () async {
+    test('cancelled', () async {
       var sc = StreamController<List<int>>();
       var result = collectBytesCancelable(sc.stream);
       // Value never completes.
diff --git a/test/cancelable_operation_test.dart b/test/cancelable_operation_test.dart
index a47e952..b38c0b9 100644
--- a/test/cancelable_operation_test.dart
+++ b/test/cancelable_operation_test.dart
@@ -10,100 +10,100 @@
 import 'utils.dart';
 
 void main() {
-  group("without being canceled", () {
+  group('without being canceled', () {
     CancelableCompleter completer;
     setUp(() {
       completer = CancelableCompleter(onCancel: expectAsync0(() {}, count: 0));
     });
 
-    test("sends values to the future", () {
+    test('sends values to the future', () {
       expect(completer.operation.value, completion(equals(1)));
       expect(completer.isCompleted, isFalse);
       completer.complete(1);
       expect(completer.isCompleted, isTrue);
     });
 
-    test("sends errors to the future", () {
-      expect(completer.operation.value, throwsA("error"));
+    test('sends errors to the future', () {
+      expect(completer.operation.value, throwsA('error'));
       expect(completer.isCompleted, isFalse);
-      completer.completeError("error");
+      completer.completeError('error');
       expect(completer.isCompleted, isTrue);
     });
 
-    test("sends values in a future to the future", () {
+    test('sends values in a future to the future', () {
       expect(completer.operation.value, completion(equals(1)));
       expect(completer.isCompleted, isFalse);
       completer.complete(Future.value(1));
       expect(completer.isCompleted, isTrue);
     });
 
-    test("sends errors in a future to the future", () {
-      expect(completer.operation.value, throwsA("error"));
+    test('sends errors in a future to the future', () {
+      expect(completer.operation.value, throwsA('error'));
       expect(completer.isCompleted, isFalse);
       expect(completer.operation.isCompleted, isFalse);
-      completer.complete(Future.error("error"));
+      completer.complete(Future.error('error'));
       expect(completer.isCompleted, isTrue);
       expect(completer.operation.isCompleted, isTrue);
     });
 
-    test("sends values to valueOrCancellation", () {
+    test('sends values to valueOrCancellation', () {
       expect(completer.operation.valueOrCancellation(), completion(equals(1)));
       completer.complete(1);
     });
 
-    test("sends errors to valueOrCancellation", () {
-      expect(completer.operation.valueOrCancellation(), throwsA("error"));
-      completer.completeError("error");
+    test('sends errors to valueOrCancellation', () {
+      expect(completer.operation.valueOrCancellation(), throwsA('error'));
+      completer.completeError('error');
     });
 
-    group("throws a StateError if completed", () {
-      test("successfully twice", () {
+    group('throws a StateError if completed', () {
+      test('successfully twice', () {
         completer.complete(1);
         expect(() => completer.complete(1), throwsStateError);
       });
 
-      test("successfully then unsuccessfully", () {
+      test('successfully then unsuccessfully', () {
         completer.complete(1);
-        expect(() => completer.completeError("error"), throwsStateError);
+        expect(() => completer.completeError('error'), throwsStateError);
       });
 
-      test("unsuccessfully twice", () {
-        expect(completer.operation.value, throwsA("error"));
-        completer.completeError("error");
-        expect(() => completer.completeError("error"), throwsStateError);
+      test('unsuccessfully twice', () {
+        expect(completer.operation.value, throwsA('error'));
+        completer.completeError('error');
+        expect(() => completer.completeError('error'), throwsStateError);
       });
 
-      test("successfully then with a future", () {
+      test('successfully then with a future', () {
         completer.complete(1);
         expect(() => completer.complete(Completer().future), throwsStateError);
       });
 
-      test("with a future then successfully", () {
+      test('with a future then successfully', () {
         completer.complete(Completer().future);
         expect(() => completer.complete(1), throwsStateError);
       });
 
-      test("with a future twice", () {
+      test('with a future twice', () {
         completer.complete(Completer().future);
         expect(() => completer.complete(Completer().future), throwsStateError);
       });
     });
 
-    group("CancelableOperation.fromFuture", () {
-      test("forwards values", () {
+    group('CancelableOperation.fromFuture', () {
+      test('forwards values', () {
         var operation = CancelableOperation.fromFuture(Future.value(1));
         expect(operation.value, completion(equals(1)));
       });
 
-      test("forwards errors", () {
-        var operation = CancelableOperation.fromFuture(Future.error("error"));
-        expect(operation.value, throwsA("error"));
+      test('forwards errors', () {
+        var operation = CancelableOperation.fromFuture(Future.error('error'));
+        expect(operation.value, throwsA('error'));
       });
     });
   });
 
-  group("when canceled", () {
-    test("causes the future never to fire", () async {
+  group('when canceled', () {
+    test('causes the future never to fire', () async {
       var completer = CancelableCompleter();
       completer.operation.value.whenComplete(expectAsync0(() {}, count: 0));
       completer.operation.cancel();
@@ -114,7 +114,7 @@
       await flushMicrotasks();
     });
 
-    test("fires onCancel", () {
+    test('fires onCancel', () {
       var canceled = false;
       CancelableCompleter completer;
       completer = CancelableCompleter(onCancel: expectAsync0(() {
@@ -135,7 +135,7 @@
       expect(completer.operation.isCompleted, isFalse);
     });
 
-    test("returns the onCancel future each time cancel is called", () {
+    test('returns the onCancel future each time cancel is called', () {
       var completer = CancelableCompleter(onCancel: expectAsync0(() {
         return Future.value(1);
       }));
@@ -158,8 +158,8 @@
     });
 
     test(
-        "does call onCancel if the completer has completed to an unfired "
-        "Future", () {
+        'does call onCancel if the completer has completed to an unfired '
+        'Future', () {
       var completer = CancelableCompleter(onCancel: expectAsync0(() {}));
       completer.complete(Completer().future);
       expect(completer.operation.cancel(), completes);
@@ -167,7 +167,7 @@
 
     test(
         "doesn't call onCancel if the completer has completed to a fired "
-        "Future", () async {
+        'Future', () async {
       var completer =
           CancelableCompleter(onCancel: expectAsync0(() {}, count: 0));
       completer.complete(Future.value(1));
@@ -175,7 +175,7 @@
       expect(completer.operation.cancel(), completes);
     });
 
-    test("can be completed once after being canceled", () async {
+    test('can be completed once after being canceled', () async {
       var completer = CancelableCompleter();
       completer.operation.value.whenComplete(expectAsync0(() {}, count: 0));
       await completer.operation.cancel();
@@ -183,21 +183,21 @@
       expect(() => completer.complete(1), throwsStateError);
     });
 
-    test("fires valueOrCancellation with the given value", () {
+    test('fires valueOrCancellation with the given value', () {
       var completer = CancelableCompleter();
       expect(completer.operation.valueOrCancellation(1), completion(equals(1)));
       completer.operation.cancel();
     });
 
-    test("pipes an error through valueOrCancellation", () {
+    test('pipes an error through valueOrCancellation', () {
       var completer = CancelableCompleter(onCancel: () {
-        throw "error";
+        throw 'error';
       });
-      expect(completer.operation.valueOrCancellation(1), throwsA("error"));
+      expect(completer.operation.valueOrCancellation(1), throwsA('error'));
       completer.operation.cancel();
     });
 
-    test("valueOrCancellation waits on the onCancel future", () async {
+    test('valueOrCancellation waits on the onCancel future', () async {
       var innerCompleter = Completer();
       var completer =
           CancelableCompleter(onCancel: () => innerCompleter.future);
@@ -217,22 +217,22 @@
     });
   });
 
-  group("asStream()", () {
-    test("emits a value and then closes", () {
+  group('asStream()', () {
+    test('emits a value and then closes', () {
       var completer = CancelableCompleter();
       expect(completer.operation.asStream().toList(), completion(equals([1])));
       completer.complete(1);
     });
 
-    test("emits an error and then closes", () {
+    test('emits an error and then closes', () {
       var completer = CancelableCompleter();
       var queue = StreamQueue(completer.operation.asStream());
-      expect(queue.next, throwsA("error"));
+      expect(queue.next, throwsA('error'));
       expect(queue.hasNext, completion(isFalse));
-      completer.completeError("error");
+      completer.completeError('error');
     });
 
-    test("cancels the completer when the subscription is canceled", () {
+    test('cancels the completer when the subscription is canceled', () {
       var completer = CancelableCompleter(onCancel: expectAsync0(() {}));
       var sub =
           completer.operation.asStream().listen(expectAsync1((_) {}, count: 0));
@@ -242,7 +242,7 @@
     });
   });
 
-  group("then", () {
+  group('then', () {
     FutureOr<String> Function(int) onValue;
     FutureOr<String> Function(Object, StackTrace) onError;
     FutureOr<String> Function() onCancel;
@@ -251,9 +251,9 @@
 
     setUp(() {
       // Initialize all functions to ones that expect to not be called.
-      onValue = expectAsync1((_) => null, count: 0, id: "onValue");
-      onError = expectAsync2((e, s) => null, count: 0, id: "onError");
-      onCancel = expectAsync0(() => null, count: 0, id: "onCancel");
+      onValue = expectAsync1((_) => null, count: 0, id: 'onValue');
+      onError = expectAsync2((e, s) => null, count: 0, id: 'onError');
+      onCancel = expectAsync0(() => null, count: 0, id: 'onCancel');
       propagateCancel = false;
     });
 
@@ -265,31 +265,31 @@
           propagateCancel: propagateCancel);
     }
 
-    group("original operation completes successfully", () {
-      test("onValue completes successfully", () {
-        onValue = expectAsync1((v) => v.toString(), count: 1, id: "onValue");
+    group('original operation completes successfully', () {
+      test('onValue completes successfully', () {
+        onValue = expectAsync1((v) => v.toString(), count: 1, id: 'onValue');
 
-        expect(runThen().value, completion("1"));
+        expect(runThen().value, completion('1'));
         originalCompleter.complete(1);
       });
 
-      test("onValue throws error", () {
+      test('onValue throws error', () {
         // expectAsync1 only works with functions that do not throw.
-        onValue = (_) => throw "error";
+        onValue = (_) => throw 'error';
 
-        expect(runThen().value, throwsA("error"));
+        expect(runThen().value, throwsA('error'));
         originalCompleter.complete(1);
       });
 
-      test("onValue returns Future that throws error", () {
+      test('onValue returns Future that throws error', () {
         onValue =
-            expectAsync1((v) => Future.error("error"), count: 1, id: "onValue");
+            expectAsync1((v) => Future.error('error'), count: 1, id: 'onValue');
 
-        expect(runThen().value, throwsA("error"));
+        expect(runThen().value, throwsA('error'));
         originalCompleter.complete(1);
       });
 
-      test("and returned operation is canceled with propagateCancel = false",
+      test('and returned operation is canceled with propagateCancel = false',
           () async {
         propagateCancel = false;
 
@@ -300,51 +300,51 @@
       });
     });
 
-    group("original operation completes with error", () {
-      test("onError not set", () {
+    group('original operation completes with error', () {
+      test('onError not set', () {
         onError = null;
 
-        expect(runThen().value, throwsA("error"));
-        originalCompleter.completeError("error");
+        expect(runThen().value, throwsA('error'));
+        originalCompleter.completeError('error');
       });
 
-      test("onError completes successfully", () {
-        onError = expectAsync2((e, s) => "onError caught $e",
-            count: 1, id: "onError");
+      test('onError completes successfully', () {
+        onError = expectAsync2((e, s) => 'onError caught $e',
+            count: 1, id: 'onError');
 
-        expect(runThen().value, completion("onError caught error"));
-        originalCompleter.completeError("error");
+        expect(runThen().value, completion('onError caught error'));
+        originalCompleter.completeError('error');
       });
 
-      test("onError throws", () {
+      test('onError throws', () {
         // expectAsync2 does not work with functions that throw.
-        onError = (e, s) => throw "onError caught $e";
+        onError = (e, s) => throw 'onError caught $e';
 
-        expect(runThen().value, throwsA("onError caught error"));
-        originalCompleter.completeError("error");
+        expect(runThen().value, throwsA('onError caught error'));
+        originalCompleter.completeError('error');
       });
 
-      test("onError returns Future that throws", () {
-        onError = expectAsync2((e, s) => Future.error("onError caught $e"),
-            count: 1, id: "onError");
+      test('onError returns Future that throws', () {
+        onError = expectAsync2((e, s) => Future.error('onError caught $e'),
+            count: 1, id: 'onError');
 
-        expect(runThen().value, throwsA("onError caught error"));
-        originalCompleter.completeError("error");
+        expect(runThen().value, throwsA('onError caught error'));
+        originalCompleter.completeError('error');
       });
 
-      test("and returned operation is canceled with propagateCancel = false",
+      test('and returned operation is canceled with propagateCancel = false',
           () async {
         propagateCancel = false;
 
         runThen().cancel();
 
         // onError should not be called.
-        originalCompleter.completeError("error");
+        originalCompleter.completeError('error');
       });
     });
 
-    group("original operation canceled", () {
-      test("onCancel not set", () {
+    group('original operation canceled', () {
+      test('onCancel not set', () {
         onCancel = null;
 
         final operation = runThen();
@@ -353,32 +353,32 @@
         expect(operation.isCanceled, true);
       });
 
-      test("onCancel completes successfully", () {
-        onCancel = expectAsync0(() => "canceled", count: 1, id: "onCancel");
+      test('onCancel completes successfully', () {
+        onCancel = expectAsync0(() => 'canceled', count: 1, id: 'onCancel');
 
-        expect(runThen().value, completion("canceled"));
+        expect(runThen().value, completion('canceled'));
         originalCompleter.operation.cancel();
       });
 
-      test("onCancel throws error", () {
+      test('onCancel throws error', () {
         // expectAsync0 only works with functions that do not throw.
-        onCancel = () => throw "error";
+        onCancel = () => throw 'error';
 
-        expect(runThen().value, throwsA("error"));
+        expect(runThen().value, throwsA('error'));
         originalCompleter.operation.cancel();
       });
 
-      test("onCancel returns Future that throws error", () {
+      test('onCancel returns Future that throws error', () {
         onCancel =
-            expectAsync0(() => Future.error("error"), count: 1, id: "onCancel");
+            expectAsync0(() => Future.error('error'), count: 1, id: 'onCancel');
 
-        expect(runThen().value, throwsA("error"));
+        expect(runThen().value, throwsA('error'));
         originalCompleter.operation.cancel();
       });
     });
 
-    group("returned operation canceled", () {
-      test("propagateCancel is true", () async {
+    group('returned operation canceled', () {
+      test('propagateCancel is true', () async {
         propagateCancel = true;
 
         await runThen().cancel();
@@ -386,7 +386,7 @@
         expect(originalCompleter.isCanceled, true);
       });
 
-      test("propagateCancel is false", () async {
+      test('propagateCancel is false', () async {
         propagateCancel = false;
 
         await runThen().cancel();
diff --git a/test/future_group_test.dart b/test/future_group_test.dart
index 770a465..f99d06d 100644
--- a/test/future_group_test.dart
+++ b/test/future_group_test.dart
@@ -15,8 +15,8 @@
     futureGroup = FutureGroup();
   });
 
-  group("with no futures", () {
-    test("never completes if nothing happens", () async {
+  group('with no futures', () {
+    test('never completes if nothing happens', () async {
       var completed = false;
       futureGroup.future.then((_) => completed = true);
 
@@ -30,8 +30,8 @@
     });
   });
 
-  group("with a future that already completed", () {
-    test("never completes if nothing happens", () async {
+  group('with a future that already completed', () {
+    test('never completes if nothing happens', () async {
       futureGroup.add(Future.value());
       await flushMicrotasks();
 
@@ -57,12 +57,12 @@
     });
 
     test("completes to that future's error, even if it's not closed", () {
-      futureGroup.add(Future.error("error"));
-      expect(futureGroup.future, throwsA("error"));
+      futureGroup.add(Future.error('error'));
+      expect(futureGroup.future, throwsA('error'));
     });
   });
 
-  test("completes once all contained futures complete", () async {
+  test('completes once all contained futures complete', () async {
     var completer1 = Completer();
     var completer2 = Completer();
     var completer3 = Completer();
@@ -88,7 +88,7 @@
     expect(completed, isTrue);
   });
 
-  test("completes to the values of the futures in order of addition", () {
+  test('completes to the values of the futures in order of addition', () {
     var completer1 = Completer();
     var completer2 = Completer();
     var completer3 = Completer();
@@ -116,13 +116,13 @@
     futureGroup.add(completer2.future);
     futureGroup.add(completer3.future);
 
-    completer2.completeError("error 2");
-    completer1.completeError("error 1");
-    expect(futureGroup.future, throwsA("error 2"));
+    completer2.completeError('error 2');
+    completer1.completeError('error 1');
+    expect(futureGroup.future, throwsA('error 2'));
   });
 
-  group("onIdle:", () {
-    test("emits an event when the last pending future completes", () async {
+  group('onIdle:', () {
+    test('emits an event when the last pending future completes', () async {
       var idle = false;
       futureGroup.onIdle.listen((_) => idle = true);
 
@@ -154,7 +154,7 @@
       expect(futureGroup.isIdle, isTrue);
     });
 
-    test("emits an event each time it becomes idle", () async {
+    test('emits an event each time it becomes idle', () async {
       var idle = false;
       futureGroup.onIdle.listen((_) => idle = true);
 
@@ -180,7 +180,7 @@
       expect(futureGroup.isIdle, isTrue);
     });
 
-    test("emits an event when the group closes", () async {
+    test('emits an event when the group closes', () async {
       // It's important that the order of events here stays consistent over
       // time, since code may rely on it in subtle ways.
       var idle = false;
diff --git a/test/lazy_stream_test.dart b/test/lazy_stream_test.dart
index db1bc94..2affe5b 100644
--- a/test/lazy_stream_test.dart
+++ b/test/lazy_stream_test.dart
@@ -2,19 +2,19 @@
 // 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 'dart:async';
 
-import "package:async/async.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:test/test.dart';
 
-import "utils.dart";
+import 'utils.dart';
 
-main() {
-  test("disallows a null callback", () {
+void main() {
+  test('disallows a null callback', () {
     expect(() => LazyStream(null), throwsArgumentError);
   });
 
-  test("calls the callback when the stream is listened", () async {
+  test('calls the callback when the stream is listened', () async {
     var callbackCalled = false;
     var stream = LazyStream(expectAsync0(() {
       callbackCalled = true;
@@ -28,7 +28,7 @@
     expect(callbackCalled, isTrue);
   });
 
-  test("calls the callback when the stream is listened", () async {
+  test('calls the callback when the stream is listened', () async {
     var callbackCalled = false;
     var stream = LazyStream(expectAsync0(() {
       callbackCalled = true;
@@ -42,7 +42,7 @@
     expect(callbackCalled, isTrue);
   });
 
-  test("forwards to a synchronously-provided stream", () async {
+  test('forwards to a synchronously-provided stream', () async {
     var controller = StreamController<int>();
     var stream = LazyStream(expectAsync0(() => controller.stream));
 
@@ -64,7 +64,7 @@
     controller.close();
   });
 
-  test("forwards to an asynchronously-provided stream", () async {
+  test('forwards to an asynchronously-provided stream', () async {
     var controller = StreamController<int>();
     var stream = LazyStream(expectAsync0(() async => controller.stream));
 
diff --git a/test/null_stream_sink_test.dart b/test/null_stream_sink_test.dart
index 33e2655..649cbad 100644
--- a/test/null_stream_sink_test.dart
+++ b/test/null_stream_sink_test.dart
@@ -2,21 +2,21 @@
 // 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 'dart:async';
 
-import "package:async/async.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:test/test.dart';
 
-import "utils.dart";
+import 'utils.dart';
 
 void main() {
-  group("constructors", () {
-    test("done defaults to a completed future", () {
+  group('constructors', () {
+    test('done defaults to a completed future', () {
       var sink = NullStreamSink();
       expect(sink.done, completes);
     });
 
-    test("a custom future may be passed to done", () async {
+    test('a custom future may be passed to done', () async {
       var completer = Completer();
       var sink = NullStreamSink(done: completer.future);
 
@@ -32,30 +32,30 @@
       expect(doneFired, isTrue);
     });
 
-    test("NullStreamSink.error passes an error to done", () {
-      var sink = NullStreamSink.error("oh no");
-      expect(sink.done, throwsA("oh no"));
+    test('NullStreamSink.error passes an error to done', () {
+      var sink = NullStreamSink.error('oh no');
+      expect(sink.done, throwsA('oh no'));
     });
   });
 
-  group("events", () {
-    test("are silently dropped before close", () {
+  group('events', () {
+    test('are silently dropped before close', () {
       var sink = NullStreamSink();
       sink.add(1);
-      sink.addError("oh no");
+      sink.addError('oh no');
     });
 
-    test("throw StateErrors after close", () {
+    test('throw StateErrors after close', () {
       var sink = NullStreamSink();
       expect(sink.close(), completes);
 
       expect(() => sink.add(1), throwsStateError);
-      expect(() => sink.addError("oh no"), throwsStateError);
+      expect(() => sink.addError('oh no'), throwsStateError);
       expect(() => sink.addStream(Stream.empty()), throwsStateError);
     });
 
-    group("addStream", () {
-      test("listens to the stream then cancels immediately", () async {
+    group('addStream', () {
+      test('listens to the stream then cancels immediately', () async {
         var sink = NullStreamSink();
         var canceled = false;
         var controller = StreamController(onCancel: () {
@@ -67,7 +67,7 @@
         expect(canceled, isTrue);
       });
 
-      test("returns the cancel future", () async {
+      test('returns the cancel future', () async {
         var completer = Completer();
         var sink = NullStreamSink();
         var controller = StreamController(onCancel: () => completer.future);
@@ -84,30 +84,30 @@
         expect(addStreamFired, isTrue);
       });
 
-      test("pipes errors from the cancel future through addStream", () async {
+      test('pipes errors from the cancel future through addStream', () async {
         var sink = NullStreamSink();
-        var controller = StreamController(onCancel: () => throw "oh no");
-        expect(sink.addStream(controller.stream), throwsA("oh no"));
+        var controller = StreamController(onCancel: () => throw 'oh no');
+        expect(sink.addStream(controller.stream), throwsA('oh no'));
       });
 
-      test("causes events to throw StateErrors until the future completes",
+      test('causes events to throw StateErrors until the future completes',
           () async {
         var sink = NullStreamSink();
         var future = sink.addStream(Stream.empty());
         expect(() => sink.add(1), throwsStateError);
-        expect(() => sink.addError("oh no"), throwsStateError);
+        expect(() => sink.addError('oh no'), throwsStateError);
         expect(() => sink.addStream(Stream.empty()), throwsStateError);
 
         await future;
         sink.add(1);
-        sink.addError("oh no");
+        sink.addError('oh no');
         expect(sink.addStream(Stream.empty()), completes);
       });
     });
   });
 
-  test("close returns the done future", () {
-    var sink = NullStreamSink.error("oh no");
-    expect(sink.close(), throwsA("oh no"));
+  test('close returns the done future', () {
+    var sink = NullStreamSink.error('oh no');
+    expect(sink.close(), throwsA('oh no'));
   });
 }
diff --git a/test/restartable_timer_test.dart b/test/restartable_timer_test.dart
index c46c87b..41f52ab 100644
--- a/test/restartable_timer_test.dart
+++ b/test/restartable_timer_test.dart
@@ -6,8 +6,8 @@
 import 'package:fake_async/fake_async.dart';
 import 'package:test/test.dart';
 
-main() {
-  test("runs the callback once the duration has elapsed", () {
+void main() {
+  test('runs the callback once the duration has elapsed', () {
     FakeAsync().run((async) {
       var fired = false;
       RestartableTimer(Duration(seconds: 5), () {
@@ -38,7 +38,7 @@
     });
   });
 
-  test("resets the duration if the timer is reset before it fires", () {
+  test('resets the duration if the timer is reset before it fires', () {
     FakeAsync().run((async) {
       var fired = false;
       var timer = RestartableTimer(Duration(seconds: 5), () {
@@ -57,7 +57,7 @@
     });
   });
 
-  test("re-runs the callback if the timer is reset after firing", () {
+  test('re-runs the callback if the timer is reset after firing', () {
     FakeAsync().run((async) {
       var fired = 0;
       var timer = RestartableTimer(Duration(seconds: 5), () {
@@ -77,7 +77,7 @@
     });
   });
 
-  test("runs the callback if the timer is reset after being canceled", () {
+  test('runs the callback if the timer is reset after being canceled', () {
     FakeAsync().run((async) {
       var fired = false;
       var timer = RestartableTimer(Duration(seconds: 5), () {
diff --git a/test/result/result_captureAll_test.dart b/test/result/result_captureAll_test.dart
index c7b688f..ba8305a 100644
--- a/test/result/result_captureAll_test.dart
+++ b/test/result/result_captureAll_test.dart
@@ -2,62 +2,64 @@
 // 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 "dart:math" show Random;
-import "package:async/async.dart";
-import "package:test/test.dart";
+import 'dart:async';
+import 'dart:math' show Random;
+
+import 'package:async/async.dart';
+import 'package:test/test.dart';
 
 final someStack = StackTrace.current;
 Result<int> res(int n) => Result<int>.value(n);
-Result err(n) => ErrorResult("$n", someStack);
+Result err(n) => ErrorResult('$n', someStack);
 
 /// Helper function creating an iterable of futures.
-Iterable<Future<int>> futures(int count, {bool throwWhen(int index)}) sync* {
-  for (int i = 0; i < count; i++) {
+Iterable<Future<int>> futures(int count,
+    {bool Function(int index) throwWhen}) sync* {
+  for (var i = 0; i < count; i++) {
     if (throwWhen != null && throwWhen(i)) {
-      yield Future<int>.error("$i", someStack);
+      yield Future<int>.error('$i', someStack);
     } else {
       yield Future<int>.value(i);
     }
   }
 }
 
-main() {
-  test("empty", () async {
+void main() {
+  test('empty', () async {
     var all = await Result.captureAll<int>(futures(0));
     expect(all, []);
   });
 
-  group("futures only,", () {
-    test("single", () async {
+  group('futures only,', () {
+    test('single', () async {
       var all = await Result.captureAll<int>(futures(1));
       expect(all, [res(0)]);
     });
 
-    test("multiple", () async {
+    test('multiple', () async {
       var all = await Result.captureAll<int>(futures(3));
       expect(all, [res(0), res(1), res(2)]);
     });
 
-    test("error only", () async {
+    test('error only', () async {
       var all =
           await Result.captureAll<int>(futures(1, throwWhen: (_) => true));
       expect(all, [err(0)]);
     });
 
-    test("multiple error only", () async {
+    test('multiple error only', () async {
       var all =
           await Result.captureAll<int>(futures(3, throwWhen: (_) => true));
       expect(all, [err(0), err(1), err(2)]);
     });
 
-    test("mixed error and value", () async {
+    test('mixed error and value', () async {
       var all =
           await Result.captureAll<int>(futures(4, throwWhen: (x) => x.isOdd));
       expect(all, [res(0), err(1), res(2), err(3)]);
     });
 
-    test("completion permutation 1-2-3", () async {
+    test('completion permutation 1-2-3', () async {
       var cs = List.generate(3, (_) => Completer<int>());
       var all = Result.captureAll<int>(cs.map((c) => c.future));
       expect(all, completion([res(1), res(2), err(3)]));
@@ -66,22 +68,22 @@
       await 0;
       cs[1].complete(2);
       await 0;
-      cs[2].completeError("3", someStack);
+      cs[2].completeError('3', someStack);
     });
 
-    test("completion permutation 1-3-2", () async {
+    test('completion permutation 1-3-2', () async {
       var cs = List.generate(3, (_) => Completer<int>());
       var all = Result.captureAll<int>(cs.map((c) => c.future));
       expect(all, completion([res(1), res(2), err(3)]));
       await 0;
       cs[0].complete(1);
       await 0;
-      cs[2].completeError("3", someStack);
+      cs[2].completeError('3', someStack);
       await 0;
       cs[1].complete(2);
     });
 
-    test("completion permutation 2-1-3", () async {
+    test('completion permutation 2-1-3', () async {
       var cs = List.generate(3, (_) => Completer<int>());
       var all = Result.captureAll<int>(cs.map((c) => c.future));
       expect(all, completion([res(1), res(2), err(3)]));
@@ -90,39 +92,39 @@
       await 0;
       cs[0].complete(1);
       await 0;
-      cs[2].completeError("3", someStack);
+      cs[2].completeError('3', someStack);
     });
 
-    test("completion permutation 2-3-1", () async {
+    test('completion permutation 2-3-1', () async {
       var cs = List.generate(3, (_) => Completer<int>());
       var all = Result.captureAll<int>(cs.map((c) => c.future));
       expect(all, completion([res(1), res(2), err(3)]));
       await 0;
       cs[1].complete(2);
       await 0;
-      cs[2].completeError("3", someStack);
+      cs[2].completeError('3', someStack);
       await 0;
       cs[0].complete(1);
     });
 
-    test("completion permutation 3-1-2", () async {
+    test('completion permutation 3-1-2', () async {
       var cs = List.generate(3, (_) => Completer<int>());
       var all = Result.captureAll<int>(cs.map((c) => c.future));
       expect(all, completion([res(1), res(2), err(3)]));
       await 0;
-      cs[2].completeError("3", someStack);
+      cs[2].completeError('3', someStack);
       await 0;
       cs[0].complete(1);
       await 0;
       cs[1].complete(2);
     });
 
-    test("completion permutation 3-2-1", () async {
+    test('completion permutation 3-2-1', () async {
       var cs = List.generate(3, (_) => Completer<int>());
       var all = Result.captureAll<int>(cs.map((c) => c.future));
       expect(all, completion([res(1), res(2), err(3)]));
       await 0;
-      cs[2].completeError("3", someStack);
+      cs[2].completeError('3', someStack);
       await 0;
       cs[1].complete(2);
       await 0;
@@ -130,8 +132,8 @@
     });
 
     var seed = Random().nextInt(0x100000000);
-    int n = 25; // max 32, otherwise rnd.nextInt(1<<n) won't work.
-    test("randomized #$n seed:${seed.toRadixString(16)}", () async {
+    var n = 25; // max 32, otherwise rnd.nextInt(1<<n) won't work.
+    test('randomized #$n seed:${seed.toRadixString(16)}', () async {
       var cs = List.generate(n, (_) => Completer<int>());
       var all = Result.captureAll<int>(cs.map((c) => c.future));
       var rnd = Random(seed);
@@ -144,27 +146,27 @@
       var completeFunctions = List<Function()>.generate(n, (i) {
         var c = cs[i];
         return () =>
-            throws(i) ? c.completeError("$i", someStack) : c.complete(i);
+            throws(i) ? c.completeError('$i', someStack) : c.complete(i);
       });
       completeFunctions.shuffle(rnd);
-      for (int i = 0; i < n; i++) {
+      for (var i = 0; i < n; i++) {
         await 0;
         completeFunctions[i]();
       }
     });
   });
-  group("values only,", () {
-    test("single", () async {
+  group('values only,', () {
+    test('single', () async {
       var all = await Result.captureAll<int>(<int>[1]);
       expect(all, [res(1)]);
     });
-    test("multiple", () async {
+    test('multiple', () async {
       var all = await Result.captureAll<int>(<int>[1, 2, 3]);
       expect(all, [res(1), res(2), res(3)]);
     });
   });
-  group("mixed futures and values,", () {
-    test("no error", () async {
+  group('mixed futures and values,', () {
+    test('no error', () async {
       var all = await Result.captureAll<int>(<FutureOr<int>>[
         1,
         Future<int>(() => 2),
@@ -173,12 +175,12 @@
       ]);
       expect(all, [res(1), res(2), res(3), res(4)]);
     });
-    test("error", () async {
+    test('error', () async {
       var all = await Result.captureAll<int>(<FutureOr<int>>[
         1,
         Future<int>(() => 2),
         3,
-        Future<int>(() async => await Future.error("4", someStack)),
+        Future<int>(() async => await Future.error('4', someStack)),
         Future<int>.value(5)
       ]);
       expect(all, [res(1), res(2), res(3), err(4), res(5)]);
diff --git a/test/result/result_flattenAll_test.dart b/test/result/result_flattenAll_test.dart
index 4a049eb..890b2d0 100644
--- a/test/result/result_flattenAll_test.dart
+++ b/test/result/result_flattenAll_test.dart
@@ -2,16 +2,17 @@
 // 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 "package:async/async.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:test/test.dart';
 
 final someStack = StackTrace.current;
 Result<T> res<T>(T n) => Result<T>.value(n);
-Result err(n) => ErrorResult("$n", someStack);
+Result err(n) => ErrorResult('$n', someStack);
 
 /// Helper function creating an iterable of results.
-Iterable<Result<int>> results(int count, {bool throwWhen(int index)}) sync* {
-  for (int i = 0; i < count; i++) {
+Iterable<Result<int>> results(int count,
+    {bool Function(int index) throwWhen}) sync* {
+  for (var i = 0; i < count; i++) {
     if (throwWhen != null && throwWhen(i)) {
       yield err(i);
     } else {
@@ -20,8 +21,8 @@
   }
 }
 
-main() {
-  expectAll(result, expectation) {
+void main() {
+  void expectAll(result, expectation) {
     if (expectation.isError) {
       expect(result, expectation);
     } else {
@@ -30,24 +31,24 @@
     }
   }
 
-  test("empty", () {
+  test('empty', () {
     expectAll(Result.flattenAll<int>(results(0)), res([]));
   });
-  test("single value", () {
+  test('single value', () {
     expectAll(Result.flattenAll<int>(results(1)), res([0]));
   });
-  test("single error", () {
+  test('single error', () {
     expectAll(
         Result.flattenAll<int>(results(1, throwWhen: (_) => true)), err(0));
   });
-  test("multiple values", () {
+  test('multiple values', () {
     expectAll(Result.flattenAll<int>(results(5)), res([0, 1, 2, 3, 4]));
   });
-  test("multiple errors", () {
+  test('multiple errors', () {
     expectAll(Result.flattenAll<int>(results(5, throwWhen: (x) => x.isOdd)),
         err(1)); // First error is result.
   });
-  test("error last", () {
+  test('error last', () {
     expectAll(
         Result.flattenAll<int>(results(5, throwWhen: (x) => x == 4)), err(4));
   });
diff --git a/test/result/result_test.dart b/test/result/result_test.dart
index a33c1ba..92fc6b0 100644
--- a/test/result/result_test.dart
+++ b/test/result/result_test.dart
@@ -2,83 +2,83 @@
 // 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 "dart:collection";
+import 'dart:async';
+import 'dart:collection';
 
-import "package:async/async.dart";
-import "package:stack_trace/stack_trace.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:stack_trace/stack_trace.dart';
+import 'package:test/test.dart';
 
 void main() {
   var stack = Trace.current();
 
-  test("create result value", () {
-    Result<int> result = Result<int>.value(42);
+  test('create result value', () {
+    var result = Result<int>.value(42);
     expect(result.isValue, isTrue);
     expect(result.isError, isFalse);
     ValueResult value = result.asValue;
     expect(value.value, equals(42));
   });
 
-  test("create result value 2", () {
+  test('create result value 2', () {
     Result<int> result = ValueResult<int>(42);
     expect(result.isValue, isTrue);
     expect(result.isError, isFalse);
-    ValueResult<int> value = result.asValue;
+    var value = result.asValue;
     expect(value.value, equals(42));
   });
 
-  test("create result error", () {
-    Result<bool> result = Result<bool>.error("BAD", stack);
+  test('create result error', () {
+    var result = Result<bool>.error('BAD', stack);
     expect(result.isValue, isFalse);
     expect(result.isError, isTrue);
-    ErrorResult error = result.asError;
-    expect(error.error, equals("BAD"));
+    var error = result.asError;
+    expect(error.error, equals('BAD'));
     expect(error.stackTrace, same(stack));
   });
 
-  test("create result error 2", () {
-    Result<bool> result = ErrorResult("BAD", stack);
+  test('create result error 2', () {
+    var result = ErrorResult('BAD', stack);
     expect(result.isValue, isFalse);
     expect(result.isError, isTrue);
-    ErrorResult error = result.asError;
-    expect(error.error, equals("BAD"));
+    var error = result.asError;
+    expect(error.error, equals('BAD'));
     expect(error.stackTrace, same(stack));
   });
 
-  test("create result error no stack", () {
-    Result<bool> result = Result<bool>.error("BAD");
+  test('create result error no stack', () {
+    var result = Result<bool>.error('BAD');
     expect(result.isValue, isFalse);
     expect(result.isError, isTrue);
-    ErrorResult error = result.asError;
-    expect(error.error, equals("BAD"));
+    var error = result.asError;
+    expect(error.error, equals('BAD'));
     expect(error.stackTrace, isNull);
   });
 
-  test("complete with value", () {
+  test('complete with value', () {
     Result<int> result = ValueResult<int>(42);
     var c = Completer<int>();
     c.future.then(expectAsync1((int v) {
       expect(v, equals(42));
     }), onError: (e, s) {
-      fail("Unexpected error");
+      fail('Unexpected error');
     });
     result.complete(c);
   });
 
-  test("complete with error", () {
-    Result<bool> result = ErrorResult("BAD", stack);
+  test('complete with error', () {
+    Result<bool> result = ErrorResult('BAD', stack);
     var c = Completer<bool>();
     c.future.then((bool v) {
-      fail("Unexpected value $v");
+      fail('Unexpected value $v');
     }, onError: expectAsync2((e, s) {
-      expect(e, equals("BAD"));
+      expect(e, equals('BAD'));
       expect(s, same(stack));
     }));
     result.complete(c);
   });
 
-  test("add sink value", () {
+  test('add sink value', () {
     var result = ValueResult<int>(42);
     EventSink<int> sink = TestSink(onData: expectAsync1((v) {
       expect(v, equals(42));
@@ -86,97 +86,95 @@
     result.addTo(sink);
   });
 
-  test("add sink error", () {
-    Result<bool> result = ErrorResult("BAD", stack);
+  test('add sink error', () {
+    Result<bool> result = ErrorResult('BAD', stack);
     EventSink<bool> sink = TestSink(onError: expectAsync2((e, s) {
-      expect(e, equals("BAD"));
+      expect(e, equals('BAD'));
       expect(s, same(stack));
     }));
     result.addTo(sink);
   });
 
-  test("value as future", () {
+  test('value as future', () {
     Result<int> result = ValueResult<int>(42);
     result.asFuture.then(expectAsync1((int v) {
       expect(v, equals(42));
     }), onError: (e, s) {
-      fail("Unexpected error");
+      fail('Unexpected error');
     });
   });
 
-  test("error as future", () {
-    Result<bool> result = ErrorResult("BAD", stack);
+  test('error as future', () {
+    Result<bool> result = ErrorResult('BAD', stack);
     result.asFuture.then((bool v) {
-      fail("Unexpected value $v");
+      fail('Unexpected value $v');
     }, onError: expectAsync2((e, s) {
-      expect(e, equals("BAD"));
+      expect(e, equals('BAD'));
       expect(s, same(stack));
     }));
   });
 
-  test("capture future value", () {
-    Future<int> value = Future<int>.value(42);
+  test('capture future value', () {
+    var value = Future<int>.value(42);
     Result.capture(value).then(expectAsync1((Result result) {
       expect(result.isValue, isTrue);
       expect(result.isError, isFalse);
-      ValueResult value = result.asValue;
+      var value = result.asValue;
       expect(value.value, equals(42));
     }), onError: (e, s) {
-      fail("Unexpected error: $e");
+      fail('Unexpected error: $e');
     });
   });
 
-  test("capture future error", () {
-    Future<bool> value = Future<bool>.error("BAD", stack);
+  test('capture future error', () {
+    var value = Future<bool>.error('BAD', stack);
     Result.capture(value).then(expectAsync1((Result result) {
       expect(result.isValue, isFalse);
       expect(result.isError, isTrue);
-      ErrorResult error = result.asError;
-      expect(error.error, equals("BAD"));
+      var error = result.asError;
+      expect(error.error, equals('BAD'));
       expect(error.stackTrace, same(stack));
     }), onError: (e, s) {
-      fail("Unexpected error: $e");
+      fail('Unexpected error: $e');
     });
   });
 
-  test("release future value", () {
-    Future<Result<int>> future =
-        Future<Result<int>>.value(Result<int>.value(42));
+  test('release future value', () {
+    var future = Future<Result<int>>.value(Result<int>.value(42));
     Result.release(future).then(expectAsync1((v) {
       expect(v, equals(42));
     }), onError: (e, s) {
-      fail("Unexpected error: $e");
+      fail('Unexpected error: $e');
     });
   });
 
-  test("release future error", () {
+  test('release future error', () {
     // An error in the result is unwrapped and reified by release.
-    Future<Result<bool>> future =
-        Future<Result<bool>>.value(Result<bool>.error("BAD", stack));
+    var future = Future<Result<bool>>.value(Result<bool>.error('BAD', stack));
     Result.release(future).then((v) {
-      fail("Unexpected value: $v");
+      fail('Unexpected value: $v');
     }, onError: expectAsync2((e, s) {
-      expect(e, equals("BAD"));
+      expect(e, equals('BAD'));
       expect(s, same(stack));
     }));
   });
 
-  test("release future real error", () {
+  test('release future real error', () {
     // An error in the error lane is passed through by release.
-    Future<Result<bool>> future = Future<Result<bool>>.error("BAD", stack);
+    var future = Future<Result<bool>>.error('BAD', stack);
     Result.release(future).then((v) {
-      fail("Unexpected value: $v");
+      fail('Unexpected value: $v');
     }, onError: expectAsync2((e, s) {
-      expect(e, equals("BAD"));
+      expect(e, equals('BAD'));
       expect(s, same(stack));
     }));
   });
 
-  test("capture stream", () {
+  test('capture stream', () {
     var c = StreamController<int>();
     var stream = Result.captureStream(c.stream);
     var expectedList = Queue.from(
-        [Result.value(42), Result.error("BAD", stack), Result.value(37)]);
+        [Result.value(42), Result.error('BAD', stack), Result.value(37)]);
     void listener(Result actual) {
       expect(expectedList.isEmpty, isFalse);
       expectResult(actual, expectedList.removeFirst());
@@ -185,21 +183,21 @@
     stream.listen(expectAsync1(listener, count: 3),
         onDone: expectAsync0(() {}), cancelOnError: true);
     c.add(42);
-    c.addError("BAD", stack);
+    c.addError('BAD', stack);
     c.add(37);
     c.close();
   });
 
-  test("release stream", () {
-    StreamController<Result<int>> c = StreamController<Result<int>>();
-    Stream<int> stream = Result.releaseStream(c.stream);
+  test('release stream', () {
+    var c = StreamController<Result<int>>();
+    var stream = Result.releaseStream(c.stream);
     var events = [
       Result<int>.value(42),
-      Result<int>.error("BAD", stack),
+      Result<int>.error('BAD', stack),
       Result<int>.value(37)
     ];
     // Expect the data events, and an extra error event.
-    var expectedList = Queue.from(events)..add(Result.error("BAD2", stack));
+    var expectedList = Queue.from(events)..add(Result.error('BAD2', stack));
 
     void dataListener(int v) {
       expect(expectedList.isEmpty, isFalse);
@@ -219,95 +217,93 @@
     stream.listen(expectAsync1(dataListener, count: 2),
         onError: expectAsync2(errorListener, count: 2),
         onDone: expectAsync0(() {}));
-    for (Result<int> result in events) {
+    for (var result in events) {
       c.add(result); // Result value or error in data line.
     }
-    c.addError("BAD2", stack); // Error in error line.
+    c.addError('BAD2', stack); // Error in error line.
     c.close();
   });
 
-  test("release stream cancel on error", () {
-    StreamController<Result<int>> c = StreamController<Result<int>>();
-    Stream<int> stream = Result.releaseStream(c.stream);
+  test('release stream cancel on error', () {
+    var c = StreamController<Result<int>>();
+    var stream = Result.releaseStream(c.stream);
     stream.listen(expectAsync1((v) {
       expect(v, equals(42));
     }), onError: expectAsync2((e, s) {
-      expect(e, equals("BAD"));
+      expect(e, equals('BAD'));
       expect(s, same(stack));
     }), onDone: () {
-      fail("Unexpected done event");
+      fail('Unexpected done event');
     }, cancelOnError: true);
     c.add(Result.value(42));
-    c.add(Result.error("BAD", stack));
+    c.add(Result.error('BAD', stack));
     c.add(Result.value(37));
     c.close();
   });
 
-  test("flatten error 1", () {
-    Result<int> error = Result<int>.error("BAD", stack);
-    Result<int> flattened =
-        Result.flatten(Result<Result<int>>.error("BAD", stack));
+  test('flatten error 1', () {
+    var error = Result<int>.error('BAD', stack);
+    var flattened = Result.flatten(Result<Result<int>>.error('BAD', stack));
     expectResult(flattened, error);
   });
 
-  test("flatten error 2", () {
-    Result<int> error = Result<int>.error("BAD", stack);
-    Result<Result<int>> result = Result<Result<int>>.value(error);
-    Result<int> flattened = Result.flatten(result);
+  test('flatten error 2', () {
+    var error = Result<int>.error('BAD', stack);
+    var result = Result<Result<int>>.value(error);
+    var flattened = Result.flatten(result);
     expectResult(flattened, error);
   });
 
-  test("flatten value", () {
-    Result<Result<int>> result =
-        Result<Result<int>>.value(Result<int>.value(42));
+  test('flatten value', () {
+    var result = Result<Result<int>>.value(Result<int>.value(42));
     expectResult(Result.flatten(result), Result<int>.value(42));
   });
 
-  test("handle unary", () {
-    ErrorResult result = Result.error("error", stack);
-    bool called = false;
+  test('handle unary', () {
+    ErrorResult result = Result.error('error', stack);
+    var called = false;
     result.handle((error) {
       called = true;
-      expect(error, "error");
+      expect(error, 'error');
     });
     expect(called, isTrue);
   });
 
-  test("handle binary", () {
-    ErrorResult result = Result.error("error", stack);
-    bool called = false;
+  test('handle binary', () {
+    ErrorResult result = Result.error('error', stack);
+    var called = false;
     result.handle((error, stackTrace) {
       called = true;
-      expect(error, "error");
+      expect(error, 'error');
       expect(stackTrace, same(stack));
     });
     expect(called, isTrue);
   });
 
-  test("handle unary and binary", () {
-    ErrorResult result = Result.error("error", stack);
-    bool called = false;
+  test('handle unary and binary', () {
+    ErrorResult result = Result.error('error', stack);
+    var called = false;
     result.handle((error, [stackTrace]) {
       called = true;
-      expect(error, "error");
+      expect(error, 'error');
       expect(stackTrace, same(stack));
     });
     expect(called, isTrue);
   });
 
-  test("handle neither unary nor binary", () {
-    ErrorResult result = Result.error("error", stack);
-    expect(() => result.handle(() => fail("unreachable")), throwsA(anything));
-    expect(() => result.handle((a, b, c) => fail("unreachable")),
+  test('handle neither unary nor binary', () {
+    ErrorResult result = Result.error('error', stack);
+    expect(() => result.handle(() => fail('unreachable')), throwsA(anything));
+    expect(() => result.handle((a, b, c) => fail('unreachable')),
         throwsA(anything));
-    expect(() => result.handle((a, b, {c}) => fail("unreachable")),
+    expect(() => result.handle((a, b, {c}) => fail('unreachable')),
         throwsA(anything));
-    expect(() => result.handle((a, {b}) => fail("unreachable")),
+    expect(() => result.handle((a, {b}) => fail('unreachable')),
         throwsA(anything));
-    expect(() => result.handle(({a, b}) => fail("unreachable")),
+    expect(() => result.handle(({a, b}) => fail('unreachable')),
         throwsA(anything));
     expect(
-        () => result.handle(({a}) => fail("unreachable")), throwsA(anything));
+        () => result.handle(({a}) => fail('unreachable')), throwsA(anything));
   });
 }
 
@@ -323,36 +319,39 @@
 }
 
 class TestSink<T> implements EventSink<T> {
-  final Function onData;
-  final Function onError;
-  final Function onDone;
+  final void Function(T) onData;
+  final void Function(dynamic, StackTrace) onError;
+  final void Function() onDone;
 
   TestSink(
-      {void this.onData(T data) = _nullData,
-      void this.onError(e, StackTrace s) = _nullError,
-      void this.onDone() = _nullDone});
+      {this.onData = _nullData,
+      this.onError = _nullError,
+      this.onDone = _nullDone});
 
+  @override
   void add(T value) {
     onData(value);
   }
 
+  @override
   void addError(error, [StackTrace stack]) {
     onError(error, stack);
   }
 
+  @override
   void close() {
     onDone();
   }
 
   static void _nullData(value) {
-    fail("Unexpected sink add: $value");
+    fail('Unexpected sink add: $value');
   }
 
   static void _nullError(e, StackTrace s) {
-    fail("Unexpected sink addError: $e");
+    fail('Unexpected sink addError: $e');
   }
 
   static void _nullDone() {
-    fail("Unepxected sink close");
+    fail('Unepxected sink close');
   }
 }
diff --git a/test/stream_completer_test.dart b/test/stream_completer_test.dart
index fb1f4a5..2cf6728 100644
--- a/test/stream_completer_test.dart
+++ b/test/stream_completer_test.dart
@@ -2,21 +2,21 @@
 // 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 'dart:async';
 
-import "package:async/async.dart" show StreamCompleter;
-import "package:test/test.dart";
+import 'package:async/async.dart' show StreamCompleter;
+import 'package:test/test.dart';
 
-import "utils.dart";
+import 'utils.dart';
 
-main() {
-  test("a stream is linked before listening", () async {
+void main() {
+  test('a stream is linked before listening', () async {
     var completer = StreamCompleter();
     completer.setSourceStream(createStream());
     expect(completer.stream.toList(), completion([1, 2, 3, 4]));
   });
 
-  test("listened to before a stream is linked", () async {
+  test('listened to before a stream is linked', () async {
     var completer = StreamCompleter();
     var done = completer.stream.toList();
     await flushMicrotasks();
@@ -32,7 +32,7 @@
     completer.setSourceStream(UnusableStream()); // Doesn't throw.
   });
 
-  test("listen and pause before linking stream", () async {
+  test('listen and pause before linking stream', () async {
     var controller = StreamCompleter();
     var events = [];
     var subscription = controller.stream.listen(events.add);
@@ -55,7 +55,7 @@
     expect(events, [1, 2, 3, 4]);
   });
 
-  test("pause more than once", () async {
+  test('pause more than once', () async {
     var completer = StreamCompleter();
     var events = [];
     var subscription = completer.stream.listen(events.add);
@@ -64,7 +64,7 @@
     subscription.pause();
     subscription.pause();
     completer.setSourceStream(createStream());
-    for (int i = 0; i < 3; i++) {
+    for (var i = 0; i < 3; i++) {
       await flushMicrotasks();
       expect(events, []);
       subscription.resume();
@@ -73,7 +73,7 @@
     expect(events, [1, 2, 3, 4]);
   });
 
-  test("cancel new stream before source is done", () async {
+  test('cancel new stream before source is done', () async {
     var completer = StreamCompleter();
     var lastEvent = -1;
     var controller = StreamController();
@@ -85,8 +85,8 @@
         subscription.cancel();
       }
     },
-        onError: unreachable("error"),
-        onDone: unreachable("done"),
+        onError: unreachable('error'),
+        onDone: unreachable('done'),
         cancelOnError: true);
     completer.setSourceStream(controller.stream);
     expect(controller.hasListener, isTrue);
@@ -105,20 +105,20 @@
     expect(controller.hasListener, isFalse);
   });
 
-  test("complete with setEmpty before listening", () async {
+  test('complete with setEmpty before listening', () async {
     var completer = StreamCompleter();
     completer.setEmpty();
     var done = Completer();
-    completer.stream.listen(unreachable("data"),
-        onError: unreachable("error"), onDone: done.complete);
+    completer.stream.listen(unreachable('data'),
+        onError: unreachable('error'), onDone: done.complete);
     await done.future;
   });
 
-  test("complete with setEmpty after listening", () async {
+  test('complete with setEmpty after listening', () async {
     var completer = StreamCompleter();
     var done = Completer();
-    completer.stream.listen(unreachable("data"),
-        onError: unreachable("error"), onDone: done.complete);
+    completer.stream.listen(unreachable('data'),
+        onError: unreachable('error'), onDone: done.complete);
     completer.setEmpty();
     await done.future;
   });
@@ -138,7 +138,7 @@
     await subscription.asFuture();
   });
 
-  test("cancelOnError true when listening before linking stream", () async {
+  test('cancelOnError true when listening before linking stream', () async {
     var completer = StreamCompleter();
     Object lastEvent = -1;
     var controller = StreamController();
@@ -146,9 +146,9 @@
       expect(value, lessThan(3));
       lastEvent = value;
     }, onError: (value) {
-      expect(value, "3");
+      expect(value, '3');
       lastEvent = value;
-    }, onDone: unreachable("done"), cancelOnError: true);
+    }, onDone: unreachable('done'), cancelOnError: true);
     completer.setSourceStream(controller.stream);
     expect(controller.hasListener, isTrue);
 
@@ -164,14 +164,14 @@
     await flushMicrotasks();
     expect(lastEvent, 2);
     expect(controller.hasListener, isTrue);
-    controller.addError("3");
+    controller.addError('3');
 
     await flushMicrotasks();
-    expect(lastEvent, "3");
+    expect(lastEvent, '3');
     expect(controller.hasListener, isFalse);
   });
 
-  test("cancelOnError true when listening after linking stream", () async {
+  test('cancelOnError true when listening after linking stream', () async {
     var completer = StreamCompleter();
     Object lastEvent = -1;
     var controller = StreamController();
@@ -183,9 +183,9 @@
       expect(value, lessThan(3));
       lastEvent = value;
     }, onError: (value) {
-      expect(value, "3");
+      expect(value, '3');
       lastEvent = value;
-    }, onDone: unreachable("done"), cancelOnError: true);
+    }, onDone: unreachable('done'), cancelOnError: true);
 
     expect(controller.hasListener, isTrue);
 
@@ -197,13 +197,13 @@
     await flushMicrotasks();
     expect(lastEvent, 2);
     expect(controller.hasListener, isTrue);
-    controller.addError("3");
+    controller.addError('3');
 
     await flushMicrotasks();
     expect(controller.hasListener, isFalse);
   });
 
-  test("linking a stream after setSourceStream before listen", () async {
+  test('linking a stream after setSourceStream before listen', () async {
     var completer = StreamCompleter();
     completer.setSourceStream(createStream());
     expect(() => completer.setSourceStream(createStream()), throwsStateError);
@@ -214,7 +214,7 @@
     expect(() => completer.setEmpty(), throwsStateError);
   });
 
-  test("linking a stream after setSourceStream after listen", () async {
+  test('linking a stream after setSourceStream after listen', () async {
     var completer = StreamCompleter();
     var list = completer.stream.toList();
     completer.setSourceStream(createStream());
@@ -226,7 +226,7 @@
     expect(() => completer.setEmpty(), throwsStateError);
   });
 
-  test("linking a stream after setEmpty before listen", () async {
+  test('linking a stream after setEmpty before listen', () async {
     var completer = StreamCompleter();
     completer.setEmpty();
     expect(() => completer.setSourceStream(createStream()), throwsStateError);
@@ -237,7 +237,7 @@
     expect(() => completer.setEmpty(), throwsStateError);
   });
 
-  test("linking a stream after setEmpty() after listen", () async {
+  test('linking a stream after setEmpty() after listen', () async {
     var completer = StreamCompleter();
     var list = completer.stream.toList();
     completer.setEmpty();
@@ -249,7 +249,7 @@
     expect(() => completer.setEmpty(), throwsStateError);
   });
 
-  test("listening more than once after setting stream", () async {
+  test('listening more than once after setting stream', () async {
     var completer = StreamCompleter();
     completer.setSourceStream(createStream());
     var list = completer.stream.toList();
@@ -258,19 +258,19 @@
     expect(() => completer.stream.toList(), throwsStateError);
   });
 
-  test("listening more than once before setting stream", () async {
+  test('listening more than once before setting stream', () async {
     var completer = StreamCompleter();
     completer.stream.toList();
     expect(() => completer.stream.toList(), throwsStateError);
   });
 
-  test("setting onData etc. before and after setting stream", () async {
+  test('setting onData etc. before and after setting stream', () async {
     var completer = StreamCompleter();
     var controller = StreamController();
     var subscription = completer.stream.listen(null);
     Object lastEvent = 0;
     subscription.onData((value) => lastEvent = value);
-    subscription.onError((value) => lastEvent = "$value");
+    subscription.onError((value) => lastEvent = '$value');
     subscription.onDone(() => lastEvent = -1);
     completer.setSourceStream(controller.stream);
     await flushMicrotasks();
@@ -279,24 +279,24 @@
     expect(lastEvent, 1);
     controller.addError(2);
     await flushMicrotasks();
-    expect(lastEvent, "2");
+    expect(lastEvent, '2');
     subscription.onData((value) => lastEvent = -value);
-    subscription.onError((value) => lastEvent = "${-value}");
+    subscription.onError((value) => lastEvent = '${-value}');
     controller.add(1);
     await flushMicrotasks();
     expect(lastEvent, -1);
     controller.addError(2);
     await flushMicrotasks();
-    expect(lastEvent, "-2");
+    expect(lastEvent, '-2');
     controller.close();
     await flushMicrotasks();
     expect(lastEvent, -1);
   });
 
-  test("pause w/ resume future accross setting stream", () async {
+  test('pause w/ resume future accross setting stream', () async {
     var completer = StreamCompleter();
     var resume = Completer();
-    var subscription = completer.stream.listen(unreachable("data"));
+    var subscription = completer.stream.listen(unreachable('data'));
     subscription.pause(resume.future);
     await flushMicrotasks();
     completer.setSourceStream(createStream());
@@ -308,43 +308,43 @@
     expect(events, [1, 2, 3, 4]);
   });
 
-  test("asFuture with error accross setting stream", () async {
+  test('asFuture with error accross setting stream', () async {
     var completer = StreamCompleter();
     var controller = StreamController();
     var subscription =
-        completer.stream.listen(unreachable("data"), cancelOnError: false);
+        completer.stream.listen(unreachable('data'), cancelOnError: false);
     var done = subscription.asFuture();
     expect(controller.hasListener, isFalse);
     completer.setSourceStream(controller.stream);
     await flushMicrotasks();
     expect(controller.hasListener, isTrue);
     controller.addError(42);
-    await done.then(unreachable("data"), onError: (error) {
+    await done.then(unreachable('data'), onError: (error) {
       expect(error, 42);
     });
     expect(controller.hasListener, isFalse);
   });
 
-  group("setError()", () {
-    test("produces a stream that emits a single error", () {
+  group('setError()', () {
+    test('produces a stream that emits a single error', () {
       var completer = StreamCompleter();
-      completer.stream.listen(unreachable("data"),
+      completer.stream.listen(unreachable('data'),
           onError: expectAsync2((error, stackTrace) {
-        expect(error, equals("oh no"));
+        expect(error, equals('oh no'));
       }), onDone: expectAsync0(() {}));
 
-      completer.setError("oh no");
+      completer.setError('oh no');
     });
 
-    test("produces a stream that emits a single error on a later listen",
+    test('produces a stream that emits a single error on a later listen',
         () async {
       var completer = StreamCompleter();
-      completer.setError("oh no");
+      completer.setError('oh no');
       await flushMicrotasks();
 
-      completer.stream.listen(unreachable("data"),
+      completer.stream.listen(unreachable('data'),
           onError: expectAsync2((error, stackTrace) {
-        expect(error, equals("oh no"));
+        expect(error, equals('oh no'));
       }), onDone: expectAsync0(() {}));
     });
   });
diff --git a/test/stream_group_test.dart b/test/stream_group_test.dart
index 799d998..690fbc1 100644
--- a/test/stream_group_test.dart
+++ b/test/stream_group_test.dart
@@ -7,22 +7,22 @@
 import 'package:async/async.dart';
 import 'package:test/test.dart';
 
-main() {
-  group("single-subscription", () {
+void main() {
+  group('single-subscription', () {
     StreamGroup<String> streamGroup;
     setUp(() {
       streamGroup = StreamGroup<String>();
     });
 
-    test("buffers events from multiple sources", () async {
+    test('buffers events from multiple sources', () async {
       var controller1 = StreamController<String>();
       streamGroup.add(controller1.stream);
-      controller1.add("first");
+      controller1.add('first');
       controller1.close();
 
       var controller2 = StreamController<String>();
       streamGroup.add(controller2.stream);
-      controller2.add("second");
+      controller2.add('second');
       controller2.close();
 
       await flushMicrotasks();
@@ -30,18 +30,18 @@
       expect(streamGroup.close(), completes);
 
       expect(streamGroup.stream.toList(),
-          completion(unorderedEquals(["first", "second"])));
+          completion(unorderedEquals(['first', 'second'])));
     });
 
-    test("buffers errors from multiple sources", () async {
+    test('buffers errors from multiple sources', () async {
       var controller1 = StreamController<String>();
       streamGroup.add(controller1.stream);
-      controller1.addError("first");
+      controller1.addError('first');
       controller1.close();
 
       var controller2 = StreamController<String>();
       streamGroup.add(controller2.stream);
-      controller2.addError("second");
+      controller2.addError('second');
       controller2.close();
 
       await flushMicrotasks();
@@ -50,21 +50,21 @@
 
       var transformed = streamGroup.stream.transform(
           StreamTransformer<String, String>.fromHandlers(
-              handleError: (error, _, sink) => sink.add("error: $error")));
+              handleError: (error, _, sink) => sink.add('error: $error')));
       expect(transformed.toList(),
-          completion(equals(["error: first", "error: second"])));
+          completion(equals(['error: first', 'error: second'])));
     });
 
-    test("buffers events and errors together", () async {
+    test('buffers events and errors together', () async {
       var controller = StreamController<String>();
       streamGroup.add(controller.stream);
 
-      controller.add("first");
-      controller.addError("second");
-      controller.add("third");
-      controller.addError("fourth");
-      controller.addError("fifth");
-      controller.add("sixth");
+      controller.add('first');
+      controller.addError('second');
+      controller.add('third');
+      controller.addError('fourth');
+      controller.addError('fifth');
+      controller.add('sixth');
       controller.close();
 
       await flushMicrotasks();
@@ -73,17 +73,17 @@
 
       var transformed = streamGroup.stream.transform(
           StreamTransformer<String, String>.fromHandlers(
-              handleData: (data, sink) => sink.add("data: $data"),
-              handleError: (error, _, sink) => sink.add("error: $error")));
+              handleData: (data, sink) => sink.add('data: $data'),
+              handleError: (error, _, sink) => sink.add('error: $error')));
       expect(
           transformed.toList(),
           completion(equals([
-            "data: first",
-            "error: second",
-            "data: third",
-            "error: fourth",
-            "error: fifth",
-            "data: sixth"
+            'data: first',
+            'error: second',
+            'data: third',
+            'error: fourth',
+            'error: fifth',
+            'data: sixth'
           ])));
     });
 
@@ -92,10 +92,10 @@
       streamGroup.add(controller.stream);
 
       expect(
-          streamGroup.stream.toList(), completion(equals(["first", "second"])));
+          streamGroup.stream.toList(), completion(equals(['first', 'second'])));
 
-      controller.add("first");
-      controller.add("second");
+      controller.add('first');
+      controller.add('second');
       controller.close();
 
       expect(streamGroup.close(), completes);
@@ -105,8 +105,8 @@
       var controller = StreamController<String>.broadcast();
       streamGroup.add(controller.stream);
 
-      controller.add("first");
-      controller.add("second");
+      controller.add('first');
+      controller.add('second');
       controller.close();
 
       await flushMicrotasks();
@@ -115,7 +115,7 @@
       expect(streamGroup.stream.toList(), completion(isEmpty));
     });
 
-    test("when paused, buffers events from a broadcast stream", () async {
+    test('when paused, buffers events from a broadcast stream', () async {
       var controller = StreamController<String>.broadcast();
       streamGroup.add(controller.stream);
 
@@ -123,8 +123,8 @@
       var subscription = streamGroup.stream.listen(events.add);
       subscription.pause();
 
-      controller.add("first");
-      controller.add("second");
+      controller.add('first');
+      controller.add('second');
       controller.close();
       await flushMicrotasks();
 
@@ -132,7 +132,7 @@
       expect(streamGroup.close(), completes);
       await flushMicrotasks();
 
-      expect(events, equals(["first", "second"]));
+      expect(events, equals(['first', 'second']));
     });
 
     test("emits events from a broadcast stream once there's a listener", () {
@@ -140,26 +140,26 @@
       streamGroup.add(controller.stream);
 
       expect(
-          streamGroup.stream.toList(), completion(equals(["first", "second"])));
+          streamGroup.stream.toList(), completion(equals(['first', 'second'])));
 
-      controller.add("first");
-      controller.add("second");
+      controller.add('first');
+      controller.add('second');
       controller.close();
 
       expect(streamGroup.close(), completes);
     });
 
-    test("forwards cancel errors", () async {
+    test('forwards cancel errors', () async {
       var subscription = streamGroup.stream.listen(null);
 
-      var controller = StreamController<String>(onCancel: () => throw "error");
+      var controller = StreamController<String>(onCancel: () => throw 'error');
       streamGroup.add(controller.stream);
       await flushMicrotasks();
 
-      expect(subscription.cancel(), throwsA("error"));
+      expect(subscription.cancel(), throwsA('error'));
     });
 
-    test("forwards a cancel future", () async {
+    test('forwards a cancel future', () async {
       var subscription = streamGroup.stream.listen(null);
 
       var completer = Completer();
@@ -180,8 +180,8 @@
     });
 
     test(
-        "add() while active pauses the stream if the group is paused, then "
-        "resumes once the group resumes", () async {
+        'add() while active pauses the stream if the group is paused, then '
+        'resumes once the group resumes', () async {
       var subscription = streamGroup.stream.listen(null);
       await flushMicrotasks();
 
@@ -201,13 +201,13 @@
       expect(paused, isFalse);
     });
 
-    group("add() while canceled", () {
+    group('add() while canceled', () {
       setUp(() async {
         streamGroup.stream.listen(null).cancel();
         await flushMicrotasks();
       });
 
-      test("immediately listens to and cancels the stream", () async {
+      test('immediately listens to and cancels the stream', () async {
         var listened = false;
         var canceled = false;
         var controller = StreamController<String>(onListen: () {
@@ -223,14 +223,14 @@
         expect(canceled, isTrue);
       });
 
-      test("forwards cancel errors", () {
+      test('forwards cancel errors', () {
         var controller =
-            StreamController<String>(onCancel: () => throw "error");
+            StreamController<String>(onCancel: () => throw 'error');
 
-        expect(streamGroup.add(controller.stream), throwsA("error"));
+        expect(streamGroup.add(controller.stream), throwsA('error'));
       });
 
-      test("forwards a cancel future", () async {
+      test('forwards a cancel future', () async {
         var completer = Completer();
         var controller =
             StreamController<String>(onCancel: () => completer.future);
@@ -248,21 +248,21 @@
     });
   });
 
-  group("broadcast", () {
+  group('broadcast', () {
     StreamGroup<String> streamGroup;
     setUp(() {
       streamGroup = StreamGroup<String>.broadcast();
     });
 
-    test("buffers events from multiple sources", () async {
+    test('buffers events from multiple sources', () async {
       var controller1 = StreamController<String>();
       streamGroup.add(controller1.stream);
-      controller1.add("first");
+      controller1.add('first');
       controller1.close();
 
       var controller2 = StreamController<String>();
       streamGroup.add(controller2.stream);
-      controller2.add("second");
+      controller2.add('second');
       controller2.close();
 
       await flushMicrotasks();
@@ -270,7 +270,7 @@
       expect(streamGroup.close(), completes);
 
       expect(
-          streamGroup.stream.toList(), completion(equals(["first", "second"])));
+          streamGroup.stream.toList(), completion(equals(['first', 'second'])));
     });
 
     test("emits events from multiple sources once there's a listener", () {
@@ -281,10 +281,10 @@
       streamGroup.add(controller2.stream);
 
       expect(
-          streamGroup.stream.toList(), completion(equals(["first", "second"])));
+          streamGroup.stream.toList(), completion(equals(['first', 'second'])));
 
-      controller1.add("first");
-      controller2.add("second");
+      controller1.add('first');
+      controller2.add('second');
       controller1.close();
       controller2.close();
 
@@ -299,8 +299,8 @@
       streamGroup.stream.listen(null).cancel();
       await flushMicrotasks();
 
-      controller.add("first");
-      controller.addError("second");
+      controller.add('first');
+      controller.addError('second');
       controller.close();
 
       await flushMicrotasks();
@@ -312,8 +312,8 @@
     test("doesn't buffer events from a broadcast stream", () async {
       var controller = StreamController<String>.broadcast();
       streamGroup.add(controller.stream);
-      controller.add("first");
-      controller.addError("second");
+      controller.add('first');
+      controller.addError('second');
       controller.close();
 
       await flushMicrotasks();
@@ -327,16 +327,16 @@
       streamGroup.add(controller.stream);
 
       expect(
-          streamGroup.stream.toList(), completion(equals(["first", "second"])));
+          streamGroup.stream.toList(), completion(equals(['first', 'second'])));
 
-      controller.add("first");
-      controller.add("second");
+      controller.add('first');
+      controller.add('second');
       controller.close();
 
       expect(streamGroup.close(), completes);
     });
 
-    test("cancels and re-listens broadcast streams", () async {
+    test('cancels and re-listens broadcast streams', () async {
       var subscription = streamGroup.stream.listen(null);
 
       var controller = StreamController<String>.broadcast();
@@ -354,7 +354,7 @@
       expect(controller.hasListener, isTrue);
     });
 
-    test("never cancels single-subscription streams", () async {
+    test('never cancels single-subscription streams', () async {
       var subscription = streamGroup.stream.listen(null);
 
       var controller =
@@ -370,7 +370,7 @@
       await flushMicrotasks();
     });
 
-    test("drops events from a single-subscription stream while dormant",
+    test('drops events from a single-subscription stream while dormant',
         () async {
       var events = [];
       var subscription = streamGroup.stream.listen(events.add);
@@ -379,22 +379,22 @@
       streamGroup.add(controller.stream);
       await flushMicrotasks();
 
-      controller.add("first");
+      controller.add('first');
       await flushMicrotasks();
-      expect(events, equals(["first"]));
+      expect(events, equals(['first']));
 
       subscription.cancel();
-      controller.add("second");
+      controller.add('second');
       await flushMicrotasks();
-      expect(events, equals(["first"]));
+      expect(events, equals(['first']));
 
       streamGroup.stream.listen(events.add);
-      controller.add("third");
+      controller.add('third');
       await flushMicrotasks();
-      expect(events, equals(["first", "third"]));
+      expect(events, equals(['first', 'third']));
     });
 
-    test("a single-subscription stream can be removed while dormant", () async {
+    test('a single-subscription stream can be removed while dormant', () async {
       var controller = StreamController<String>();
       streamGroup.add(controller.stream);
       await flushMicrotasks();
@@ -407,61 +407,61 @@
       await flushMicrotasks();
 
       expect(streamGroup.stream.toList(), completion(isEmpty));
-      controller.add("first");
+      controller.add('first');
       expect(streamGroup.close(), completes);
     });
   });
 
-  group("regardless of type", () {
-    group("single-subscription", () {
+  group('regardless of type', () {
+    group('single-subscription', () {
       regardlessOfType(() => StreamGroup<String>());
     });
 
-    group("broadcast", () {
+    group('broadcast', () {
       regardlessOfType(() => StreamGroup<String>.broadcast());
     });
   });
 
-  test("merge() emits events from all components streams", () async {
+  test('merge() emits events from all components streams', () async {
     var controller1 = StreamController<String>();
     var controller2 = StreamController<String>();
 
     var merged = StreamGroup.merge([controller1.stream, controller2.stream]);
 
-    controller1.add("first");
+    controller1.add('first');
     controller1.close();
-    controller2.add("second");
+    controller2.add('second');
     controller2.close();
 
-    expect(await merged.toList(), ["first", "second"]);
+    expect(await merged.toList(), ['first', 'second']);
   });
 
-  test("mergeBroadcast() emits events from all components streams", () async {
+  test('mergeBroadcast() emits events from all components streams', () async {
     var controller1 = StreamController<String>();
     var controller2 = StreamController<String>();
 
     var merged =
         StreamGroup.mergeBroadcast([controller1.stream, controller2.stream]);
 
-    controller1.add("first");
+    controller1.add('first');
     controller1.close();
-    controller2.add("second");
+    controller2.add('second');
     controller2.close();
 
     expect(merged.isBroadcast, isTrue);
 
-    expect(await merged.toList(), ["first", "second"]);
+    expect(await merged.toList(), ['first', 'second']);
   });
 }
 
-void regardlessOfType(StreamGroup<String> newStreamGroup()) {
+void regardlessOfType(StreamGroup<String> Function() newStreamGroup) {
   StreamGroup<String> streamGroup;
   setUp(() {
     streamGroup = newStreamGroup();
   });
 
-  group("add()", () {
-    group("while dormant", () {
+  group('add()', () {
+    group('while dormant', () {
       test("doesn't listen to the stream until the group is listened to",
           () async {
         var controller = StreamController<String>();
@@ -475,7 +475,7 @@
         expect(controller.hasListener, isTrue);
       });
 
-      test("is a no-op if the stream is already in the group", () {
+      test('is a no-op if the stream is already in the group', () {
         var controller = StreamController<String>();
         streamGroup.add(controller.stream);
         streamGroup.add(controller.stream);
@@ -487,13 +487,13 @@
       });
     });
 
-    group("while active", () {
+    group('while active', () {
       setUp(() async {
         streamGroup.stream.listen(null);
         await flushMicrotasks();
       });
 
-      test("listens to the stream immediately", () async {
+      test('listens to the stream immediately', () async {
         var controller = StreamController<String>();
 
         expect(streamGroup.add(controller.stream), isNull);
@@ -501,7 +501,7 @@
         expect(controller.hasListener, isTrue);
       });
 
-      test("is a no-op if the stream is already in the group", () async {
+      test('is a no-op if the stream is already in the group', () async {
         var controller = StreamController<String>();
 
         // If the stream were actually listened to more than once, future
@@ -513,28 +513,28 @@
     });
   });
 
-  group("remove()", () {
-    group("while dormant", () {
+  group('remove()', () {
+    group('while dormant', () {
       test("stops emitting events for a stream that's removed", () async {
         var controller = StreamController<String>();
         streamGroup.add(controller.stream);
 
-        expect(streamGroup.stream.toList(), completion(equals(["first"])));
+        expect(streamGroup.stream.toList(), completion(equals(['first'])));
 
-        controller.add("first");
+        controller.add('first');
         await flushMicrotasks();
-        controller.add("second");
+        controller.add('second');
 
         expect(streamGroup.remove(controller.stream), completion(null));
         expect(streamGroup.close(), completes);
       });
 
-      test("is a no-op for an unknown stream", () {
+      test('is a no-op for an unknown stream', () {
         var controller = StreamController<String>();
         expect(streamGroup.remove(controller.stream), isNull);
       });
 
-      test("and closed closes the group when the last stream is removed",
+      test('and closed closes the group when the last stream is removed',
           () async {
         var controller1 = StreamController<String>();
         var controller2 = StreamController<String>();
@@ -555,7 +555,7 @@
       });
     });
 
-    group("while listening", () {
+    group('while listening', () {
       test("doesn't emit events from a removed stream", () {
         var controller = StreamController<String>();
         streamGroup.add(controller.stream);
@@ -565,9 +565,9 @@
         // removal. This is documented in [StreamGroup.remove].
         expect(streamGroup.stream.toList(), completion(isEmpty));
 
-        controller.add("first");
+        controller.add('first');
         expect(streamGroup.remove(controller.stream), completion(null));
-        controller.add("second");
+        controller.add('second');
 
         expect(streamGroup.close(), completes);
       });
@@ -585,18 +585,18 @@
         expect(controller.hasListener, isFalse);
       });
 
-      test("forwards cancel errors", () async {
+      test('forwards cancel errors', () async {
         var controller =
-            StreamController<String>(onCancel: () => throw "error");
+            StreamController<String>(onCancel: () => throw 'error');
         streamGroup.add(controller.stream);
 
         streamGroup.stream.listen(null);
         await flushMicrotasks();
 
-        expect(streamGroup.remove(controller.stream), throwsA("error"));
+        expect(streamGroup.remove(controller.stream), throwsA('error'));
       });
 
-      test("forwards cancel futures", () async {
+      test('forwards cancel futures', () async {
         var completer = Completer();
         var controller =
             StreamController<String>(onCancel: () => completer.future);
@@ -618,7 +618,7 @@
         expect(fired, isTrue);
       });
 
-      test("is a no-op for an unknown stream", () async {
+      test('is a no-op for an unknown stream', () async {
         var controller = StreamController<String>();
         streamGroup.stream.listen(null);
         await flushMicrotasks();
@@ -626,7 +626,7 @@
         expect(streamGroup.remove(controller.stream), isNull);
       });
 
-      test("and closed closes the group when the last stream is removed",
+      test('and closed closes the group when the last stream is removed',
           () async {
         var done = false;
         streamGroup.stream.listen(null, onDone: () => done = true);
@@ -652,15 +652,15 @@
     });
   });
 
-  group("close()", () {
-    group("while dormant", () {
-      test("if there are no streams, closes the group", () {
+  group('close()', () {
+    group('while dormant', () {
+      test('if there are no streams, closes the group', () {
         expect(streamGroup.close(), completes);
         expect(streamGroup.stream.toList(), completion(isEmpty));
       });
 
       test(
-          "if there are streams, closes the group once those streams close "
+          'if there are streams, closes the group once those streams close '
           "and there's a listener", () async {
         var controller1 = StreamController<String>();
         var controller2 = StreamController<String>();
@@ -677,13 +677,13 @@
       });
     });
 
-    group("while active", () {
-      test("if there are no streams, closes the group", () {
+    group('while active', () {
+      test('if there are no streams, closes the group', () {
         expect(streamGroup.stream.toList(), completion(isEmpty));
         expect(streamGroup.close(), completes);
       });
 
-      test("if there are streams, closes the group once those streams close",
+      test('if there are streams, closes the group once those streams close',
           () async {
         var done = false;
         streamGroup.stream.listen(null, onDone: () => done = true);
@@ -710,7 +710,7 @@
       });
     });
 
-    test("returns a Future that completes once all events are dispatched",
+    test('returns a Future that completes once all events are dispatched',
         () async {
       var events = [];
       streamGroup.stream.listen(events.add);
@@ -722,16 +722,16 @@
       // Add a bunch of events. Each of these will get dispatched in a
       // separate microtask, so we can test that [close] only completes once
       // all of them have dispatched.
-      controller.add("one");
-      controller.add("two");
-      controller.add("three");
-      controller.add("four");
-      controller.add("five");
-      controller.add("six");
+      controller.add('one');
+      controller.add('two');
+      controller.add('three');
+      controller.add('four');
+      controller.add('five');
+      controller.add('six');
       controller.close();
 
       await streamGroup.close();
-      expect(events, equals(["one", "two", "three", "four", "five", "six"]));
+      expect(events, equals(['one', 'two', 'three', 'four', 'five', 'six']));
     });
   });
 }
diff --git a/test/stream_queue_test.dart b/test/stream_queue_test.dart
index b2a8625..fa286a8 100644
--- a/test/stream_queue_test.dart
+++ b/test/stream_queue_test.dart
@@ -2,16 +2,16 @@
 // 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 'dart:async';
 
-import "package:async/async.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:test/test.dart';
 
-import "utils.dart";
+import 'utils.dart';
 
-main() {
-  group("source stream", () {
-    test("is listened to on first request, paused between requests", () async {
+void main() {
+  group('source stream', () {
+    test('is listened to on first request, paused between requests', () async {
       var controller = StreamController<int>();
       var events = StreamQueue<int>(controller.stream);
       await flushMicrotasks();
@@ -42,8 +42,8 @@
     });
   });
 
-  group("eventsDispatched", () {
-    test("increments after a next future completes", () async {
+  group('eventsDispatched', () {
+    test('increments after a next future completes', () async {
       var events = StreamQueue<int>(createStream());
 
       expect(events.eventsDispatched, equals(0));
@@ -60,13 +60,13 @@
       expect(events.eventsDispatched, equals(2));
     });
 
-    test("increments multiple times for multi-value requests", () async {
+    test('increments multiple times for multi-value requests', () async {
       var events = StreamQueue<int>(createStream());
       await events.take(3);
       expect(events.eventsDispatched, equals(3));
     });
 
-    test("increments multiple times for an accepted transaction", () async {
+    test('increments multiple times for an accepted transaction', () async {
       var events = StreamQueue<int>(createStream());
       await events.withTransaction((queue) async {
         await queue.next;
@@ -83,8 +83,8 @@
     });
   });
 
-  group("lookAhead operation", () {
-    test("as simple list of events", () async {
+  group('lookAhead operation', () {
+    test('as simple list of events', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.lookAhead(4), [1, 2, 3, 4]);
       expect(await events.next, 1);
@@ -94,7 +94,7 @@
       await events.cancel();
     });
 
-    test("of 0 events", () async {
+    test('of 0 events', () async {
       var events = StreamQueue<int>(createStream());
       expect(events.lookAhead(0), completion([]));
       expect(events.next, completion(1));
@@ -110,7 +110,7 @@
       await events.cancel();
     });
 
-    test("with bad arguments throws", () async {
+    test('with bad arguments throws', () async {
       var events = StreamQueue<int>(createStream());
       expect(() => events.lookAhead(-1), throwsArgumentError);
       expect(await events.next, 1); // Did not consume event.
@@ -119,13 +119,13 @@
       await events.cancel();
     });
 
-    test("of too many arguments", () async {
+    test('of too many arguments', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.lookAhead(6), [1, 2, 3, 4]);
       await events.cancel();
     });
 
-    test("too large later", () async {
+    test('too large later', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
@@ -133,25 +133,25 @@
       await events.cancel();
     });
 
-    test("error", () async {
+    test('error', () async {
       var events = StreamQueue<int>(createErrorStream());
-      expect(events.lookAhead(4), throwsA("To err is divine!"));
-      expect(events.take(4), throwsA("To err is divine!"));
+      expect(events.lookAhead(4), throwsA('To err is divine!'));
+      expect(events.take(4), throwsA('To err is divine!'));
       expect(await events.next, 4);
       await events.cancel();
     });
   });
 
-  group("next operation", () {
-    test("simple sequence of requests", () async {
+  group('next operation', () {
+    test('simple sequence of requests', () async {
       var events = StreamQueue<int>(createStream());
-      for (int i = 1; i <= 4; i++) {
+      for (var i = 1; i <= 4; i++) {
         expect(await events.next, i);
       }
       expect(events.next, throwsStateError);
     });
 
-    test("multiple requests at the same time", () async {
+    test('multiple requests at the same time', () async {
       var events = StreamQueue<int>(createStream());
       var result = await Future.wait(
           [events.next, events.next, events.next, events.next]);
@@ -159,18 +159,18 @@
       await events.cancel();
     });
 
-    test("sequence of requests with error", () async {
+    test('sequence of requests with error', () async {
       var events = StreamQueue<int>(createErrorStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
-      expect(events.next, throwsA("To err is divine!"));
+      expect(events.next, throwsA('To err is divine!'));
       expect(await events.next, 4);
       await events.cancel();
     });
   });
 
-  group("skip operation", () {
-    test("of two elements in the middle of sequence", () async {
+  group('skip operation', () {
+    test('of two elements in the middle of sequence', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.skip(2), 0);
@@ -178,7 +178,7 @@
       await events.cancel();
     });
 
-    test("with negative/bad arguments throws", () async {
+    test('with negative/bad arguments throws', () async {
       var events = StreamQueue<int>(createStream());
       expect(() => events.skip(-1), throwsArgumentError);
       // A non-int throws either a type error or an argument error,
@@ -189,7 +189,7 @@
       await events.cancel();
     });
 
-    test("of 0 elements works", () async {
+    test('of 0 elements works', () async {
       var events = StreamQueue<int>(createStream());
       expect(events.skip(0), completion(0));
       expect(events.next, completion(1));
@@ -205,13 +205,13 @@
       await events.cancel();
     });
 
-    test("of too many events ends at stream start", () async {
+    test('of too many events ends at stream start', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.skip(6), 2);
       await events.cancel();
     });
 
-    test("of too many events after some events", () async {
+    test('of too many events after some events', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
@@ -219,7 +219,7 @@
       await events.cancel();
     });
 
-    test("of too many events ends at stream end", () async {
+    test('of too many events ends at stream end', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
@@ -229,20 +229,20 @@
       await events.cancel();
     });
 
-    test("of events with error", () async {
+    test('of events with error', () async {
       var events = StreamQueue<int>(createErrorStream());
-      expect(events.skip(4), throwsA("To err is divine!"));
+      expect(events.skip(4), throwsA('To err is divine!'));
       expect(await events.next, 4);
       await events.cancel();
     });
 
-    test("of events with error, and skip again after", () async {
+    test('of events with error, and skip again after', () async {
       var events = StreamQueue<int>(createErrorStream());
-      expect(events.skip(4), throwsA("To err is divine!"));
+      expect(events.skip(4), throwsA('To err is divine!'));
       expect(events.skip(2), completion(1));
       await events.cancel();
     });
-    test("multiple skips at same time complete in order.", () async {
+    test('multiple skips at same time complete in order.', () async {
       var events = StreamQueue<int>(createStream());
       var skip1 = events.skip(1);
       var skip2 = events.skip(0);
@@ -266,8 +266,8 @@
     });
   });
 
-  group("take operation", () {
-    test("as simple take of events", () async {
+  group('take operation', () {
+    test('as simple take of events', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.take(2), [2, 3]);
@@ -275,7 +275,7 @@
       await events.cancel();
     });
 
-    test("of 0 events", () async {
+    test('of 0 events', () async {
       var events = StreamQueue<int>(createStream());
       expect(events.take(0), completion([]));
       expect(events.next, completion(1));
@@ -291,7 +291,7 @@
       await events.cancel();
     });
 
-    test("with bad arguments throws", () async {
+    test('with bad arguments throws', () async {
       var events = StreamQueue<int>(createStream());
       expect(() => events.take(-1), throwsArgumentError);
       expect(await events.next, 1); // Did not consume event.
@@ -300,13 +300,13 @@
       await events.cancel();
     });
 
-    test("of too many arguments", () async {
+    test('of too many arguments', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.take(6), [1, 2, 3, 4]);
       await events.cancel();
     });
 
-    test("too large later", () async {
+    test('too large later', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
@@ -314,27 +314,27 @@
       await events.cancel();
     });
 
-    test("error", () async {
+    test('error', () async {
       var events = StreamQueue<int>(createErrorStream());
-      expect(events.take(4), throwsA("To err is divine!"));
+      expect(events.take(4), throwsA('To err is divine!'));
       expect(await events.next, 4);
       await events.cancel();
     });
   });
 
-  group("rest operation", () {
-    test("after single next", () async {
+  group('rest operation', () {
+    test('after single next', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.rest.toList(), [2, 3, 4]);
     });
 
-    test("at start", () async {
+    test('at start', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.rest.toList(), [1, 2, 3, 4]);
     });
 
-    test("at end", () async {
+    test('at end', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
@@ -343,7 +343,7 @@
       expect(await events.rest.toList(), isEmpty);
     });
 
-    test("after end", () async {
+    test('after end', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
@@ -353,13 +353,13 @@
       expect(await events.rest.toList(), isEmpty);
     });
 
-    test("after receiving done requested before", () async {
+    test('after receiving done requested before', () async {
       var events = StreamQueue<int>(createStream());
       var next1 = events.next;
       var next2 = events.next;
       var next3 = events.next;
       var rest = events.rest;
-      for (int i = 0; i < 10; i++) {
+      for (var i = 0; i < 10; i++) {
         await flushMicrotasks();
       }
       expect(await next1, 1);
@@ -368,17 +368,17 @@
       expect(await rest.toList(), [4]);
     });
 
-    test("with an error event error", () async {
+    test('with an error event error', () async {
       var events = StreamQueue<int>(createErrorStream());
       expect(await events.next, 1);
       var rest = events.rest;
       var events2 = StreamQueue(rest);
       expect(await events2.next, 2);
-      expect(events2.next, throwsA("To err is divine!"));
+      expect(events2.next, throwsA('To err is divine!'));
       expect(await events2.next, 4);
     });
 
-    test("closes the events, prevents other operations", () async {
+    test('closes the events, prevents other operations', () async {
       var events = StreamQueue<int>(createStream());
       var stream = events.rest;
       expect(() => events.next, throwsStateError);
@@ -389,7 +389,7 @@
       expect(stream.toList(), completion([1, 2, 3, 4]));
     });
 
-    test("forwards to underlying stream", () async {
+    test('forwards to underlying stream', () async {
       var cancel = Completer();
       var controller = StreamController<int>(onCancel: () => cancel.future);
       var events = StreamQueue<int>(controller.stream);
@@ -436,8 +436,8 @@
     });
   });
 
-  group("peek operation", () {
-    test("peeks one event", () async {
+  group('peek operation', () {
+    test('peeks one event', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.peek, 1);
       expect(await events.next, 1);
@@ -449,28 +449,28 @@
       expect(events.peek, throwsA(anything));
       await events.cancel();
     });
-    test("multiple requests at the same time", () async {
+    test('multiple requests at the same time', () async {
       var events = StreamQueue<int>(createStream());
       var result = await Future.wait(
           [events.peek, events.peek, events.next, events.peek, events.peek]);
       expect(result, [1, 1, 1, 2, 2]);
       await events.cancel();
     });
-    test("sequence of requests with error", () async {
+    test('sequence of requests with error', () async {
       var events = StreamQueue<int>(createErrorStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
-      expect(events.peek, throwsA("To err is divine!"));
+      expect(events.peek, throwsA('To err is divine!'));
       // Error stays in queue.
-      expect(events.peek, throwsA("To err is divine!"));
-      expect(events.next, throwsA("To err is divine!"));
+      expect(events.peek, throwsA('To err is divine!'));
+      expect(events.next, throwsA('To err is divine!'));
       expect(await events.next, 4);
       await events.cancel();
     });
   });
 
-  group("cancel operation", () {
-    test("closes the events, prevents any other operation", () async {
+  group('cancel operation', () {
+    test('closes the events, prevents any other operation', () async {
       var events = StreamQueue<int>(createStream());
       await events.cancel();
       expect(() => events.lookAhead(1), throwsStateError);
@@ -482,7 +482,7 @@
       expect(() => events.cancel(), throwsStateError);
     });
 
-    test("cancels underlying subscription when called before any event",
+    test('cancels underlying subscription when called before any event',
         () async {
       var cancelFuture = Future.value(42);
       var controller = StreamController<int>(onCancel: () => cancelFuture);
@@ -490,7 +490,7 @@
       expect(await events.cancel(), 42);
     });
 
-    test("cancels underlying subscription, returns result", () async {
+    test('cancels underlying subscription, returns result', () async {
       var cancelFuture = Future.value(42);
       var controller = StreamController<int>(onCancel: () => cancelFuture);
       var events = StreamQueue<int>(controller.stream);
@@ -499,8 +499,8 @@
       expect(await events.cancel(), 42);
     });
 
-    group("with immediate: true", () {
-      test("closes the events, prevents any other operation", () async {
+    group('with immediate: true', () {
+      test('closes the events, prevents any other operation', () async {
         var events = StreamQueue<int>(createStream());
         await events.cancel(immediate: true);
         expect(() => events.next, throwsStateError);
@@ -510,7 +510,7 @@
         expect(() => events.cancel(), throwsStateError);
       });
 
-      test("cancels the underlying subscription immediately", () async {
+      test('cancels the underlying subscription immediately', () async {
         var controller = StreamController<int>();
         controller.add(1);
 
@@ -522,7 +522,7 @@
         expect(controller.hasListener, isFalse);
       });
 
-      test("cancels the underlying subscription when called before any event",
+      test('cancels the underlying subscription when called before any event',
           () async {
         var cancelFuture = Future.value(42);
         var controller = StreamController<int>(onCancel: () => cancelFuture);
@@ -531,7 +531,7 @@
         expect(await events.cancel(immediate: true), 42);
       });
 
-      test("closes pending requests", () async {
+      test('closes pending requests', () async {
         var events = StreamQueue<int>(createStream());
         expect(await events.next, 1);
         expect(events.next, throwsStateError);
@@ -540,7 +540,7 @@
         await events.cancel(immediate: true);
       });
 
-      test("returns the result of closing the underlying subscription",
+      test('returns the result of closing the underlying subscription',
           () async {
         var controller =
             StreamController<int>(onCancel: () => Future.value(42));
@@ -564,30 +564,30 @@
     });
   });
 
-  group("hasNext operation", () {
-    test("true at start", () async {
+  group('hasNext operation', () {
+    test('true at start', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.hasNext, isTrue);
     });
 
-    test("true after start", () async {
+    test('true after start', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, isTrue);
     });
 
-    test("true at end", () async {
+    test('true at end', () async {
       var events = StreamQueue<int>(createStream());
-      for (int i = 1; i <= 4; i++) {
+      for (var i = 1; i <= 4; i++) {
         expect(await events.next, i);
       }
       expect(await events.hasNext, isFalse);
     });
 
-    test("true when enqueued", () async {
+    test('true when enqueued', () async {
       var events = StreamQueue<int>(createStream());
       var values = <int>[];
-      for (int i = 1; i <= 3; i++) {
+      for (var i = 1; i <= 3; i++) {
         events.next.then(values.add);
       }
       expect(values, isEmpty);
@@ -595,10 +595,10 @@
       expect(values, [1, 2, 3]);
     });
 
-    test("false when enqueued", () async {
+    test('false when enqueued', () async {
       var events = StreamQueue<int>(createStream());
       var values = <int>[];
-      for (int i = 1; i <= 4; i++) {
+      for (var i = 1; i <= 4; i++) {
         events.next.then(values.add);
       }
       expect(values, isEmpty);
@@ -606,7 +606,7 @@
       expect(values, [1, 2, 3, 4]);
     });
 
-    test("true when data event", () async {
+    test('true when data event', () async {
       var controller = StreamController<int>();
       var events = StreamQueue<int>(controller.stream);
 
@@ -622,7 +622,7 @@
       expect(hasNext, isTrue);
     });
 
-    test("true when error event", () async {
+    test('true when error event', () async {
       var controller = StreamController<int>();
       var events = StreamQueue<int>(controller.stream);
 
@@ -632,14 +632,14 @@
       });
       await flushMicrotasks();
       expect(hasNext, isNull);
-      controller.addError("BAD");
+      controller.addError('BAD');
       expect(hasNext, isNull);
       await flushMicrotasks();
       expect(hasNext, isTrue);
-      expect(events.next, throwsA("BAD"));
+      expect(events.next, throwsA('BAD'));
     });
 
-    test("- hasNext after hasNext", () async {
+    test('- hasNext after hasNext', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.hasNext, true);
       expect(await events.hasNext, true);
@@ -657,7 +657,7 @@
       expect(await events.hasNext, false);
     });
 
-    test("- next after true", () async {
+    test('- next after true', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
@@ -665,7 +665,7 @@
       expect(await events.next, 3);
     });
 
-    test("- next after true, enqueued", () async {
+    test('- next after true, enqueued', () async {
       var events = StreamQueue<int>(createStream());
       var responses = <Object>[];
       events.next.then(responses.add);
@@ -677,7 +677,7 @@
       expect(responses, [1, true, 2]);
     });
 
-    test("- skip 0 after true", () async {
+    test('- skip 0 after true', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
@@ -685,7 +685,7 @@
       expect(await events.next, 2);
     });
 
-    test("- skip 1 after true", () async {
+    test('- skip 1 after true', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
@@ -693,7 +693,7 @@
       expect(await events.next, 3);
     });
 
-    test("- skip 2 after true", () async {
+    test('- skip 2 after true', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
@@ -701,7 +701,7 @@
       expect(await events.next, 4);
     });
 
-    test("- take 0 after true", () async {
+    test('- take 0 after true', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
@@ -709,7 +709,7 @@
       expect(await events.next, 2);
     });
 
-    test("- take 1 after true", () async {
+    test('- take 1 after true', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
@@ -717,7 +717,7 @@
       expect(await events.next, 3);
     });
 
-    test("- take 2 after true", () async {
+    test('- take 2 after true', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
@@ -725,7 +725,7 @@
       expect(await events.next, 4);
     });
 
-    test("- rest after true", () async {
+    test('- rest after true', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.hasNext, true);
@@ -733,7 +733,7 @@
       expect(await stream.toList(), [2, 3, 4]);
     });
 
-    test("- rest after true, at last", () async {
+    test('- rest after true, at last', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
@@ -743,7 +743,7 @@
       expect(await stream.toList(), [4]);
     });
 
-    test("- rest after false", () async {
+    test('- rest after false', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
@@ -754,7 +754,7 @@
       expect(await stream.toList(), isEmpty);
     });
 
-    test("- cancel after true on data", () async {
+    test('- cancel after true on data', () async {
       var events = StreamQueue<int>(createStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
@@ -762,7 +762,7 @@
       expect(await events.cancel(), null);
     });
 
-    test("- cancel after true on error", () async {
+    test('- cancel after true on error', () async {
       var events = StreamQueue<int>(createErrorStream());
       expect(await events.next, 1);
       expect(await events.next, 2);
@@ -771,7 +771,7 @@
     });
   });
 
-  group("startTransaction operation produces a transaction that", () {
+  group('startTransaction operation produces a transaction that', () {
     StreamQueue<int> events;
     StreamQueueTransaction<int> transaction;
     StreamQueue<int> queue1;
@@ -784,8 +784,8 @@
       queue2 = transaction.newQueue();
     });
 
-    group("emits queues that", () {
-      test("independently emit events", () async {
+    group('emits queues that', () {
+      test('independently emit events', () async {
         expect(await queue1.next, 2);
         expect(await queue2.next, 2);
         expect(await queue2.next, 3);
@@ -796,7 +796,7 @@
         expect(await queue2.hasNext, isFalse);
       });
 
-      test("queue requests for events", () async {
+      test('queue requests for events', () async {
         expect(queue1.next, completion(2));
         expect(queue2.next, completion(2));
         expect(queue2.next, completion(3));
@@ -807,7 +807,7 @@
         expect(queue2.hasNext, completion(isFalse));
       });
 
-      test("independently emit errors", () async {
+      test('independently emit errors', () async {
         events = StreamQueue(createErrorStream());
         expect(await events.next, 1);
         transaction = events.startTransaction();
@@ -816,8 +816,8 @@
 
         expect(queue1.next, completion(2));
         expect(queue2.next, completion(2));
-        expect(queue2.next, throwsA("To err is divine!"));
-        expect(queue1.next, throwsA("To err is divine!"));
+        expect(queue2.next, throwsA('To err is divine!'));
+        expect(queue1.next, throwsA('To err is divine!'));
         expect(queue1.next, completion(4));
         expect(queue2.next, completion(4));
         expect(queue1.hasNext, completion(isFalse));
@@ -825,8 +825,8 @@
       });
     });
 
-    group("when rejected", () {
-      test("further original requests use the previous state", () async {
+    group('when rejected', () {
+      test('further original requests use the previous state', () async {
         expect(await queue1.next, 2);
         expect(await queue2.next, 2);
         expect(await queue2.next, 3);
@@ -840,7 +840,7 @@
         expect(await events.hasNext, isFalse);
       });
 
-      test("pending original requests use the previous state", () async {
+      test('pending original requests use the previous state', () async {
         expect(await queue1.next, 2);
         expect(await queue2.next, 2);
         expect(await queue2.next, 3);
@@ -853,7 +853,7 @@
         transaction.reject();
       });
 
-      test("further child requests act as though the stream was closed",
+      test('further child requests act as though the stream was closed',
           () async {
         expect(await queue1.next, 2);
         transaction.reject();
@@ -862,7 +862,7 @@
         expect(queue1.next, throwsStateError);
       });
 
-      test("pending child requests act as though the stream was closed",
+      test('pending child requests act as though the stream was closed',
           () async {
         expect(await queue1.next, 2);
         expect(queue1.hasNext, completion(isFalse));
@@ -871,7 +871,7 @@
       });
 
       // Regression test.
-      test("pending child rest requests emit no more events", () async {
+      test('pending child rest requests emit no more events', () async {
         var controller = StreamController();
         var events = StreamQueue(controller.stream);
         var transaction = events.startTransaction();
@@ -899,13 +899,13 @@
         await queue1.cancel();
       });
 
-      test("calls to commit() or reject() fail", () async {
+      test('calls to commit() or reject() fail', () async {
         transaction.reject();
         expect(transaction.reject, throwsStateError);
         expect(() => transaction.commit(queue1), throwsStateError);
       });
 
-      test("before the transaction emits any events, does nothing", () async {
+      test('before the transaction emits any events, does nothing', () async {
         var controller = StreamController();
         var events = StreamQueue(controller.stream);
 
@@ -924,22 +924,22 @@
       });
     });
 
-    group("when committed", () {
-      test("further original requests use the committed state", () async {
+    group('when committed', () {
+      test('further original requests use the committed state', () async {
         expect(await queue1.next, 2);
         await flushMicrotasks();
         transaction.commit(queue1);
         expect(await events.next, 3);
       });
 
-      test("pending original requests use the committed state", () async {
+      test('pending original requests use the committed state', () async {
         expect(await queue1.next, 2);
         expect(events.next, completion(3));
         await flushMicrotasks();
         transaction.commit(queue1);
       });
 
-      test("further child requests act as though the stream was closed",
+      test('further child requests act as though the stream was closed',
           () async {
         expect(await queue2.next, 2);
         transaction.commit(queue2);
@@ -948,7 +948,7 @@
         expect(queue1.next, throwsStateError);
       });
 
-      test("pending child requests act as though the stream was closed",
+      test('pending child requests act as though the stream was closed',
           () async {
         expect(await queue2.next, 2);
         expect(queue1.hasNext, completion(isFalse));
@@ -956,7 +956,7 @@
         transaction.commit(queue2);
       });
 
-      test("further requests act as though the stream was closed", () async {
+      test('further requests act as though the stream was closed', () async {
         expect(await queue1.next, 2);
         transaction.commit(queue1);
 
@@ -964,25 +964,25 @@
         expect(queue1.next, throwsStateError);
       });
 
-      test("cancel() may still be called explicitly", () async {
+      test('cancel() may still be called explicitly', () async {
         expect(await queue1.next, 2);
         transaction.commit(queue1);
         await queue1.cancel();
       });
 
-      test("throws if there are pending requests", () async {
+      test('throws if there are pending requests', () async {
         expect(await queue1.next, 2);
         expect(queue1.hasNext, completion(isTrue));
         expect(() => transaction.commit(queue1), throwsStateError);
       });
 
-      test("calls to commit() or reject() fail", () async {
+      test('calls to commit() or reject() fail', () async {
         transaction.commit(queue1);
         expect(transaction.reject, throwsStateError);
         expect(() => transaction.commit(queue1), throwsStateError);
       });
 
-      test("before the transaction emits any events, does nothing", () async {
+      test('before the transaction emits any events, does nothing', () async {
         var controller = StreamController();
         var events = StreamQueue(controller.stream);
 
@@ -1003,14 +1003,14 @@
     });
   });
 
-  group("withTransaction operation", () {
+  group('withTransaction operation', () {
     StreamQueue<int> events;
     setUp(() async {
       events = StreamQueue(createStream());
       expect(await events.next, 1);
     });
 
-    test("passes a copy of the parent queue", () async {
+    test('passes a copy of the parent queue', () async {
       await events.withTransaction(expectAsync1((queue) async {
         expect(await queue.next, 2);
         expect(await queue.next, 3);
@@ -1021,8 +1021,8 @@
     });
 
     test(
-        "the parent queue continues from the child position if it returns "
-        "true", () async {
+        'the parent queue continues from the child position if it returns '
+        'true', () async {
       await events.withTransaction(expectAsync1((queue) async {
         expect(await queue.next, 2);
         return true;
@@ -1032,8 +1032,8 @@
     });
 
     test(
-        "the parent queue continues from its original position if it returns "
-        "false", () async {
+        'the parent queue continues from its original position if it returns '
+        'false', () async {
       await events.withTransaction(expectAsync1((queue) async {
         expect(await queue.next, 2);
         return false;
@@ -1042,29 +1042,29 @@
       expect(await events.next, 2);
     });
 
-    test("the parent queue continues from the child position if it throws", () {
+    test('the parent queue continues from the child position if it throws', () {
       expect(events.withTransaction(expectAsync1((queue) async {
         expect(await queue.next, 2);
-        throw "oh no";
-      })), throwsA("oh no"));
+        throw 'oh no';
+      })), throwsA('oh no'));
 
       expect(events.next, completion(3));
     });
 
-    test("returns whether the transaction succeeded", () {
+    test('returns whether the transaction succeeded', () {
       expect(events.withTransaction((_) async => true), completion(isTrue));
       expect(events.withTransaction((_) async => false), completion(isFalse));
     });
   });
 
-  group("cancelable operation", () {
+  group('cancelable operation', () {
     StreamQueue<int> events;
     setUp(() async {
       events = StreamQueue(createStream());
       expect(await events.next, 1);
     });
 
-    test("passes a copy of the parent queue", () async {
+    test('passes a copy of the parent queue', () async {
       await events.cancelable(expectAsync1((queue) async {
         expect(await queue.next, 2);
         expect(await queue.next, 3);
@@ -1073,7 +1073,7 @@
       })).value;
     });
 
-    test("the parent queue continues from the child position by default",
+    test('the parent queue continues from the child position by default',
         () async {
       await events.cancelable(expectAsync1((queue) async {
         expect(await queue.next, 2);
@@ -1083,19 +1083,19 @@
     });
 
     test(
-        "the parent queue continues from the child position if an error is "
-        "thrown", () async {
+        'the parent queue continues from the child position if an error is '
+        'thrown', () async {
       expect(
           events.cancelable(expectAsync1((queue) async {
             expect(await queue.next, 2);
-            throw "oh no";
+            throw 'oh no';
           })).value,
-          throwsA("oh no"));
+          throwsA('oh no'));
 
       expect(events.next, completion(3));
     });
 
-    test("the parent queue continues from the original position if canceled",
+    test('the parent queue continues from the original position if canceled',
         () async {
       var operation = events.cancelable(expectAsync1((queue) async {
         expect(await queue.next, 2);
@@ -1105,17 +1105,17 @@
       expect(await events.next, 2);
     });
 
-    test("forwards the value from the callback", () async {
+    test('forwards the value from the callback', () async {
       expect(
           await events.cancelable(expectAsync1((queue) async {
             expect(await queue.next, 2);
-            return "value";
+            return 'value';
           })).value,
-          "value");
+          'value');
     });
   });
 
-  test("all combinations sequential skip/next/take operations", () async {
+  test('all combinations sequential skip/next/take operations', () async {
     // Takes all combinations of two of next, skip and take, then ends with
     // doing rest. Each of the first rounds do 10 events of each type,
     // the rest does 20 elements.
@@ -1124,30 +1124,30 @@
 
     // Test expecting [startIndex .. startIndex + 9] as events using
     // `next`.
-    nextTest(startIndex) {
-      for (int i = 0; i < 10; i++) {
+    void nextTest(startIndex) {
+      for (var i = 0; i < 10; i++) {
         expect(events.next, completion(startIndex + i));
       }
     }
 
     // Test expecting 10 events to be skipped.
-    skipTest(startIndex) {
+    void skipTest(startIndex) {
       expect(events.skip(10), completion(0));
     }
 
     // Test expecting [startIndex .. startIndex + 9] as events using
     // `take(10)`.
-    takeTest(startIndex) {
+    void takeTest(startIndex) {
       expect(events.take(10),
           completion(List.generate(10, (i) => startIndex + i)));
     }
 
     var tests = [nextTest, skipTest, takeTest];
 
-    int counter = 0;
+    var counter = 0;
     // Run through all pairs of two tests and run them.
-    for (int i = 0; i < tests.length; i++) {
-      for (int j = 0; j < tests.length; j++) {
+    for (var i = 0; i < tests.length; i++) {
+      for (var j = 0; j < tests.length; j++) {
         tests[i](counter);
         tests[j](counter + 10);
         counter += 20;
@@ -1178,7 +1178,7 @@
     await flushMicrotasks();
     controller.add(2);
     await flushMicrotasks();
-    controller.addError("To err is divine!");
+    controller.addError('To err is divine!');
     await flushMicrotasks();
     controller.add(4);
     await flushMicrotasks();
@@ -1188,5 +1188,7 @@
 }
 
 Stream<int> createLongStream(int eventCount) async* {
-  for (int i = 0; i < eventCount; i++) yield i;
+  for (var i = 0; i < eventCount; i++) {
+    yield i;
+  }
 }
diff --git a/test/stream_sink_completer_test.dart b/test/stream_sink_completer_test.dart
index 56860ce..69d1d8a 100644
--- a/test/stream_sink_completer_test.dart
+++ b/test/stream_sink_completer_test.dart
@@ -2,21 +2,21 @@
 // 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 'dart:async';
 
-import "package:async/async.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:test/test.dart';
 
-import "utils.dart";
+import 'utils.dart';
 
-main() {
+void main() {
   StreamSinkCompleter completer;
   setUp(() {
     completer = StreamSinkCompleter();
   });
 
-  group("when a stream is linked before events are added", () {
-    test("data events are forwarded", () {
+  group('when a stream is linked before events are added', () {
+    test('data events are forwarded', () {
       var sink = TestSink();
       completer.setDestinationSink(sink);
       completer.sink..add(1)..add(2)..add(3)..add(4);
@@ -27,16 +27,16 @@
       expect(sink.results[3].asValue.value, equals(4));
     });
 
-    test("error events are forwarded", () {
+    test('error events are forwarded', () {
       var sink = TestSink();
       completer.setDestinationSink(sink);
-      completer.sink..addError("oh no")..addError("that's bad");
+      completer.sink..addError('oh no')..addError("that's bad");
 
-      expect(sink.results[0].asError.error, equals("oh no"));
+      expect(sink.results[0].asError.error, equals('oh no'));
       expect(sink.results[1].asError.error, equals("that's bad"));
     });
 
-    test("addStream is forwarded", () async {
+    test('addStream is forwarded', () async {
       var sink = TestSink();
       completer.setDestinationSink(sink);
 
@@ -44,13 +44,13 @@
       completer.sink.addStream(controller.stream);
 
       controller.add(1);
-      controller.addError("oh no");
+      controller.addError('oh no');
       controller.add(2);
       controller.addError("that's bad");
       await flushMicrotasks();
 
       expect(sink.results[0].asValue.value, equals(1));
-      expect(sink.results[1].asError.error, equals("oh no"));
+      expect(sink.results[1].asError.error, equals('oh no'));
       expect(sink.results[2].asValue.value, equals(2));
       expect(sink.results[3].asError.error, equals("that's bad"));
       expect(sink.isClosed, isFalse);
@@ -60,14 +60,14 @@
       expect(sink.isClosed, isFalse);
     });
 
-    test("close() is forwarded", () {
+    test('close() is forwarded', () {
       var sink = TestSink();
       completer.setDestinationSink(sink);
       completer.sink.close();
       expect(sink.isClosed, isTrue);
     });
 
-    test("the future from the inner close() is returned", () async {
+    test('the future from the inner close() is returned', () async {
       var closeCompleter = Completer();
       var sink = TestSink(onDone: () => closeCompleter.future);
       completer.setDestinationSink(sink);
@@ -85,35 +85,35 @@
       expect(closeCompleted, isTrue);
     });
 
-    test("errors are forwarded from the inner close()", () {
-      var sink = TestSink(onDone: () => throw "oh no");
+    test('errors are forwarded from the inner close()', () {
+      var sink = TestSink(onDone: () => throw 'oh no');
       completer.setDestinationSink(sink);
-      expect(completer.sink.done, throwsA("oh no"));
-      expect(completer.sink.close(), throwsA("oh no"));
+      expect(completer.sink.done, throwsA('oh no'));
+      expect(completer.sink.close(), throwsA('oh no'));
     });
 
     test("errors aren't top-leveled if only close() is listened to", () async {
-      var sink = TestSink(onDone: () => throw "oh no");
+      var sink = TestSink(onDone: () => throw 'oh no');
       completer.setDestinationSink(sink);
-      expect(completer.sink.close(), throwsA("oh no"));
+      expect(completer.sink.close(), throwsA('oh no'));
 
       // Give the event loop a chance to top-level errors if it's going to.
       await flushMicrotasks();
     });
 
     test("errors aren't top-leveled if only done is listened to", () async {
-      var sink = TestSink(onDone: () => throw "oh no");
+      var sink = TestSink(onDone: () => throw 'oh no');
       completer.setDestinationSink(sink);
       completer.sink.close();
-      expect(completer.sink.done, throwsA("oh no"));
+      expect(completer.sink.done, throwsA('oh no'));
 
       // Give the event loop a chance to top-level errors if it's going to.
       await flushMicrotasks();
     });
   });
 
-  group("when a stream is linked after events are added", () {
-    test("data events are forwarded", () async {
+  group('when a stream is linked after events are added', () {
+    test('data events are forwarded', () async {
       completer.sink..add(1)..add(2)..add(3)..add(4);
       await flushMicrotasks();
 
@@ -127,24 +127,24 @@
       expect(sink.results[3].asValue.value, equals(4));
     });
 
-    test("error events are forwarded", () async {
-      completer.sink..addError("oh no")..addError("that's bad");
+    test('error events are forwarded', () async {
+      completer.sink..addError('oh no')..addError("that's bad");
       await flushMicrotasks();
 
       var sink = TestSink();
       completer.setDestinationSink(sink);
       await flushMicrotasks();
 
-      expect(sink.results[0].asError.error, equals("oh no"));
+      expect(sink.results[0].asError.error, equals('oh no'));
       expect(sink.results[1].asError.error, equals("that's bad"));
     });
 
-    test("addStream is forwarded", () async {
+    test('addStream is forwarded', () async {
       var controller = StreamController();
       completer.sink.addStream(controller.stream);
 
       controller.add(1);
-      controller.addError("oh no");
+      controller.addError('oh no');
       controller.add(2);
       controller.addError("that's bad");
       controller.close();
@@ -155,13 +155,13 @@
       await flushMicrotasks();
 
       expect(sink.results[0].asValue.value, equals(1));
-      expect(sink.results[1].asError.error, equals("oh no"));
+      expect(sink.results[1].asError.error, equals('oh no'));
       expect(sink.results[2].asValue.value, equals(2));
       expect(sink.results[3].asError.error, equals("that's bad"));
       expect(sink.isClosed, isFalse);
     });
 
-    test("close() is forwarded", () async {
+    test('close() is forwarded', () async {
       completer.sink.close();
       await flushMicrotasks();
 
@@ -172,7 +172,7 @@
       expect(sink.isClosed, isTrue);
     });
 
-    test("the future from the inner close() is returned", () async {
+    test('the future from the inner close() is returned', () async {
       var closeCompleted = false;
       completer.sink.close().then(expectAsync1((_) {
         closeCompleted = true;
@@ -190,20 +190,20 @@
       expect(closeCompleted, isTrue);
     });
 
-    test("errors are forwarded from the inner close()", () async {
-      expect(completer.sink.done, throwsA("oh no"));
-      expect(completer.sink.close(), throwsA("oh no"));
+    test('errors are forwarded from the inner close()', () async {
+      expect(completer.sink.done, throwsA('oh no'));
+      expect(completer.sink.close(), throwsA('oh no'));
       await flushMicrotasks();
 
-      var sink = TestSink(onDone: () => throw "oh no");
+      var sink = TestSink(onDone: () => throw 'oh no');
       completer.setDestinationSink(sink);
     });
 
     test("errors aren't top-leveled if only close() is listened to", () async {
-      expect(completer.sink.close(), throwsA("oh no"));
+      expect(completer.sink.close(), throwsA('oh no'));
       await flushMicrotasks();
 
-      var sink = TestSink(onDone: () => throw "oh no");
+      var sink = TestSink(onDone: () => throw 'oh no');
       completer.setDestinationSink(sink);
 
       // Give the event loop a chance to top-level errors if it's going to.
@@ -212,10 +212,10 @@
 
     test("errors aren't top-leveled if only done is listened to", () async {
       completer.sink.close();
-      expect(completer.sink.done, throwsA("oh no"));
+      expect(completer.sink.done, throwsA('oh no'));
       await flushMicrotasks();
 
-      var sink = TestSink(onDone: () => throw "oh no");
+      var sink = TestSink(onDone: () => throw 'oh no');
       completer.setDestinationSink(sink);
 
       // Give the event loop a chance to top-level errors if it's going to.
@@ -223,7 +223,7 @@
     });
   });
 
-  test("the sink is closed, the destination is set, then done is read",
+  test('the sink is closed, the destination is set, then done is read',
       () async {
     expect(completer.sink.close(), completes);
     await flushMicrotasks();
@@ -234,7 +234,7 @@
     expect(completer.sink.done, completes);
   });
 
-  test("done is read, the destination is set, then the sink is closed",
+  test('done is read, the destination is set, then the sink is closed',
       () async {
     expect(completer.sink.done, completes);
     await flushMicrotasks();
@@ -245,8 +245,8 @@
     expect(completer.sink.close(), completes);
   });
 
-  group("fromFuture()", () {
-    test("with a successful completion", () async {
+  group('fromFuture()', () {
+    test('with a successful completion', () async {
       var futureCompleter = Completer<StreamSink>();
       var sink = StreamSinkCompleter.fromFuture(futureCompleter.future);
       sink.add(1);
@@ -263,27 +263,27 @@
       expect(testSink.results[2].asValue.value, equals(3));
     });
 
-    test("with an error", () async {
+    test('with an error', () async {
       var futureCompleter = Completer<StreamSink>();
       var sink = StreamSinkCompleter.fromFuture(futureCompleter.future);
-      expect(sink.done, throwsA("oh no"));
-      futureCompleter.completeError("oh no");
+      expect(sink.done, throwsA('oh no'));
+      futureCompleter.completeError('oh no');
     });
   });
 
-  group("setError()", () {
-    test("produces a closed sink with the error", () {
-      completer.setError("oh no");
-      expect(completer.sink.done, throwsA("oh no"));
-      expect(completer.sink.close(), throwsA("oh no"));
+  group('setError()', () {
+    test('produces a closed sink with the error', () {
+      completer.setError('oh no');
+      expect(completer.sink.done, throwsA('oh no'));
+      expect(completer.sink.close(), throwsA('oh no'));
     });
 
-    test("produces an error even if done was accessed earlier", () async {
-      expect(completer.sink.done, throwsA("oh no"));
-      expect(completer.sink.close(), throwsA("oh no"));
+    test('produces an error even if done was accessed earlier', () async {
+      expect(completer.sink.done, throwsA('oh no'));
+      expect(completer.sink.close(), throwsA('oh no'));
       await flushMicrotasks();
 
-      completer.setError("oh no");
+      completer.setError('oh no');
     });
   });
 
diff --git a/test/stream_sink_transformer_test.dart b/test/stream_sink_transformer_test.dart
index 5e981a6..8493971 100644
--- a/test/stream_sink_transformer_test.dart
+++ b/test/stream_sink_transformer_test.dart
@@ -2,12 +2,12 @@
 // 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 'dart:async';
 
-import "package:async/async.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:test/test.dart';
 
-import "utils.dart";
+import 'utils.dart';
 
 void main() {
   StreamController controller;
@@ -15,8 +15,8 @@
     controller = StreamController();
   });
 
-  group("fromStreamTransformer", () {
-    test("transforms data events", () {
+  group('fromStreamTransformer', () {
+    test('transforms data events', () {
       var transformer = StreamSinkTransformer.fromStreamTransformer(
           StreamTransformer.fromHandlers(handleData: (i, sink) {
         sink.add(i * 2);
@@ -34,7 +34,7 @@
       sink.close();
     });
 
-    test("transforms error events", () {
+    test('transforms error events', () {
       var transformer = StreamSinkTransformer.fromStreamTransformer(
           StreamTransformer.fromHandlers(handleError: (i, stackTrace, sink) {
         sink.addError((i as num) * 2, stackTrace);
@@ -55,7 +55,7 @@
       sink.close();
     });
 
-    test("transforms done events", () {
+    test('transforms done events', () {
       var transformer = StreamSinkTransformer.fromStreamTransformer(
           StreamTransformer.fromHandlers(handleDone: (sink) {
         sink.add(1);
@@ -71,7 +71,7 @@
       sink.close();
     });
 
-    test("forwards the future from inner.close", () async {
+    test('forwards the future from inner.close', () async {
       var transformer = StreamSinkTransformer.fromStreamTransformer(
           StreamTransformer.fromHandlers());
       var innerSink = CompleterStreamSink();
@@ -104,18 +104,18 @@
 
       // This will close the inner sink, but it shouldn't top-level the error.
       sink.add(1);
-      innerSink.completer.completeError("oh no");
+      innerSink.completer.completeError('oh no');
       await flushMicrotasks();
 
       // The error should be piped through done and close even if they're called
       // after the underlying sink is closed.
-      expect(sink.done, throwsA("oh no"));
-      expect(sink.close(), throwsA("oh no"));
+      expect(sink.done, throwsA('oh no'));
+      expect(sink.close(), throwsA('oh no'));
     });
   });
 
-  group("fromHandlers", () {
-    test("transforms data events", () {
+  group('fromHandlers', () {
+    test('transforms data events', () {
       var transformer =
           StreamSinkTransformer.fromHandlers(handleData: (i, sink) {
         sink.add(i * 2);
@@ -133,7 +133,7 @@
       sink.close();
     });
 
-    test("transforms error events", () {
+    test('transforms error events', () {
       var transformer = StreamSinkTransformer.fromHandlers(
           handleError: (i, stackTrace, sink) {
         sink.addError((i as num) * 2, stackTrace);
@@ -154,7 +154,7 @@
       sink.close();
     });
 
-    test("transforms done events", () {
+    test('transforms done events', () {
       var transformer = StreamSinkTransformer.fromHandlers(handleDone: (sink) {
         sink.add(1);
         sink.close();
@@ -169,7 +169,7 @@
       sink.close();
     });
 
-    test("forwards the future from inner.close", () async {
+    test('forwards the future from inner.close', () async {
       var transformer = StreamSinkTransformer.fromHandlers();
       var innerSink = CompleterStreamSink();
       var sink = transformer.bind(innerSink);
@@ -201,13 +201,13 @@
 
       // This will close the inner sink, but it shouldn't top-level the error.
       sink.add(1);
-      innerSink.completer.completeError("oh no");
+      innerSink.completer.completeError('oh no');
       await flushMicrotasks();
 
       // The error should be piped through done and close even if they're called
       // after the underlying sink is closed.
-      expect(sink.done, throwsA("oh no"));
-      expect(sink.close(), throwsA("oh no"));
+      expect(sink.done, throwsA('oh no'));
+      expect(sink.close(), throwsA('oh no'));
     });
   });
 }
diff --git a/test/stream_splitter_test.dart b/test/stream_splitter_test.dart
index 497f125..fd37f87 100644
--- a/test/stream_splitter_test.dart
+++ b/test/stream_splitter_test.dart
@@ -7,7 +7,7 @@
 import 'package:async/async.dart';
 import 'package:test/test.dart';
 
-main() {
+void main() {
   StreamController<int> controller;
   StreamSplitter splitter;
   setUp(() {
@@ -37,12 +37,12 @@
     controller.close();
   });
 
-  test("a branch replays error events as well as data events", () {
+  test('a branch replays error events as well as data events', () {
     var branch = splitter.split();
     splitter.close();
 
     controller.add(1);
-    controller.addError("error");
+    controller.addError('error');
     controller.add(3);
     controller.close();
 
@@ -54,7 +54,7 @@
           count++;
         }, count: 2), onError: expectAsync1((error) {
       expect(count, equals(1));
-      expect(error, equals("error"));
+      expect(error, equals('error'));
       count++;
     }), onDone: expectAsync0(() {
       expect(count, equals(3));
@@ -89,7 +89,7 @@
     splitter.close();
   });
 
-  test("creates single-subscription branches", () async {
+  test('creates single-subscription branches', () async {
     var branch = splitter.split();
     expect(branch.isBroadcast, isFalse);
     branch.listen(null);
@@ -101,7 +101,7 @@
   // 1.11 is released. In 1.10, the stream exposed by a StreamController didn't
   // have a reified type.
 
-  test("multiple branches each replay the stream", () async {
+  test('multiple branches each replay the stream', () async {
     var branch1 = splitter.split();
     controller.add(1);
     controller.add(2);
@@ -151,7 +151,7 @@
     expect(controller.hasListener, isTrue);
   });
 
-  test("the source stream is paused when all branches are paused", () async {
+  test('the source stream is paused when all branches are paused', () async {
     var branch1 = splitter.split();
     var branch2 = splitter.split();
     var branch3 = splitter.split();
@@ -178,7 +178,7 @@
     expect(controller.isPaused, isFalse);
   });
 
-  test("the source stream is paused when all branches are canceled", () async {
+  test('the source stream is paused when all branches are canceled', () async {
     var branch1 = splitter.split();
     var branch2 = splitter.split();
     var branch3 = splitter.split();
@@ -211,7 +211,7 @@
 
   test(
       "the source stream is canceled when it's closed after all branches have "
-      "been canceled", () async {
+      'been canceled', () async {
     var branch1 = splitter.split();
     var branch2 = splitter.split();
     var branch3 = splitter.split();
@@ -237,8 +237,8 @@
   });
 
   test(
-      "the source stream is canceled when all branches are canceled after it "
-      "has been closed", () async {
+      'the source stream is canceled when all branches are canceled after it '
+      'has been closed', () async {
     var branch1 = splitter.split();
     var branch2 = splitter.split();
     var branch3 = splitter.split();
@@ -263,7 +263,7 @@
 
   test(
       "a splitter that's closed before any branches are added never listens "
-      "to the source stream", () {
+      'to the source stream', () {
     splitter.close();
 
     // This would throw an error if the stream had already been listened to.
@@ -271,8 +271,8 @@
   });
 
   test(
-      "splitFrom splits a source stream into the designated number of "
-      "branches", () {
+      'splitFrom splits a source stream into the designated number of '
+      'branches', () {
     var branches = StreamSplitter.splitFrom(controller.stream, 5);
 
     controller.add(1);
diff --git a/test/stream_zip_test.dart b/test/stream_zip_test.dart
index 1e5f524..f462996 100644
--- a/test/stream_zip_test.dart
+++ b/test/stream_zip_test.dart
@@ -2,10 +2,10 @@
 // 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 'dart:async';
 
-import "package:async/async.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:test/test.dart';
 
 /// Create an error with the same values as [base], except that it throwsA
 /// when seeing the value [errorValue].
@@ -16,10 +16,10 @@
 /// Make a [Stream] from an [Iterable] by adding events to a stream controller
 /// at periodic intervals.
 Stream mks(Iterable iterable) {
-  Iterator iterator = iterable.iterator;
-  StreamController controller = StreamController();
+  var iterator = iterable.iterator;
+  var controller = StreamController();
   // Some varying time between 3 and 10 ms.
-  int ms = ((++ctr) * 5) % 7 + 3;
+  var ms = ((++ctr) * 5) % 7 + 3;
   Timer.periodic(Duration(milliseconds: ms), (Timer timer) {
     if (iterator.moveNext()) {
       controller.add(iterator.current);
@@ -34,17 +34,17 @@
 /// Counter used to give varying delays for streams.
 int ctr = 0;
 
-main() {
+void main() {
   // Test that zipping [streams] gives the results iterated by [expectedData].
-  testZip(Iterable<Stream> streams, Iterable expectedData) {
-    List data = [];
+  void testZip(Iterable<Stream> streams, Iterable expectedData) {
+    var data = [];
     Stream zip = StreamZip(streams);
     zip.listen(data.add, onDone: expectAsync0(() {
       expect(data, equals(expectedData));
     }));
   }
 
-  test("Basic", () {
+  test('Basic', () {
     testZip([
       mks([1, 2, 3]),
       mks([4, 5, 6]),
@@ -56,7 +56,7 @@
     ]);
   });
 
-  test("Uneven length 1", () {
+  test('Uneven length 1', () {
     testZip([
       mks([1, 2, 3, 99, 100]),
       mks([4, 5, 6]),
@@ -68,7 +68,7 @@
     ]);
   });
 
-  test("Uneven length 2", () {
+  test('Uneven length 2', () {
     testZip([
       mks([1, 2, 3]),
       mks([4, 5, 6, 99, 100]),
@@ -80,7 +80,7 @@
     ]);
   });
 
-  test("Uneven length 3", () {
+  test('Uneven length 3', () {
     testZip([
       mks([1, 2, 3]),
       mks([4, 5, 6]),
@@ -92,7 +92,7 @@
     ]);
   });
 
-  test("Uneven length 4", () {
+  test('Uneven length 4', () {
     testZip([
       mks([1, 2, 3, 98]),
       mks([4, 5, 6]),
@@ -104,7 +104,7 @@
     ]);
   });
 
-  test("Empty 1", () {
+  test('Empty 1', () {
     testZip([
       mks([]),
       mks([4, 5, 6]),
@@ -112,7 +112,7 @@
     ], []);
   });
 
-  test("Empty 2", () {
+  test('Empty 2', () {
     testZip([
       mks([1, 2, 3]),
       mks([]),
@@ -120,7 +120,7 @@
     ], []);
   });
 
-  test("Empty 3", () {
+  test('Empty 3', () {
     testZip([
       mks([1, 2, 3]),
       mks([4, 5, 6]),
@@ -128,11 +128,11 @@
     ], []);
   });
 
-  test("Empty source", () {
+  test('Empty source', () {
     testZip([], []);
   });
 
-  test("Single Source", () {
+  test('Single Source', () {
     testZip([
       mks([1, 2, 3])
     ], [
@@ -142,12 +142,12 @@
     ]);
   });
 
-  test("Other-streams", () {
-    Stream st1 = mks([1, 2, 3, 4, 5, 6]).where((x) => x < 4);
+  test('Other-streams', () {
+    var st1 = mks([1, 2, 3, 4, 5, 6]).where((x) => x < 4);
     Stream st2 =
         Stream.periodic(const Duration(milliseconds: 5), (x) => x + 4).take(3);
-    StreamController c = StreamController.broadcast();
-    Stream st3 = c.stream;
+    var c = StreamController.broadcast();
+    var st3 = c.stream;
     testZip([
       st1,
       st2,
@@ -164,67 +164,66 @@
       ..close();
   });
 
-  test("Error 1", () {
+  test('Error 1', () {
     expect(
         StreamZip([
-          streamError(mks([1, 2, 3]), 2, "BAD-1"),
+          streamError(mks([1, 2, 3]), 2, 'BAD-1'),
           mks([4, 5, 6]),
           mks([7, 8, 9])
         ]).toList(),
-        throwsA(equals("BAD-1")));
+        throwsA(equals('BAD-1')));
   });
 
-  test("Error 2", () {
+  test('Error 2', () {
     expect(
         StreamZip([
           mks([1, 2, 3]),
-          streamError(mks([4, 5, 6]), 5, "BAD-2"),
+          streamError(mks([4, 5, 6]), 5, 'BAD-2'),
           mks([7, 8, 9])
         ]).toList(),
-        throwsA(equals("BAD-2")));
+        throwsA(equals('BAD-2')));
   });
 
-  test("Error 3", () {
+  test('Error 3', () {
     expect(
         StreamZip([
           mks([1, 2, 3]),
           mks([4, 5, 6]),
-          streamError(mks([7, 8, 9]), 8, "BAD-3")
+          streamError(mks([7, 8, 9]), 8, 'BAD-3')
         ]).toList(),
-        throwsA(equals("BAD-3")));
+        throwsA(equals('BAD-3')));
   });
 
-  test("Error at end", () {
+  test('Error at end', () {
     expect(
         StreamZip([
           mks([1, 2, 3]),
-          streamError(mks([4, 5, 6]), 6, "BAD-4"),
+          streamError(mks([4, 5, 6]), 6, 'BAD-4'),
           mks([7, 8, 9])
         ]).toList(),
-        throwsA(equals("BAD-4")));
+        throwsA(equals('BAD-4')));
   });
 
-  test("Error before first end", () {
+  test('Error before first end', () {
     // StreamControllers' streams with no "close" called will never be done,
     // so the fourth event of the first stream is guaranteed to come first.
     expect(
         StreamZip([
-          streamError(mks([1, 2, 3, 4]), 4, "BAD-5"),
+          streamError(mks([1, 2, 3, 4]), 4, 'BAD-5'),
           (StreamController()..add(4)..add(5)..add(6)).stream,
           (StreamController()..add(7)..add(8)..add(9)).stream
         ]).toList(),
-        throwsA(equals("BAD-5")));
+        throwsA(equals('BAD-5')));
   });
 
-  test("Error after first end", () {
-    StreamController controller = StreamController();
+  test('Error after first end', () {
+    var controller = StreamController();
     controller..add(7)..add(8)..add(9);
     // Transformer that puts error into controller when one of the first two
     // streams have sent a done event.
-    StreamTransformer trans =
-        StreamTransformer.fromHandlers(handleDone: (EventSink s) {
+    var trans = StreamTransformer.fromHandlers(handleDone: (EventSink s) {
       Timer.run(() {
-        controller.addError("BAD-6");
+        controller.addError('BAD-6');
       });
       s.close();
     });
@@ -239,16 +238,16 @@
     ]);
   });
 
-  test("Pause/Resume", () {
-    int sc1p = 0;
-    StreamController c1 = StreamController(onPause: () {
+  test('Pause/Resume', () {
+    var sc1p = 0;
+    var c1 = StreamController(onPause: () {
       sc1p++;
     }, onResume: () {
       sc1p--;
     });
 
-    int sc2p = 0;
-    StreamController c2 = StreamController(onPause: () {
+    var sc2p = 0;
+    var c2 = StreamController(onPause: () {
       sc2p++;
     }, onResume: () {
       sc2p--;
@@ -264,7 +263,7 @@
     const ms25 = Duration(milliseconds: 25);
 
     // StreamIterator uses pause and resume to control flow.
-    StreamIterator it = StreamIterator(zip);
+    var it = StreamIterator(zip);
 
     it.moveNext().then((hasMore) {
       expect(hasMore, isTrue);
@@ -301,11 +300,11 @@
     c2..add(2)..add(4);
   });
 
-  test("pause-resume2", () {
+  test('pause-resume2', () {
     var s1 = Stream.fromIterable([0, 2, 4, 6, 8]);
     var s2 = Stream.fromIterable([1, 3, 5, 7]);
     var sz = StreamZip([s1, s2]);
-    int ctr = 0;
+    var ctr = 0;
     StreamSubscription sub;
     sub = sz.listen(expectAsync1((v) {
       expect(v, equals([ctr * 2, ctr * 2 + 1]));
diff --git a/test/stream_zip_zone_test.dart b/test/stream_zip_zone_test.dart
index c7756e6..68cd723 100644
--- a/test/stream_zip_zone_test.dart
+++ b/test/stream_zip_zone_test.dart
@@ -2,36 +2,37 @@
 // 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:test/test.dart";
+import 'dart:async';
+
+import 'package:test/test.dart';
 
 // Test that stream listener callbacks all happen in the zone where the
 // listen occurred.
 
-main() {
+void main() {
   StreamController controller;
   controller = StreamController();
-  testStream("singlesub-async", controller, controller.stream);
+  testStream('singlesub-async', controller, controller.stream);
   controller = StreamController.broadcast();
-  testStream("broadcast-async", controller, controller.stream);
+  testStream('broadcast-async', controller, controller.stream);
   controller = StreamController();
   testStream(
-      "asbroadcast-async", controller, controller.stream.asBroadcastStream());
+      'asbroadcast-async', controller, controller.stream.asBroadcastStream());
 
   controller = StreamController(sync: true);
-  testStream("singlesub-sync", controller, controller.stream);
+  testStream('singlesub-sync', controller, controller.stream);
   controller = StreamController.broadcast(sync: true);
-  testStream("broadcast-sync", controller, controller.stream);
+  testStream('broadcast-sync', controller, controller.stream);
   controller = StreamController(sync: true);
   testStream(
-      "asbroadcast-sync", controller, controller.stream.asBroadcastStream());
+      'asbroadcast-sync', controller, controller.stream.asBroadcastStream());
 }
 
 void testStream(String name, StreamController controller, Stream stream) {
   test(name, () {
-    Zone outer = Zone.current;
+    var outer = Zone.current;
     runZoned(() {
-      Zone newZone1 = Zone.current;
+      var newZone1 = Zone.current;
       StreamSubscription sub;
       sub = stream.listen(expectAsync1((v) {
         expect(v, 42);
diff --git a/test/subscription_stream_test.dart b/test/subscription_stream_test.dart
index 9460dec..0b24a02 100644
--- a/test/subscription_stream_test.dart
+++ b/test/subscription_stream_test.dart
@@ -2,15 +2,15 @@
 // 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 'dart:async';
 
-import "package:async/async.dart" show SubscriptionStream;
-import "package:test/test.dart";
+import 'package:async/async.dart' show SubscriptionStream;
+import 'package:test/test.dart';
 
-import "utils.dart";
+import 'utils.dart';
 
-main() {
-  test("subscription stream of an entire subscription", () async {
+void main() {
+  test('subscription stream of an entire subscription', () async {
     var stream = createStream();
     var subscription = stream.listen(null);
     var subscriptionStream = SubscriptionStream<int>(subscription);
@@ -18,7 +18,7 @@
     expect(subscriptionStream.toList(), completion([1, 2, 3, 4]));
   });
 
-  test("subscription stream after two events", () async {
+  test('subscription stream after two events', () async {
     var stream = createStream();
     var skips = 0;
     var completer = Completer();
@@ -35,7 +35,7 @@
     expect(subscriptionStream.toList(), completion([3, 4]));
   });
 
-  test("listening twice fails", () async {
+  test('listening twice fails', () async {
     var stream = createStream();
     var sourceSubscription = stream.listen(null);
     var subscriptionStream = SubscriptionStream<int>(sourceSubscription);
@@ -44,7 +44,7 @@
     await subscription.cancel();
   });
 
-  test("pause and cancel passed through to original stream", () async {
+  test('pause and cancel passed through to original stream', () async {
     var controller = StreamController(onCancel: () async => 42);
     var sourceSubscription = controller.stream.listen(null);
     var subscriptionStream = SubscriptionStream(sourceSubscription);
@@ -69,9 +69,9 @@
     expect(controller.hasListener, isFalse);
   });
 
-  group("cancelOnError source:", () {
+  group('cancelOnError source:', () {
     for (var sourceCancels in [false, true]) {
-      group("${sourceCancels ? "yes" : "no"}:", () {
+      group('${sourceCancels ? "yes" : "no"}:', () {
         SubscriptionStream subscriptionStream;
         Future onCancel; // Completes if source stream is canceled before done.
         setUp(() {
@@ -83,16 +83,16 @@
           subscriptionStream = SubscriptionStream<int>(sourceSubscription);
         });
 
-        test("- subscriptionStream: no", () async {
+        test('- subscriptionStream: no', () async {
           var done = Completer();
           var events = [];
           subscriptionStream.listen(events.add,
               onError: events.add, onDone: done.complete, cancelOnError: false);
-          var expected = [1, 2, "To err is divine!"];
+          var expected = [1, 2, 'To err is divine!'];
           if (sourceCancels) {
             await onCancel;
             // And [done] won't complete at all.
-            bool isDone = false;
+            var isDone = false;
             done.future.then((_) {
               isDone = true;
             });
@@ -105,7 +105,7 @@
           expect(events, expected);
         });
 
-        test("- subscriptionStream: yes", () async {
+        test('- subscriptionStream: yes', () async {
           var completer = Completer();
           var events = [];
           subscriptionStream.listen(events.add,
@@ -113,18 +113,18 @@
                 events.add(value);
                 completer.complete();
               },
-              onDone: () => throw "should not happen",
+              onDone: () => throw 'should not happen',
               cancelOnError: true);
           await completer.future;
           await flushMicrotasks();
-          expect(events, [1, 2, "To err is divine!"]);
+          expect(events, [1, 2, 'To err is divine!']);
         });
       });
     }
 
     for (var cancelOnError in [false, true]) {
-      group(cancelOnError ? "yes" : "no", () {
-        test("- no error, value goes to asFuture", () async {
+      group(cancelOnError ? 'yes' : 'no', () {
+        test('- no error, value goes to asFuture', () async {
           var stream = createStream();
           var sourceSubscription =
               stream.listen(null, cancelOnError: cancelOnError);
@@ -134,7 +134,7 @@
           expect(subscription.asFuture(42), completion(42));
         });
 
-        test("- error goes to asFuture", () async {
+        test('- error goes to asFuture', () async {
           var stream = createErrorStream();
           var sourceSubscription =
               stream.listen(null, cancelOnError: cancelOnError);
@@ -160,13 +160,13 @@
 }
 
 Stream<int> createErrorStream([Completer onCancel]) async* {
-  bool canceled = true;
+  var canceled = true;
   try {
     yield 1;
     await flushMicrotasks();
     yield 2;
     await flushMicrotasks();
-    yield* Future<int>.error("To err is divine!").asStream();
+    yield* Future<int>.error('To err is divine!').asStream();
     await flushMicrotasks();
     yield 4;
     await flushMicrotasks();
@@ -181,5 +181,7 @@
 }
 
 Stream<int> createLongStream() async* {
-  for (int i = 0; i < 200; i++) yield i;
+  for (var i = 0; i < 200; i++) {
+    yield i;
+  }
 }
diff --git a/test/subscription_transformer_test.dart b/test/subscription_transformer_test.dart
index 64f45ec..f0e3a70 100644
--- a/test/subscription_transformer_test.dart
+++ b/test/subscription_transformer_test.dart
@@ -10,8 +10,8 @@
 import 'utils.dart';
 
 void main() {
-  group("with no callbacks", () {
-    test("forwards cancellation", () async {
+  group('with no callbacks', () {
+    test('forwards cancellation', () async {
       var isCanceled = false;
       var cancelCompleter = Completer();
       var controller = StreamController(onCancel: expectAsync0(() {
@@ -39,7 +39,7 @@
       expect(subscription.cancel(), completes);
     });
 
-    test("forwards pausing and resuming", () async {
+    test('forwards pausing and resuming', () async {
       var controller = StreamController();
       var subscription = controller.stream
           .transform(subscriptionTransformer())
@@ -62,7 +62,7 @@
       expect(controller.isPaused, isFalse);
     });
 
-    test("forwards pausing with a resume future", () async {
+    test('forwards pausing with a resume future', () async {
       var controller = StreamController();
       var subscription = controller.stream
           .transform(subscriptionTransformer())
@@ -79,8 +79,8 @@
     });
   });
 
-  group("with a cancel callback", () {
-    test("invokes the callback when the subscription is canceled", () async {
+  group('with a cancel callback', () {
+    test('invokes the callback when the subscription is canceled', () async {
       var isCanceled = false;
       var callbackInvoked = false;
       var controller = StreamController(onCancel: expectAsync0(() {
@@ -103,7 +103,7 @@
       expect(isCanceled, isTrue);
     });
 
-    test("invokes the callback once and caches its result", () async {
+    test('invokes the callback once and caches its result', () async {
       var completer = Completer();
       var controller = StreamController();
       var subscription = controller.stream
@@ -132,8 +132,8 @@
     });
   });
 
-  group("with a pause callback", () {
-    test("invokes the callback when pause is called", () async {
+  group('with a pause callback', () {
+    test('invokes the callback when pause is called', () async {
       var pauseCount = 0;
       var controller = StreamController();
       var subscription = controller.stream
@@ -180,8 +180,8 @@
     });
   });
 
-  group("with a resume callback", () {
-    test("invokes the callback when resume is called", () async {
+  group('with a resume callback', () {
+    test('invokes the callback when resume is called', () async {
       var resumeCount = 0;
       var controller = StreamController();
       var subscription = controller.stream
@@ -213,7 +213,7 @@
       expect(resumeCount, equals(3));
     });
 
-    test("invokes the callback when a resume future completes", () async {
+    test('invokes the callback when a resume future completes', () async {
       var resumed = false;
       var controller = StreamController();
       var subscription = controller.stream.transform(
@@ -247,7 +247,7 @@
     });
   });
 
-  group("when the outer subscription is canceled but the inner is not", () {
+  group('when the outer subscription is canceled but the inner is not', () {
     StreamSubscription subscription;
     setUp(() {
       var controller = StreamController();
@@ -258,7 +258,7 @@
               onDone: expectAsync0(() {}, count: 0));
       subscription.cancel();
       controller.add(1);
-      controller.addError("oh no!");
+      controller.addError('oh no!');
       controller.close();
     });
 
@@ -277,11 +277,11 @@
       await flushMicrotasks();
     });
 
-    test("isPaused returns false", () {
+    test('isPaused returns false', () {
       expect(subscription.isPaused, isFalse);
     });
 
-    test("asFuture never completes", () async {
+    test('asFuture never completes', () async {
       subscription.asFuture().then(expectAsync1((_) {}, count: 0));
       await flushMicrotasks();
     });
diff --git a/test/typed_wrapper/stream_subscription_test.dart b/test/typed_wrapper/stream_subscription_test.dart
index bbec8f7..2a11546 100644
--- a/test/typed_wrapper/stream_subscription_test.dart
+++ b/test/typed_wrapper/stream_subscription_test.dart
@@ -4,13 +4,13 @@
 
 import 'dart:async';
 
-import "package:async/src/typed/stream_subscription.dart";
-import "package:test/test.dart";
+import 'package:async/src/typed/stream_subscription.dart';
+import 'package:test/test.dart';
 
 import '../utils.dart';
 
 void main() {
-  group("with valid types, forwards", () {
+  group('with valid types, forwards', () {
     StreamController controller;
     StreamSubscription wrapper;
     bool isCanceled;
@@ -21,26 +21,26 @@
       wrapper = TypeSafeStreamSubscription<int>(controller.stream.listen(null));
     });
 
-    test("onData()", () {
+    test('onData()', () {
       wrapper.onData(expectAsync1((data) {
         expect(data, equals(1));
       }));
       controller.add(1);
     });
 
-    test("onError()", () {
+    test('onError()', () {
       wrapper.onError(expectAsync1((error) {
-        expect(error, equals("oh no"));
+        expect(error, equals('oh no'));
       }));
-      controller.addError("oh no");
+      controller.addError('oh no');
     });
 
-    test("onDone()", () {
+    test('onDone()', () {
       wrapper.onDone(expectAsync0(() {}));
       controller.close();
     });
 
-    test("pause(), resume(), and isPaused", () async {
+    test('pause(), resume(), and isPaused', () async {
       expect(wrapper.isPaused, isFalse);
 
       wrapper.pause();
@@ -54,19 +54,19 @@
       expect(wrapper.isPaused, isFalse);
     });
 
-    test("cancel()", () async {
+    test('cancel()', () async {
       wrapper.cancel();
       await flushMicrotasks();
       expect(isCanceled, isTrue);
     });
 
-    test("asFuture()", () {
+    test('asFuture()', () {
       expect(wrapper.asFuture(12), completion(equals(12)));
       controller.close();
     });
   });
 
-  group("with invalid types,", () {
+  group('with invalid types,', () {
     StreamController controller;
     StreamSubscription wrapper;
     bool isCanceled;
@@ -77,8 +77,8 @@
       wrapper = TypeSafeStreamSubscription<int>(controller.stream.listen(null));
     });
 
-    group("throws a CastError for", () {
-      test("onData()", () {
+    group('throws a CastError for', () {
+      test('onData()', () {
         expect(() {
           // TODO(nweiz): Use the wrapper declared in setUp when sdk#26226 is
           // fixed.
@@ -87,28 +87,28 @@
               TypeSafeStreamSubscription<int>(controller.stream.listen(null));
 
           wrapper.onData(expectAsync1((_) {}, count: 0));
-          controller.add("foo");
+          controller.add('foo');
         }, throwsZonedCastError);
       });
     });
 
     group("doesn't throw a CastError for", () {
-      test("onError()", () {
+      test('onError()', () {
         wrapper.onError(expectAsync1((error) {
-          expect(error, equals("oh no"));
+          expect(error, equals('oh no'));
         }));
-        controller.add("foo");
-        controller.addError("oh no");
+        controller.add('foo');
+        controller.addError('oh no');
       });
 
-      test("onDone()", () {
+      test('onDone()', () {
         wrapper.onDone(expectAsync0(() {}));
-        controller.add("foo");
+        controller.add('foo');
         controller.close();
       });
 
-      test("pause(), resume(), and isPaused", () async {
-        controller.add("foo");
+      test('pause(), resume(), and isPaused', () async {
+        controller.add('foo');
 
         expect(wrapper.isPaused, isFalse);
 
@@ -123,17 +123,17 @@
         expect(wrapper.isPaused, isFalse);
       });
 
-      test("cancel()", () async {
-        controller.add("foo");
+      test('cancel()', () async {
+        controller.add('foo');
 
         wrapper.cancel();
         await flushMicrotasks();
         expect(isCanceled, isTrue);
       });
 
-      test("asFuture()", () {
+      test('asFuture()', () {
         expect(wrapper.asFuture(12), completion(equals(12)));
-        controller.add("foo");
+        controller.add('foo');
         controller.close();
       });
     });
diff --git a/test/utils.dart b/test/utils.dart
index e517c78..b09d06b 100644
--- a/test/utils.dart
+++ b/test/utils.dart
@@ -3,10 +3,10 @@
 // BSD-style license that can be found in the LICENSE file.
 
 /// Helper utilities for testing.
-import "dart:async";
+import 'dart:async';
 
-import "package:async/async.dart";
-import "package:test/test.dart";
+import 'package:async/async.dart';
+import 'package:test/test.dart';
 
 /// A zero-millisecond timer should wait until after all microtasks.
 Future flushMicrotasks() => Future.delayed(Duration.zero);
@@ -17,7 +17,7 @@
 ///
 /// Returns a function that fails the test if it is ever called.
 OptionalArgAction unreachable(String name) =>
-    ([a, b]) => fail("Unreachable: $name");
+    ([a, b]) => fail('Unreachable: $name');
 
 // TODO(nweiz): Use the version of this in test when test#418 is fixed.
 /// A matcher that runs a callback in its own zone and asserts that that zone
@@ -46,9 +46,10 @@
 /// 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 UnimplementedError("Gotcha!");
+class UnusableStream<T> extends Stream<T> {
+  @override
+  StreamSubscription<T> listen(onData, {onError, onDone, cancelOnError}) {
+    throw UnimplementedError('Gotcha!');
   }
 }
 
@@ -60,11 +61,16 @@
 class CompleterStreamSink<T> implements StreamSink<T> {
   final completer = Completer();
 
+  @override
   Future get done => completer.future;
 
+  @override
   void add(T event) {}
+  @override
   void addError(error, [StackTrace stackTrace]) {}
+  @override
   Future addStream(Stream<T> stream) async {}
+  @override
   Future close() => completer.future;
 }
 
@@ -79,6 +85,7 @@
   bool get isClosed => _isClosed;
   var _isClosed = false;
 
+  @override
   Future get done => _doneCompleter.future;
   final _doneCompleter = Completer();
 
@@ -88,22 +95,26 @@
   ///
   /// If [onDone] is passed, it's called when the user calls [close]. Its result
   /// is piped to the [done] future.
-  TestSink({onDone()}) : _onDone = onDone ?? (() {});
+  TestSink({void Function() onDone}) : _onDone = onDone ?? (() {});
 
+  @override
   void add(T event) {
     results.add(Result<T>.value(event));
   }
 
+  @override
   void addError(error, [StackTrace stackTrace]) {
     results.add(Result<T>.error(error, stackTrace));
   }
 
+  @override
   Future addStream(Stream<T> stream) {
     var completer = Completer.sync();
     stream.listen(add, onError: addError, onDone: completer.complete);
     return completer.future;
   }
 
+  @override
   Future close() {
     _isClosed = true;
     _doneCompleter.complete(Future.microtask(_onDone));