diff --git a/pkgs/stream_transform/.travis.yml b/pkgs/stream_transform/.travis.yml
index 326d6cf..e6d16f6 100644
--- a/pkgs/stream_transform/.travis.yml
+++ b/pkgs/stream_transform/.travis.yml
@@ -3,6 +3,7 @@
   only: [master]
 dart:
   - dev
+  - stable
 cache:
   directories:
     - $HOME/.pub-cache
diff --git a/pkgs/stream_transform/lib/src/async_map_buffer.dart b/pkgs/stream_transform/lib/src/async_map_buffer.dart
index 72190d2..f804666 100644
--- a/pkgs/stream_transform/lib/src/async_map_buffer.dart
+++ b/pkgs/stream_transform/lib/src/async_map_buffer.dart
@@ -28,7 +28,7 @@
 /// pending conversions have finished.
 StreamTransformer<S, T> asyncMapBuffer<S, T>(
     Future<T> convert(List<S> collected)) {
-  var workFinished = new StreamController();
+  var workFinished = StreamController();
   // Let the first event through.
   workFinished.add(null);
   return chainTransformers(
diff --git a/pkgs/stream_transform/lib/src/audit.dart b/pkgs/stream_transform/lib/src/audit.dart
index 2463ee6..7b4d767 100644
--- a/pkgs/stream_transform/lib/src/audit.dart
+++ b/pkgs/stream_transform/lib/src/audit.dart
@@ -23,7 +23,7 @@
 
   return fromHandlers(handleData: (T data, EventSink<T> sink) {
     recentData = data;
-    timer ??= new Timer(duration, () {
+    timer ??= Timer(duration, () {
       sink.add(recentData);
       timer = null;
       if (shouldClose) {
diff --git a/pkgs/stream_transform/lib/src/bind.dart b/pkgs/stream_transform/lib/src/bind.dart
index 169653f..eefdc60 100644
--- a/pkgs/stream_transform/lib/src/bind.dart
+++ b/pkgs/stream_transform/lib/src/bind.dart
@@ -10,7 +10,7 @@
 /// Creates a [StreamTransformer] which overrides [StreamTransformer.bind] to
 /// [bindFn].
 StreamTransformer<S, T> fromBind<S, T>(Bind<S, T> bindFn) =>
-    new _StreamTransformer(bindFn);
+    _StreamTransformer(bindFn);
 
 class _StreamTransformer<S, T> extends StreamTransformerBase<S, T> {
   final Bind<S, T> _bind;
diff --git a/pkgs/stream_transform/lib/src/buffer.dart b/pkgs/stream_transform/lib/src/buffer.dart
index 0d9b87f..c05e79a 100644
--- a/pkgs/stream_transform/lib/src/buffer.dart
+++ b/pkgs/stream_transform/lib/src/buffer.dart
@@ -12,8 +12,7 @@
 ///
 /// Errors from the source stream or the trigger are immediately forwarded to
 /// the output.
-StreamTransformer<T, List<T>> buffer<T>(Stream trigger) =>
-    new _Buffer<T>(trigger);
+StreamTransformer<T, List<T>> buffer<T>(Stream trigger) => _Buffer<T>(trigger);
 
 /// A StreamTransformer which aggregates values and emits when it sees a value
 /// on [_trigger].
@@ -32,8 +31,8 @@
   @override
   Stream<List<T>> bind(Stream<T> values) {
     var controller = values.isBroadcast
-        ? new StreamController<List<T>>.broadcast(sync: true)
-        : new StreamController<List<T>>(sync: true);
+        ? StreamController<List<T>>.broadcast(sync: true)
+        : StreamController<List<T>>(sync: true);
 
     List<T> currentResults;
     var waitingForTrigger = true;
diff --git a/pkgs/stream_transform/lib/src/debounce.dart b/pkgs/stream_transform/lib/src/debounce.dart
index 1ff91de..ff3f21f 100644
--- a/pkgs/stream_transform/lib/src/debounce.dart
+++ b/pkgs/stream_transform/lib/src/debounce.dart
@@ -39,7 +39,7 @@
   var shouldClose = false;
   return fromHandlers(handleData: (T value, EventSink<R> sink) {
     timer?.cancel();
-    timer = new Timer(duration, () {
+    timer = Timer(duration, () {
       sink.add(soFar);
       if (shouldClose) {
         sink.close();
diff --git a/pkgs/stream_transform/lib/src/followed_by.dart b/pkgs/stream_transform/lib/src/followed_by.dart
index 22f6945..df506f3 100644
--- a/pkgs/stream_transform/lib/src/followed_by.dart
+++ b/pkgs/stream_transform/lib/src/followed_by.dart
@@ -16,8 +16,7 @@
 /// occur before the first stream is done. If a broadcast stream follows a
 /// single-subscription stream, pausing the stream while it is listening to the
 /// second stream will cause events to be dropped rather than buffered.
-StreamTransformer<T, T> followedBy<T>(Stream<T> next) =>
-    new _FollowedBy<T>(next);
+StreamTransformer<T, T> followedBy<T>(Stream<T> next) => _FollowedBy<T>(next);
 
 class _FollowedBy<T> extends StreamTransformerBase<T, T> {
   final Stream<T> _next;
@@ -27,8 +26,8 @@
   @override
   Stream<T> bind(Stream<T> first) {
     var controller = first.isBroadcast
-        ? new StreamController<T>.broadcast(sync: true)
-        : new StreamController<T>(sync: true);
+        ? StreamController<T>.broadcast(sync: true)
+        : StreamController<T>(sync: true);
 
     var next = first.isBroadcast && !_next.isBroadcast
         ? _next.asBroadcastStream()
diff --git a/pkgs/stream_transform/lib/src/from_handlers.dart b/pkgs/stream_transform/lib/src/from_handlers.dart
index 36a0417..6096c4c 100644
--- a/pkgs/stream_transform/lib/src/from_handlers.dart
+++ b/pkgs/stream_transform/lib/src/from_handlers.dart
@@ -15,7 +15,7 @@
         {HandleData<S, T> handleData,
         HandleError<T> handleError,
         HandleDone<T> handleDone}) =>
-    new _StreamTransformer(
+    _StreamTransformer(
         handleData: handleData,
         handleError: handleError,
         handleDone: handleDone);
@@ -49,8 +49,8 @@
   @override
   Stream<T> bind(Stream<S> values) {
     var controller = values.isBroadcast
-        ? new StreamController<T>.broadcast(sync: true)
-        : new StreamController<T>(sync: true);
+        ? StreamController<T>.broadcast(sync: true)
+        : StreamController<T>(sync: true);
 
     StreamSubscription<S> subscription;
     controller.onListen = () {
diff --git a/pkgs/stream_transform/lib/src/merge.dart b/pkgs/stream_transform/lib/src/merge.dart
index 36d81d3..ead8bc6 100644
--- a/pkgs/stream_transform/lib/src/merge.dart
+++ b/pkgs/stream_transform/lib/src/merge.dart
@@ -9,7 +9,7 @@
 /// If the source stream is a broadcast stream, the result stream will be as
 /// well, regardless of [other]'s type. If a single subscription stream is
 /// merged into a broadcast stream it may never be canceled.
-StreamTransformer<T, T> merge<T>(Stream<T> other) => new _Merge<T>([other]);
+StreamTransformer<T, T> merge<T>(Stream<T> other) => _Merge<T>([other]);
 
 /// Emits values from the source stream and all streams in [others] in any order
 /// as they arrive.
@@ -19,7 +19,7 @@
 /// subscription streams are merged into a broadcast stream they may never be
 /// canceled.
 StreamTransformer<T, T> mergeAll<T>(Iterable<Stream<T>> others) =>
-    new _Merge<T>(others);
+    _Merge<T>(others);
 
 class _Merge<T> extends StreamTransformerBase<T, T> {
   final Iterable<Stream<T>> _others;
@@ -29,8 +29,8 @@
   @override
   Stream<T> bind(Stream<T> first) {
     var controller = first.isBroadcast
-        ? new StreamController<T>.broadcast(sync: true)
-        : new StreamController<T>(sync: true);
+        ? StreamController<T>.broadcast(sync: true)
+        : StreamController<T>(sync: true);
 
     var allStreams = [first]..addAll(_others);
     if (first.isBroadcast) {
diff --git a/pkgs/stream_transform/lib/src/start_with.dart b/pkgs/stream_transform/lib/src/start_with.dart
index 9434748..1ddde0c 100644
--- a/pkgs/stream_transform/lib/src/start_with.dart
+++ b/pkgs/stream_transform/lib/src/start_with.dart
@@ -11,7 +11,7 @@
 ///
 /// If the original stream is a broadcast stream the result will be as well.
 StreamTransformer<T, T> startWith<T>(T initial) =>
-    startWithStream<T>(new Future.value(initial).asStream());
+    startWithStream<T>(Future.value(initial).asStream());
 
 /// Emits all values in [initial] before any values from the original stream.
 ///
@@ -19,7 +19,7 @@
 /// the original stream is a broadcast stream it will miss any events which
 /// occur before the initial values are all emitted.
 StreamTransformer<T, T> startWithMany<T>(Iterable<T> initial) =>
-    startWithStream<T>(new Stream.fromIterable(initial));
+    startWithStream<T>(Stream.fromIterable(initial));
 
 /// Emits all values in [initial] before any values from the original stream.
 ///
diff --git a/pkgs/stream_transform/lib/src/switch.dart b/pkgs/stream_transform/lib/src/switch.dart
index bbd40d4..87ae4ff 100644
--- a/pkgs/stream_transform/lib/src/switch.dart
+++ b/pkgs/stream_transform/lib/src/switch.dart
@@ -24,8 +24,7 @@
 ///
 /// If the source stream is a broadcast stream, the result stream will be as
 /// well, regardless of the types of streams emitted.
-StreamTransformer<Stream<T>, T> switchLatest<T>() =>
-    new _SwitchTransformer<T>();
+StreamTransformer<Stream<T>, T> switchLatest<T>() => _SwitchTransformer<T>();
 
 class _SwitchTransformer<T> extends StreamTransformerBase<Stream<T>, T> {
   const _SwitchTransformer();
@@ -33,8 +32,8 @@
   @override
   Stream<T> bind(Stream<Stream<T>> outer) {
     var controller = outer.isBroadcast
-        ? new StreamController<T>.broadcast(sync: true)
-        : new StreamController<T>(sync: true);
+        ? StreamController<T>.broadcast(sync: true)
+        : StreamController<T>(sync: true);
 
     StreamSubscription<Stream<T>> outerSubscription;
 
diff --git a/pkgs/stream_transform/lib/src/take_until.dart b/pkgs/stream_transform/lib/src/take_until.dart
index 0c10856..522ef30 100644
--- a/pkgs/stream_transform/lib/src/take_until.dart
+++ b/pkgs/stream_transform/lib/src/take_until.dart
@@ -10,7 +10,7 @@
 /// which are emitted before the trigger, but have further asynchronous delays
 /// in transformations following the takeUtil, will still go through. Cancelling
 /// a subscription immediately stops values.
-StreamTransformer<T, T> takeUntil<T>(Future trigger) => new _TakeUntil(trigger);
+StreamTransformer<T, T> takeUntil<T>(Future trigger) => _TakeUntil(trigger);
 
 class _TakeUntil<T> extends StreamTransformerBase<T, T> {
   final Future _trigger;
@@ -20,8 +20,8 @@
   @override
   Stream<T> bind(Stream<T> values) {
     var controller = values.isBroadcast
-        ? new StreamController<T>.broadcast(sync: true)
-        : new StreamController<T>(sync: true);
+        ? StreamController<T>.broadcast(sync: true)
+        : StreamController<T>(sync: true);
 
     StreamSubscription subscription;
     var isDone = false;
diff --git a/pkgs/stream_transform/lib/src/throttle.dart b/pkgs/stream_transform/lib/src/throttle.dart
index b8faa25..475ad92 100644
--- a/pkgs/stream_transform/lib/src/throttle.dart
+++ b/pkgs/stream_transform/lib/src/throttle.dart
@@ -13,7 +13,7 @@
   return fromHandlers(handleData: (data, sink) {
     if (timer == null) {
       sink.add(data);
-      timer = new Timer(duration, () {
+      timer = Timer(duration, () {
         timer = null;
       });
     }
diff --git a/pkgs/stream_transform/pubspec.yaml b/pkgs/stream_transform/pubspec.yaml
index e10a772..81c1043 100644
--- a/pkgs/stream_transform/pubspec.yaml
+++ b/pkgs/stream_transform/pubspec.yaml
@@ -2,10 +2,10 @@
 description: A collection of utilities to transform and manipulate streams.
 author: Dart Team <misc@dartlang.org>
 homepage: https://www.github.com/dart-lang/stream_transform
-version: 0.0.14+1
+version: 0.0.15-dev
 
 environment:
-  sdk: ">=2.0.0-dev.20.0 <3.0.0"
+  sdk: ">=2.0.0 <3.0.0"
 
 dev_dependencies:
-  test: ^0.12.20+13
+  test: ^1.0.0
diff --git a/pkgs/stream_transform/test/async_map_buffer_test.dart b/pkgs/stream_transform/test/async_map_buffer_test.dart
index f8b73a7..f96092a 100644
--- a/pkgs/stream_transform/test/async_map_buffer_test.dart
+++ b/pkgs/stream_transform/test/async_map_buffer_test.dart
@@ -10,8 +10,8 @@
 
 void main() {
   var streamTypes = {
-    'single subscription': () => new StreamController(),
-    'broadcast': () => new StreamController.broadcast()
+    'single subscription': () => StreamController(),
+    'broadcast': () => StreamController.broadcast()
   };
   StreamController values;
   List emittedValues;
@@ -30,7 +30,7 @@
     expect(finishWork, isNull,
         reason: 'See $values befor previous work is complete');
     workArgument = values;
-    finishWork = new Completer();
+    finishWork = Completer();
     finishWork.future.then((_) {
       workArgument = null;
       finishWork = null;
@@ -63,11 +63,11 @@
 
       test('does not emit before work finishes', () async {
         values.add(1);
-        await new Future(() {});
+        await Future(() {});
         expect(emittedValues, isEmpty);
         expect(workArgument, [1]);
         finishWork.complete(workArgument);
-        await new Future(() {});
+        await Future(() {});
         expect(emittedValues, [
           [1]
         ]);
@@ -75,50 +75,50 @@
 
       test('buffers values while work is ongoing', () async {
         values.add(1);
-        await new Future(() {});
+        await Future(() {});
         values.add(2);
         values.add(3);
-        await new Future(() {});
+        await Future(() {});
         finishWork.complete();
-        await new Future(() {});
+        await Future(() {});
         expect(workArgument, [2, 3]);
       });
 
       test('forwards errors without waiting for work', () async {
         values.add(1);
-        await new Future(() {});
+        await Future(() {});
         values.addError('error');
-        await new Future(() {});
+        await Future(() {});
         expect(errors, ['error']);
       });
 
       test('forwards errors which occur during the work', () async {
         values.add(1);
-        await new Future(() {});
+        await Future(() {});
         finishWork.completeError('error');
-        await new Future(() {});
+        await Future(() {});
         expect(errors, ['error']);
       });
 
       test('can continue handling events after an error', () async {
         values.add(1);
-        await new Future(() {});
+        await Future(() {});
         finishWork.completeError('error');
         values.add(2);
-        await new Future(() {});
+        await Future(() {});
         expect(workArgument, [2]);
         finishWork.completeError('another');
-        await new Future(() {});
+        await Future(() {});
         expect(errors, ['error', 'another']);
       });
 
       test('does not start next work early due to an error in values',
           () async {
         values.add(1);
-        await new Future(() {});
+        await Future(() {});
         values.addError('error');
         values.add(2);
-        await new Future(() {});
+        await Future(() {});
         expect(errors, ['error']);
         // [work] will assert that the second iteration is not called because
         // the first has not completed.
@@ -133,29 +133,29 @@
       test('closes when values end if no work is pending', () async {
         expect(isDone, false);
         await values.close();
-        await new Future(() {});
+        await Future(() {});
         expect(isDone, true);
       });
 
       test('waits for pending work when values close', () async {
         values.add(1);
-        await new Future(() {});
+        await Future(() {});
         expect(isDone, false);
         values.add(2);
         await values.close();
         expect(isDone, false);
         finishWork.complete(null);
-        await new Future(() {});
+        await Future(() {});
         // Still a pending value
         expect(isDone, false);
         finishWork.complete(null);
-        await new Future(() {});
+        await Future(() {});
         expect(isDone, true);
       });
 
       test('forwards errors from values', () async {
         values.addError('error');
-        await new Future(() {});
+        await Future(() {});
         expect(errors, ['error']);
       });
 
@@ -164,9 +164,9 @@
           var otherValues = [];
           transformed.listen(otherValues.add);
           values.add(1);
-          await new Future(() {});
+          await Future(() {});
           finishWork.complete('result');
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, ['result']);
           expect(otherValues, ['result']);
         });
@@ -175,30 +175,30 @@
           var otherDone = false;
           transformed.listen(null, onDone: () => otherDone = true);
           values.add(1);
-          await new Future(() {});
+          await Future(() {});
           await values.close();
           expect(isDone, false);
           expect(otherDone, false);
           finishWork.complete();
-          await new Future(() {});
+          await Future(() {});
           expect(isDone, true);
           expect(otherDone, true);
         });
 
         test('can cancel and relisten', () async {
           values.add(1);
-          await new Future(() {});
+          await Future(() {});
           finishWork.complete('first');
-          await new Future(() {});
+          await Future(() {});
           await subscription.cancel();
           values.add(2);
-          await new Future(() {});
+          await Future(() {});
           subscription = transformed.listen(emittedValues.add);
           values.add(3);
-          await new Future(() {});
+          await Future(() {});
           expect(workArgument, [3]);
           finishWork.complete('second');
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, ['first', 'second']);
         });
       }
diff --git a/pkgs/stream_transform/test/async_where_test.dart b/pkgs/stream_transform/test/async_where_test.dart
index 9c66506..9d0c9f2 100644
--- a/pkgs/stream_transform/test/async_where_test.dart
+++ b/pkgs/stream_transform/test/async_where_test.dart
@@ -9,47 +9,47 @@
 
 void main() {
   test('forwards only events that pass the predicate', () async {
-    var values = new Stream.fromIterable([1, 2, 3, 4]);
+    var values = Stream.fromIterable([1, 2, 3, 4]);
     var filtered = values.transform(asyncWhere((e) async => e > 2));
     expect(await filtered.toList(), [3, 4]);
   });
 
   test('allows predicates that go through event loop', () async {
-    var values = new Stream.fromIterable([1, 2, 3, 4]);
+    var values = Stream.fromIterable([1, 2, 3, 4]);
     var filtered = values.transform(asyncWhere((e) async {
-      await new Future(() {});
+      await Future(() {});
       return e > 2;
     }));
     expect(await filtered.toList(), [3, 4]);
   });
 
   test('allows synchronous predicate', () async {
-    var values = new Stream.fromIterable([1, 2, 3, 4]);
+    var values = Stream.fromIterable([1, 2, 3, 4]);
     var filtered = values.transform(asyncWhere((e) => e > 2));
     expect(await filtered.toList(), [3, 4]);
   });
 
   test('can result in empty stream', () async {
-    var values = new Stream.fromIterable([1, 2, 3, 4]);
+    var values = Stream.fromIterable([1, 2, 3, 4]);
     var filtered = values.transform(asyncWhere((e) => e > 4));
     expect(await filtered.isEmpty, true);
   });
 
   test('forwards values to multiple listeners', () async {
-    var values = new StreamController<int>.broadcast();
+    var values = StreamController<int>.broadcast();
     var filtered = values.stream.transform(asyncWhere((e) async => e > 2));
     var firstValues = [];
     var secondValues = [];
     filtered..listen(firstValues.add)..listen(secondValues.add);
     values..add(1)..add(2)..add(3)..add(4);
-    await new Future(() {});
+    await Future(() {});
     expect(firstValues, [3, 4]);
     expect(secondValues, [3, 4]);
   });
 
   test('closes streams with multiple listeners', () async {
-    var values = new StreamController.broadcast();
-    var predicate = new Completer<bool>();
+    var values = StreamController.broadcast();
+    var predicate = Completer<bool>();
     var filtered = values.stream.transform(asyncWhere((_) => predicate.future));
     var firstDone = false;
     var secondDone = false;
@@ -62,7 +62,7 @@
     expect(secondDone, false);
 
     predicate.complete(true);
-    await new Future(() {});
+    await Future(() {});
     expect(firstDone, true);
     expect(secondDone, true);
   });
@@ -70,13 +70,13 @@
   test('forwards errors emitted by the test callback', () async {
     var errors = [];
     var emitted = [];
-    var values = new Stream.fromIterable([1, 2, 3, 4]);
+    var values = Stream.fromIterable([1, 2, 3, 4]);
     var filtered = values.transform(asyncWhere((e) async {
-      await new Future(() {});
-      if (e.isEven) throw new Exception('$e');
+      await Future(() {});
+      if (e.isEven) throw Exception('$e');
       return true;
     }));
-    var done = new Completer();
+    var done = Completer();
     filtered.listen(emitted.add, onError: errors.add, onDone: done.complete);
     await done.future;
     expect(emitted, [1, 3]);
diff --git a/pkgs/stream_transform/test/audit_test.dart b/pkgs/stream_transform/test/audit_test.dart
index b61a8db..55a327e 100644
--- a/pkgs/stream_transform/test/audit_test.dart
+++ b/pkgs/stream_transform/test/audit_test.dart
@@ -11,8 +11,8 @@
 
 void main() {
   var streamTypes = {
-    'single subscription': () => new StreamController(),
-    'broadcast': () => new StreamController.broadcast()
+    'single subscription': () => StreamController(),
+    'broadcast': () => StreamController.broadcast()
   };
   for (var streamType in streamTypes.keys) {
     group('Stream type [$streamType]', () {
@@ -87,9 +87,9 @@
         test('does not starve output if many values come closer than duration',
             () async {
           values.add(1);
-          await new Future.delayed(const Duration(milliseconds: 3));
+          await Future.delayed(const Duration(milliseconds: 3));
           values.add(2);
-          await new Future.delayed(const Duration(milliseconds: 3));
+          await Future.delayed(const Duration(milliseconds: 3));
           values.add(3);
           await waitForTimer(5);
           expect(emittedValues, [2, 3]);
diff --git a/pkgs/stream_transform/test/buffer_test.dart b/pkgs/stream_transform/test/buffer_test.dart
index 4d3a2b6..835a7eb 100644
--- a/pkgs/stream_transform/test/buffer_test.dart
+++ b/pkgs/stream_transform/test/buffer_test.dart
@@ -9,8 +9,8 @@
 
 void main() {
   var streamTypes = {
-    'single subscription': () => new StreamController(),
-    'broadcast': () => new StreamController.broadcast()
+    'single subscription': () => StreamController(),
+    'broadcast': () => StreamController.broadcast()
   };
   StreamController trigger;
   StreamController values;
@@ -59,10 +59,10 @@
 
         test('does not emit before `trigger`', () async {
           values.add(1);
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, isEmpty);
           trigger.add(null);
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, [
             [1]
           ]);
@@ -70,10 +70,10 @@
 
         test('emits immediately if trigger emits before a value', () async {
           trigger.add(null);
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, isEmpty);
           values.add(1);
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, [
             [1]
           ]);
@@ -82,12 +82,12 @@
         test('two triggers in a row - emit then emit next value', () async {
           values.add(1);
           values.add(2);
-          await new Future(() {});
+          await Future(() {});
           trigger.add(null);
           trigger.add(null);
-          await new Future(() {});
+          await Future(() {});
           values.add(3);
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, [
             [1, 2],
             [3]
@@ -96,12 +96,12 @@
 
         test('pre-emptive trigger then trigger after values', () async {
           trigger.add(null);
-          await new Future(() {});
+          await Future(() {});
           values.add(1);
           values.add(2);
-          await new Future(() {});
+          await Future(() {});
           trigger.add(null);
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, [
             [1],
             [2]
@@ -111,10 +111,10 @@
         test('multiple pre-emptive triggers, only emits first value', () async {
           trigger.add(null);
           trigger.add(null);
-          await new Future(() {});
+          await Future(() {});
           values.add(1);
           values.add(2);
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, [
             [1]
           ]);
@@ -123,13 +123,13 @@
         test('groups values between trigger', () async {
           values.add(1);
           values.add(2);
-          await new Future(() {});
+          await Future(() {});
           trigger.add(null);
           values.add(3);
           values.add(4);
-          await new Future(() {});
+          await Future(() {});
           trigger.add(null);
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, [
             [1, 2],
             [3, 4]
@@ -145,7 +145,7 @@
         test('closes when trigger ends', () async {
           expect(isDone, false);
           await trigger.close();
-          await new Future(() {});
+          await Future(() {});
           expect(isDone, true);
         });
 
@@ -156,7 +156,7 @@
           await values.close();
           expect(isDone, false);
           trigger.add(null);
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, [
             [1]
           ]);
@@ -169,7 +169,7 @@
           values.add(1);
           trigger.add(null);
           await values.close();
-          await new Future(() {});
+          await Future(() {});
           expect(isDone, true);
         });
 
@@ -179,7 +179,7 @@
           await trigger.close();
           expect(isDone, false);
           values.add(1);
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, [
             [1]
           ]);
@@ -188,13 +188,13 @@
 
         test('forwards errors from trigger', () async {
           trigger.addError('error');
-          await new Future(() {});
+          await Future(() {});
           expect(errors, ['error']);
         });
 
         test('forwards errors from values', () async {
           values.addError('error');
-          await new Future(() {});
+          await Future(() {});
           expect(errors, ['error']);
         });
       });
@@ -234,18 +234,18 @@
       setUpForStreamTypes(triggerType, 'broadcast');
       values.add(1);
       trigger.add(null);
-      await new Future(() {});
+      await Future(() {});
       expect(emittedValues, [
         [1]
       ]);
       await subscription.cancel();
       values.add(2);
       trigger.add(null);
-      await new Future(() {});
+      await Future(() {});
       subscription = transformed.listen(emittedValues.add);
       values.add(3);
       trigger.add(null);
-      await new Future(() {});
+      await Future(() {});
       expect(emittedValues, [
         [1],
         [3]
diff --git a/pkgs/stream_transform/test/concurrent_async_map_test.dart b/pkgs/stream_transform/test/concurrent_async_map_test.dart
index 9ea11a5..531e941 100644
--- a/pkgs/stream_transform/test/concurrent_async_map_test.dart
+++ b/pkgs/stream_transform/test/concurrent_async_map_test.dart
@@ -10,8 +10,8 @@
 
 void main() {
   var streamTypes = {
-    'single subscription': () => new StreamController(),
-    'broadcast': () => new StreamController.broadcast()
+    'single subscription': () => StreamController(),
+    'broadcast': () => StreamController.broadcast()
   };
   StreamController streamController;
   List emittedValues;
@@ -26,7 +26,7 @@
 
   Future convert(dynamic value) {
     values.add(value);
-    var completer = new Completer();
+    var completer = Completer();
     finishWork.add(completer);
     return completer.future;
   }
@@ -54,11 +54,11 @@
 
       test('does not emit before convert finishes', () async {
         streamController.add(1);
-        await new Future(() {});
+        await Future(() {});
         expect(emittedValues, isEmpty);
         expect(values, [1]);
         finishWork.first.complete(1);
-        await new Future(() {});
+        await Future(() {});
         expect(emittedValues, [1]);
       });
 
@@ -66,36 +66,36 @@
         streamController.add(1);
         streamController.add(2);
         streamController.add(3);
-        await new Future(() {});
+        await Future(() {});
         expect(values, [1, 2, 3]);
       });
 
       test('forwards errors directly without waiting for previous convert',
           () async {
         streamController.add(1);
-        await new Future(() {});
+        await Future(() {});
         streamController.addError('error');
-        await new Future(() {});
+        await Future(() {});
         expect(errors, ['error']);
       });
 
       test('forwards errors which occur during the convert', () async {
         streamController.add(1);
-        await new Future(() {});
+        await Future(() {});
         finishWork.first.completeError('error');
-        await new Future(() {});
+        await Future(() {});
         expect(errors, ['error']);
       });
 
       test('can continue handling events after an error', () async {
         streamController.add(1);
-        await new Future(() {});
+        await Future(() {});
         finishWork[0].completeError('error');
         streamController.add(2);
-        await new Future(() {});
+        await Future(() {});
         expect(values, [1, 2]);
         finishWork[1].completeError('another');
-        await new Future(() {});
+        await Future(() {});
         expect(errors, ['error', 'another']);
       });
 
@@ -108,7 +108,7 @@
       test('closes when values end if no conversion is pending', () async {
         expect(isDone, false);
         await streamController.close();
-        await new Future(() {});
+        await Future(() {});
         expect(isDone, true);
       });
 
@@ -117,9 +117,9 @@
           var otherValues = [];
           transformed.listen(otherValues.add);
           streamController.add(1);
-          await new Future(() {});
+          await Future(() {});
           finishWork.first.complete('result');
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, ['result']);
           expect(otherValues, ['result']);
         });
@@ -128,30 +128,30 @@
           var otherDone = false;
           transformed.listen(null, onDone: () => otherDone = true);
           streamController.add(1);
-          await new Future(() {});
+          await Future(() {});
           await streamController.close();
           expect(isDone, false);
           expect(otherDone, false);
           finishWork.first.complete();
-          await new Future(() {});
+          await Future(() {});
           expect(isDone, true);
           expect(otherDone, true);
         });
 
         test('can cancel and relisten', () async {
           streamController.add(1);
-          await new Future(() {});
+          await Future(() {});
           finishWork.first.complete('first');
-          await new Future(() {});
+          await Future(() {});
           await subscription.cancel();
           streamController.add(2);
-          await new Future(() {});
+          await Future(() {});
           subscription = transformed.listen(emittedValues.add);
           streamController.add(3);
-          await new Future(() {});
+          await Future(() {});
           expect(values, [1, 3]);
           finishWork[1].complete('second');
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, ['first', 'second']);
         });
       }
diff --git a/pkgs/stream_transform/test/debounce_test.dart b/pkgs/stream_transform/test/debounce_test.dart
index 59cb809..a5dc4b6 100644
--- a/pkgs/stream_transform/test/debounce_test.dart
+++ b/pkgs/stream_transform/test/debounce_test.dart
@@ -11,8 +11,8 @@
 
 void main() {
   var streamTypes = {
-    'single subscription': () => new StreamController(),
-    'broadcast': () => new StreamController.broadcast()
+    'single subscription': () => StreamController(),
+    'broadcast': () => StreamController.broadcast()
   };
   for (var streamType in streamTypes.keys) {
     group('Stream type [$streamType]', () {
@@ -70,7 +70,7 @@
           values.add(1);
           await waitForTimer(5);
           await values.close();
-          await new Future(() {});
+          await Future(() {});
           expect(isDone, true);
         });
 
@@ -78,7 +78,7 @@
           values.add(1);
           await waitForTimer(5);
           values.add(2);
-          await new Future(() {});
+          await Future(() {});
           await values.close();
           expect(isDone, false);
           await waitForTimer(5);
diff --git a/pkgs/stream_transform/test/followd_by_test.dart b/pkgs/stream_transform/test/followd_by_test.dart
index 2bff18c..956bf23 100644
--- a/pkgs/stream_transform/test/followd_by_test.dart
+++ b/pkgs/stream_transform/test/followd_by_test.dart
@@ -9,8 +9,8 @@
 
 void main() {
   var streamTypes = {
-    'single subscription': () => new StreamController(),
-    'broadcast': () => new StreamController.broadcast()
+    'single subscription': () => StreamController(),
+    'broadcast': () => StreamController.broadcast()
   };
   for (var firstType in streamTypes.keys) {
     for (var secondType in streamTypes.keys) {
@@ -55,9 +55,9 @@
         test('adds all values from both streams', () async {
           first..add(1)..add(2);
           await first.close();
-          await new Future(() {});
+          await Future(() {});
           second..add(3)..add(4);
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, [1, 2, 3, 4]);
         });
 
@@ -94,10 +94,10 @@
               await first.close();
               subscription.pause();
               second.add(1);
-              await new Future(() {});
+              await Future(() {});
               subscription.resume();
               second.add(2);
-              await new Future(() {});
+              await Future(() {});
               expect(emittedValues, [2]);
             });
           } else {
@@ -106,10 +106,10 @@
               await first.close();
               subscription.pause();
               second.add(1);
-              await new Future(() {});
+              await Future(() {});
               subscription.resume();
               second.add(2);
-              await new Future(() {});
+              await Future(() {});
               expect(emittedValues, [1, 2]);
             });
           }
@@ -121,7 +121,7 @@
             first.add(1);
             subscription = transformed.listen(emittedValues.add);
             first.add(2);
-            await new Future(() {});
+            await Future(() {});
             expect(emittedValues, [2]);
           });
 
@@ -129,10 +129,10 @@
             await first.close();
             await subscription.cancel();
             second.add(2);
-            await new Future(() {});
+            await Future(() {});
             subscription = transformed.listen(emittedValues.add);
             second.add(3);
-            await new Future((() {}));
+            await Future((() {}));
             expect(emittedValues, [3]);
           });
 
@@ -142,11 +142,11 @@
             first.add(1);
             await first.close();
             second.add(2);
-            await new Future(() {});
+            await Future(() {});
             var thirdValues = [];
             transformed.listen(thirdValues.add);
             second.add(3);
-            await new Future(() {});
+            await Future(() {});
             expect(emittedValues, [1, 2, 3]);
             expect(otherValues, [1, 2, 3]);
             expect(thirdValues, [3]);
diff --git a/pkgs/stream_transform/test/from_handlers_test.dart b/pkgs/stream_transform/test/from_handlers_test.dart
index 8240b1c..d77f676 100644
--- a/pkgs/stream_transform/test/from_handlers_test.dart
+++ b/pkgs/stream_transform/test/from_handlers_test.dart
@@ -37,7 +37,7 @@
   group('default from_handlers', () {
     group('Single subscription stream', () {
       setUp(() {
-        setUpForController(new StreamController(), fromHandlers());
+        setUpForController(StreamController(), fromHandlers());
       });
 
       test('has correct stream type', () {
@@ -47,13 +47,13 @@
       test('forwards values', () async {
         values.add(1);
         values.add(2);
-        await new Future(() {});
+        await Future(() {});
         expect(emittedValues, [1, 2]);
       });
 
       test('forwards errors', () async {
         values.addError('error');
-        await new Future(() {});
+        await Future(() {});
         expect(errors, ['error']);
       });
 
@@ -75,7 +75,7 @@
       StreamSubscription subscription2;
 
       setUp(() {
-        setUpForController(new StreamController.broadcast(), fromHandlers());
+        setUpForController(StreamController.broadcast(), fromHandlers());
         emittedValues2 = [];
         errors2 = [];
         isDone2 = false;
@@ -92,14 +92,14 @@
       test('forwards values', () async {
         values.add(1);
         values.add(2);
-        await new Future(() {});
+        await Future(() {});
         expect(emittedValues, [1, 2]);
         expect(emittedValues2, [1, 2]);
       });
 
       test('forwards errors', () async {
         values.addError('error');
-        await new Future(() {});
+        await Future(() {});
         expect(errors, ['error']);
         expect(errors2, ['error']);
       });
@@ -122,7 +122,7 @@
   group('custom handlers', () {
     group('single subscription', () {
       setUp(() async {
-        setUpForController(new StreamController(),
+        setUpForController(StreamController(),
             fromHandlers(handleData: (value, sink) {
           sink.add(value + 1);
         }));
@@ -130,7 +130,7 @@
       test('uses transform from handleData', () async {
         values.add(1);
         values.add(2);
-        await new Future(() {});
+        await Future(() {});
         expect(emittedValues, [2, 3]);
       });
     });
@@ -145,7 +145,7 @@
         doneCallCount = 0;
         errorCallCount = 0;
         setUpForController(
-            new StreamController.broadcast(),
+            StreamController.broadcast(),
             fromHandlers(handleData: (value, sink) {
               dataCallCount++;
             }, handleError: (error, stackTrace, sink) {
@@ -159,7 +159,7 @@
 
       test('handles data once', () async {
         values.add(1);
-        await new Future(() {});
+        await Future(() {});
         expect(dataCallCount, 1);
       });
 
@@ -170,7 +170,7 @@
 
       test('handles errors once', () async {
         values.addError('error');
-        await new Future(() {});
+        await Future(() {});
         expect(errorCallCount, 1);
       });
     });
diff --git a/pkgs/stream_transform/test/merge_test.dart b/pkgs/stream_transform/test/merge_test.dart
index 75df0e8..cf576ac 100644
--- a/pkgs/stream_transform/test/merge_test.dart
+++ b/pkgs/stream_transform/test/merge_test.dart
@@ -11,8 +11,8 @@
 void main() {
   group('merge', () {
     test('includes all values', () async {
-      var first = new Stream.fromIterable([1, 2, 3]);
-      var second = new Stream.fromIterable([4, 5, 6]);
+      var first = Stream.fromIterable([1, 2, 3]);
+      var second = Stream.fromIterable([4, 5, 6]);
       var allValues = await first.transform(merge(second)).toList();
       expect(allValues, containsAllInOrder([1, 2, 3]));
       expect(allValues, containsAllInOrder([4, 5, 6]));
@@ -21,12 +21,12 @@
 
     test('cancels both sources', () async {
       var firstCanceled = false;
-      var first = new StreamController()
+      var first = StreamController()
         ..onCancel = () {
           firstCanceled = true;
         };
       var secondCanceled = false;
-      var second = new StreamController()
+      var second = StreamController()
         ..onCancel = () {
           secondCanceled = true;
         };
@@ -38,8 +38,8 @@
     });
 
     test('completes when both sources complete', () async {
-      var first = new StreamController();
-      var second = new StreamController();
+      var first = StreamController();
+      var second = StreamController();
       var isDone = false;
       first.stream.transform(merge(second.stream)).listen((_) {}, onDone: () {
         isDone = true;
@@ -51,14 +51,14 @@
     });
 
     test('can cancel and relisten to broadcast stream', () async {
-      var first = new StreamController.broadcast();
-      var second = new StreamController();
+      var first = StreamController.broadcast();
+      var second = StreamController();
       var emittedValues = [];
       var transformed = first.stream.transform((merge(second.stream)));
       var subscription = transformed.listen(emittedValues.add);
       first.add(1);
       second.add(2);
-      await new Future(() {});
+      await Future(() {});
       expect(emittedValues, contains(1));
       expect(emittedValues, contains(2));
       await subscription.cancel();
@@ -66,7 +66,7 @@
       subscription = transformed.listen(emittedValues.add);
       first.add(3);
       second.add(4);
-      await new Future(() {});
+      await Future(() {});
       expect(emittedValues, contains(3));
       expect(emittedValues, contains(4));
     });
@@ -74,9 +74,9 @@
 
   group('mergeAll', () {
     test('includes all values', () async {
-      var first = new Stream.fromIterable([1, 2, 3]);
-      var second = new Stream.fromIterable([4, 5, 6]);
-      var third = new Stream.fromIterable([7, 8, 9]);
+      var first = Stream.fromIterable([1, 2, 3]);
+      var second = Stream.fromIterable([4, 5, 6]);
+      var third = Stream.fromIterable([7, 8, 9]);
       var allValues = await first.transform(mergeAll([second, third])).toList();
       expect(allValues, containsAllInOrder([1, 2, 3]));
       expect(allValues, containsAllInOrder([4, 5, 6]));
@@ -86,17 +86,17 @@
 
     test('handles mix of broadcast and single-subscription', () async {
       var firstCanceled = false;
-      var first = new StreamController.broadcast()
+      var first = StreamController.broadcast()
         ..onCancel = () {
           firstCanceled = true;
         };
       var secondBroadcastCanceled = false;
-      var secondBroadcast = new StreamController.broadcast()
+      var secondBroadcast = StreamController.broadcast()
         ..onCancel = () {
           secondBroadcastCanceled = true;
         };
       var secondSingleCanceled = false;
-      var secondSingle = new StreamController()
+      var secondSingle = StreamController()
         ..onCancel = () {
           secondSingleCanceled = true;
         };
@@ -114,7 +114,7 @@
       secondBroadcast.add(2);
       secondSingle.add(3);
 
-      await new Future(() {});
+      await Future(() {});
       await firstSubscription.cancel();
 
       expect(firstCanceled, false);
@@ -125,10 +125,10 @@
       secondBroadcast.add(5);
       secondSingle.add(6);
 
-      await new Future(() {});
+      await Future(() {});
       await secondSubscription.cancel();
 
-      await new Future(() {});
+      await Future(() {});
       expect(firstCanceled, true);
       expect(secondBroadcastCanceled, true);
       expect(secondSingleCanceled, false,
diff --git a/pkgs/stream_transform/test/scan_test.dart b/pkgs/stream_transform/test/scan_test.dart
index b2b9760..db95885 100644
--- a/pkgs/stream_transform/test/scan_test.dart
+++ b/pkgs/stream_transform/test/scan_test.dart
@@ -11,7 +11,7 @@
 void main() {
   group('Scan', () {
     test('produces intermediate values', () async {
-      var source = new Stream.fromIterable([1, 2, 3, 4]);
+      var source = Stream.fromIterable([1, 2, 3, 4]);
       var sum = (int x, int y) => x + y;
       var result = await source.transform(scan(0, sum)).toList();
 
@@ -19,7 +19,7 @@
     });
 
     test('can create a broadcast stream', () async {
-      var source = new StreamController.broadcast();
+      var source = StreamController.broadcast();
 
       var transformed = source.stream.transform(scan(null, null));
 
diff --git a/pkgs/stream_transform/test/start_with_test.dart b/pkgs/stream_transform/test/start_with_test.dart
index 97f0529..c02e2a3 100644
--- a/pkgs/stream_transform/test/start_with_test.dart
+++ b/pkgs/stream_transform/test/start_with_test.dart
@@ -10,8 +10,8 @@
 
 void main() {
   var streamTypes = {
-    'single subscription': () => new StreamController(),
-    'broadcast': () => new StreamController.broadcast()
+    'single subscription': () => StreamController(),
+    'broadcast': () => StreamController.broadcast()
   };
   StreamController values;
   Stream transformed;
@@ -35,7 +35,7 @@
 
       test('outputs all values', () async {
         values..add(2)..add(3);
-        await new Future(() {});
+        await Future(() {});
         expect(emittedValues, [1, 2, 3]);
       });
 
@@ -53,12 +53,12 @@
       if (streamType == 'broadcast') {
         test('can cancel and relisten', () async {
           values.add(2);
-          await new Future(() {});
+          await Future(() {});
           await subscription.cancel();
           subscription = transformed.listen(emittedValues.add);
           values.add(3);
-          await new Future(() {});
-          await new Future(() {});
+          await Future(() {});
+          await Future(() {});
           expect(emittedValues, [1, 2, 3]);
         });
       }
@@ -68,12 +68,12 @@
       setUp(() async {
         setupForStreamType(streamType, startWithMany([1, 2]));
         // Ensure all initial values go through
-        await new Future(() {});
+        await Future(() {});
       });
 
       test('outputs all values', () async {
         values..add(3)..add(4);
-        await new Future(() {});
+        await Future(() {});
         expect(emittedValues, [1, 2, 3, 4]);
       });
 
@@ -91,11 +91,11 @@
       if (streamType == 'broadcast') {
         test('can cancel and relisten', () async {
           values.add(3);
-          await new Future(() {});
+          await Future(() {});
           await subscription.cancel();
           subscription = transformed.listen(emittedValues.add);
           values.add(4);
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, [1, 2, 3, 4]);
         });
       }
@@ -113,7 +113,7 @@
           starting..add(1)..add(2);
           await starting.close();
           values..add(3)..add(4);
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, [1, 2, 3, 4]);
         });
 
@@ -128,13 +128,13 @@
         if (streamType == 'broadcast') {
           test('can cancel and relisten during starting', () async {
             starting.add(1);
-            await new Future(() {});
+            await Future(() {});
             await subscription.cancel();
             subscription = transformed.listen(emittedValues.add);
             starting.add(2);
             await starting.close();
             values..add(3)..add(4);
-            await new Future(() {});
+            await Future(() {});
             expect(emittedValues, [1, 2, 3, 4]);
           });
 
@@ -142,11 +142,11 @@
             starting..add(1)..add(2);
             await starting.close();
             values.add(3);
-            await new Future(() {});
+            await Future(() {});
             await subscription.cancel();
             subscription = transformed.listen(emittedValues.add);
             values.add(4);
-            await new Future(() {});
+            await Future(() {});
             expect(emittedValues, [1, 2, 3, 4]);
           });
         }
diff --git a/pkgs/stream_transform/test/switch_test.dart b/pkgs/stream_transform/test/switch_test.dart
index f5ac19a..8fb190d 100644
--- a/pkgs/stream_transform/test/switch_test.dart
+++ b/pkgs/stream_transform/test/switch_test.dart
@@ -10,8 +10,8 @@
 
 void main() {
   var streamTypes = {
-    'single subscription': () => new StreamController(),
-    'broadcast': () => new StreamController.broadcast()
+    'single subscription': () => StreamController(),
+    'broadcast': () => StreamController.broadcast()
   };
   for (var outerType in streamTypes.keys) {
     for (var innerType in streamTypes.keys) {
@@ -52,40 +52,40 @@
 
         test('forwards events', () async {
           outer.add(first.stream);
-          await new Future(() {});
+          await Future(() {});
           first.add(1);
           first.add(2);
-          await new Future(() {});
+          await Future(() {});
 
           outer.add(second.stream);
-          await new Future(() {});
+          await Future(() {});
           second.add(3);
           second.add(4);
-          await new Future(() {});
+          await Future(() {});
 
           expect(emittedValues, [1, 2, 3, 4]);
         });
 
         test('forwards errors from outer Stream', () async {
           outer.addError('error');
-          await new Future(() {});
+          await Future(() {});
           expect(errors, ['error']);
         });
 
         test('forwards errors from inner Stream', () async {
           outer.add(first.stream);
-          await new Future(() {});
+          await Future(() {});
           first.addError('error');
-          await new Future(() {});
+          await Future(() {});
           expect(errors, ['error']);
         });
 
         test('closes when final stream is done', () async {
           outer.add(first.stream);
-          await new Future(() {});
+          await Future(() {});
 
           outer.add(second.stream);
-          await new Future(() {});
+          await Future(() {});
 
           await outer.close();
           expect(isDone, false);
@@ -98,7 +98,7 @@
             'closes when outer stream closes if latest inner stream already '
             'closed', () async {
           outer.add(first.stream);
-          await new Future(() {});
+          await Future(() {});
           await first.close();
           expect(isDone, false);
 
@@ -108,20 +108,20 @@
 
         test('cancels listeners on previous streams', () async {
           outer.add(first.stream);
-          await new Future(() {});
+          await Future(() {});
 
           outer.add(second.stream);
-          await new Future(() {});
+          await Future(() {});
           expect(firstCanceled, true);
         });
 
         test('cancels listener on current and outer stream on cancel',
             () async {
           outer.add(first.stream);
-          await new Future(() {});
+          await Future(() {});
           await subscription.cancel();
 
-          await new Future(() {});
+          await Future(() {});
           expect(outerCanceled, true);
           expect(firstCanceled, true);
         });
@@ -131,22 +131,22 @@
 
   group('switchMap', () {
     test('uses map function', () async {
-      var outer = new StreamController<List>();
+      var outer = StreamController<List>();
 
       var values = [];
       outer.stream
-          .transform(switchMap((l) => new Stream.fromIterable(l)))
+          .transform(switchMap((l) => Stream.fromIterable(l)))
           .listen(values.add);
 
       outer.add([1, 2, 3]);
-      await new Future(() {});
+      await Future(() {});
       outer.add([4, 5, 6]);
-      await new Future(() {});
+      await Future(() {});
       expect(values, [1, 2, 3, 4, 5, 6]);
     });
 
     test('can create a broadcast stream', () async {
-      var outer = new StreamController.broadcast();
+      var outer = StreamController.broadcast();
 
       var transformed = outer.stream.transform(switchMap(null));
 
diff --git a/pkgs/stream_transform/test/take_until_test.dart b/pkgs/stream_transform/test/take_until_test.dart
index 1ed2f79..3c7bb1b 100644
--- a/pkgs/stream_transform/test/take_until_test.dart
+++ b/pkgs/stream_transform/test/take_until_test.dart
@@ -10,8 +10,8 @@
 
 void main() {
   var streamTypes = {
-    'single subscription': () => new StreamController(),
-    'broadcast': () => new StreamController.broadcast()
+    'single subscription': () => StreamController(),
+    'broadcast': () => StreamController.broadcast()
   };
   for (var streamType in streamTypes.keys) {
     group('takeUntil on Stream type [$streamType]', () {
@@ -33,7 +33,7 @@
         emittedValues = [];
         errors = [];
         isDone = false;
-        closeTrigger = new Completer();
+        closeTrigger = Completer();
         transformed = values.stream.transform(takeUntil(closeTrigger.future));
         subscription = transformed
             .listen(emittedValues.add, onError: errors.add, onDone: () {
@@ -49,13 +49,13 @@
       test('lets values through before trigger', () async {
         values.add(1);
         values.add(2);
-        await new Future(() {});
+        await Future(() {});
         expect(emittedValues, [1, 2]);
       });
 
       test('forwards errors', () async {
         values.addError('error');
-        await new Future(() {});
+        await Future(() {});
         expect(errors, ['error']);
       });
 
@@ -66,13 +66,13 @@
 
       test('sends done when trigger fires', () async {
         closeTrigger.complete();
-        await new Future(() {});
+        await Future(() {});
         expect(isDone, true);
       });
 
       test('cancels value subscription when trigger fires', () async {
         closeTrigger.complete();
-        await new Future(() {});
+        await Future(() {});
         expect(valuesCanceled, true);
       });
 
@@ -82,7 +82,7 @@
           transformed.listen(otherValues.add);
           values.add(1);
           values.add(2);
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, [1, 2]);
           expect(otherValues, [1, 2]);
         });
@@ -91,7 +91,7 @@
           var otherDone = false;
           transformed.listen(null, onDone: () => otherDone = true);
           closeTrigger.complete();
-          await new Future(() {});
+          await Future(() {});
           expect(otherDone, true);
           expect(isDone, true);
         });
@@ -106,13 +106,13 @@
 
         test('can cancel and relisten before trigger fires', () async {
           values.add(1);
-          await new Future(() {});
+          await Future(() {});
           await subscription.cancel();
           values.add(2);
-          await new Future(() {});
+          await Future(() {});
           subscription = transformed.listen(emittedValues.add);
           values.add(3);
-          await new Future(() {});
+          await Future(() {});
           expect(emittedValues, [1, 3]);
         });
       }
diff --git a/pkgs/stream_transform/test/tap_test.dart b/pkgs/stream_transform/test/tap_test.dart
index ffdabba..989c342 100644
--- a/pkgs/stream_transform/test/tap_test.dart
+++ b/pkgs/stream_transform/test/tap_test.dart
@@ -11,45 +11,45 @@
 void main() {
   test('calls function for values', () async {
     var valuesSeen = [];
-    var stream = new Stream.fromIterable([1, 2, 3]);
+    var stream = Stream.fromIterable([1, 2, 3]);
     await stream.transform(tap(valuesSeen.add)).last;
     expect(valuesSeen, [1, 2, 3]);
   });
 
   test('forwards values', () async {
-    var stream = new Stream.fromIterable([1, 2, 3]);
+    var stream = Stream.fromIterable([1, 2, 3]);
     var values = await stream.transform(tap((_) {})).toList();
     expect(values, [1, 2, 3]);
   });
 
   test('calls function for errors', () async {
     var error;
-    var source = new StreamController();
+    var source = StreamController();
     source.stream
         .transform(tap((_) {}, onError: (e, st) {
           error = e;
         }))
         .listen((_) {}, onError: (_) {});
     source.addError('error');
-    await new Future(() {});
+    await Future(() {});
     expect(error, 'error');
   });
 
   test('forwards errors', () async {
     var error;
-    var source = new StreamController();
+    var source = StreamController();
     source.stream.transform(tap((_) {}, onError: (e, st) {})).listen((_) {},
         onError: (e) {
       error = e;
     });
     source.addError('error');
-    await new Future(() {});
+    await Future(() {});
     expect(error, 'error');
   });
 
   test('calls function on done', () async {
     var doneCalled = false;
-    var source = new StreamController();
+    var source = StreamController();
     source.stream
         .transform((tap((_) {}, onDone: () {
           doneCalled = true;
@@ -62,14 +62,14 @@
   test('forwards only once with multiple listeners on a broadcast stream',
       () async {
     var dataCallCount = 0;
-    var source = new StreamController.broadcast();
+    var source = StreamController.broadcast();
     source.stream.transform(tap((_) {
       dataCallCount++;
     }))
       ..listen((_) {})
       ..listen((_) {});
     source.add(1);
-    await new Future(() {});
+    await Future(() {});
     expect(dataCallCount, 1);
   });
 
@@ -77,21 +77,21 @@
       'forwards errors only once with multiple listeners on a broadcast stream',
       () async {
     var errorCallCount = 0;
-    var source = new StreamController.broadcast();
+    var source = StreamController.broadcast();
     source.stream.transform(tap((_) {}, onError: (_, __) {
       errorCallCount++;
     }))
       ..listen((_) {}, onError: (_, __) {})
       ..listen((_) {}, onError: (_, __) {});
     source.addError('error');
-    await new Future(() {});
+    await Future(() {});
     expect(errorCallCount, 1);
   });
 
   test('calls onDone only once with multiple listeners on a broadcast stream',
       () async {
     var doneCallCount = 0;
-    var source = new StreamController.broadcast();
+    var source = StreamController.broadcast();
     source.stream.transform(tap((_) {}, onDone: () {
       doneCallCount++;
     }))
@@ -102,20 +102,20 @@
   });
 
   test('forwards values to multiple listeners', () async {
-    var source = new StreamController.broadcast();
+    var source = StreamController.broadcast();
     var emittedValues1 = [];
     var emittedValues2 = [];
     source.stream.transform(tap((_) {}))
       ..listen(emittedValues1.add)
       ..listen(emittedValues2.add);
     source.add(1);
-    await new Future(() {});
+    await Future(() {});
     expect(emittedValues1, [1]);
     expect(emittedValues2, [1]);
   });
 
   test('allows null callback', () async {
-    var stream = new Stream.fromIterable([1, 2, 3]);
+    var stream = Stream.fromIterable([1, 2, 3]);
     await stream.transform(tap(null)).last;
   });
 }
diff --git a/pkgs/stream_transform/test/throttle_test.dart b/pkgs/stream_transform/test/throttle_test.dart
index 94e1851..b0b839d 100644
--- a/pkgs/stream_transform/test/throttle_test.dart
+++ b/pkgs/stream_transform/test/throttle_test.dart
@@ -11,8 +11,8 @@
 
 void main() {
   var streamTypes = {
-    'single subscription': () => new StreamController(),
-    'broadcast': () => new StreamController.broadcast()
+    'single subscription': () => StreamController(),
+    'broadcast': () => StreamController.broadcast()
   };
   for (var streamType in streamTypes.keys) {
     group('Stream type [$streamType]', () {
@@ -79,7 +79,7 @@
             var otherValues = [];
             transformed.listen(otherValues.add);
             values.add(1);
-            await new Future(() {});
+            await Future(() {});
             expect(emittedValues, [1]);
             expect(otherValues, [1]);
           });
diff --git a/pkgs/stream_transform/test/utils.dart b/pkgs/stream_transform/test/utils.dart
index 4e38ef7..2bb7679 100644
--- a/pkgs/stream_transform/test/utils.dart
+++ b/pkgs/stream_transform/test/utils.dart
@@ -7,5 +7,5 @@
 /// Cycle the event loop to ensure timers are started, then wait for a delay
 /// longer than [milliseconds] to allow for the timer to fire.
 Future waitForTimer(int milliseconds) =>
-    new Future(() {/* ensure Timer is started*/}).then((_) =>
-        new Future.delayed(new Duration(milliseconds: milliseconds + 1)));
+    Future(() {/* ensure Timer is started*/})
+        .then((_) => Future.delayed(Duration(milliseconds: milliseconds + 1)));