Refactor Future constructors.

pkg/scheduled_test/lib/src/utils.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library utils;
 
 import 'dart:async';
 
 import 'package:stack_trace/stack_trace.dart';
 
@@ skipping 32 matching lines @@
   var firstLine = "$firstPrefix${lines.first}";
   lines = lines.skip(1).map((line) => '$prefix$line').toList();
   lines.insert(0, firstLine);
   return lines.join('\n');
 }
 
 /// Returns a [Future] that completes after pumping the event queue [times]
 /// times. By default, this should pump the event queue enough times to allow
 /// any code to run, as long as it's not waiting on some external event.
 Future pumpEventQueue([int times=20]) {
-  if (times == 0) return new Future.immediate(null);
-  return new Future.immediate(null).then((_) => pumpEventQueue(times - 1));
+  if (times == 0) return new Future.value();
+  return new Future.value().then((_) => pumpEventQueue(times - 1));
 }
 
 /// Returns whether [iterable1] has the same elements in the same order as
 /// [iterable2]. The elements are compared using `==`.
 bool orderedIterableEquals(Iterable iterable1, Iterable iterable2) {
   var iter1 = iterable1.iterator;
   var iter2 = iterable2.iterator;
 
   while (true) {
     var hasNext1 = iter1.moveNext();
     var hasNext2 = iter2.moveNext();
     if (hasNext1 != hasNext2) return false;
     if (!hasNext1) return true;
     if (iter1.current != iter2.current) return false;
   }
 }
 
 // TODO(nweiz): remove this when issue 8731 is fixed.
 /// Returns a [Stream] that will immediately emit [error] and then close.
-Stream errorStream(error) => new Future.immediateError(error).asStream();
+Stream errorStream(error) => new Future.error(error).asStream();
 
 /// Returns a buffered stream that will emit the same values as the stream
 /// returned by [future] once [future] completes. If [future] completes to an
 /// error, the return value will emit that error and then close.
 Stream futureStream(Future<Stream> future) {
   var controller = new StreamController();
   future.then((stream) {
     stream.listen(
         controller.add,
         onError: (error) => controller.addError(error),
@@ skipping 70 matching lines @@
 
 /// Takes a simple data structure (composed of [Map]s, [Iterable]s, scalar
 /// objects, and [Future]s) and recursively resolves all the [Future]s contained
 /// within. Completes with the fully resolved structure.
 Future awaitObject(object) {
   // Unroll nested futures.
   if (object is Future) return object.then(awaitObject);
   if (object is Iterable) {
     return Future.wait(object.map(awaitObject).toList());
   }
-  if (object is! Map) return new Future.immediate(object);
+  if (object is! Map) return new Future.value(object);
 
   var pairs = <Future<Pair>>[];
   object.forEach((key, value) {
     pairs.add(awaitObject(value)
         .then((resolved) => new Pair(key, resolved)));
   });
   return Future.wait(pairs).then((resolvedPairs) {
     var map = {};
     for (var pair in resolvedPairs) {
       map[pair.first] = pair.last;
@@ skipping 10 matching lines @@
 }
 
 /// Returns a string representation of [trace] that has the core and test frames
 /// folded together.
 String terseTraceString(StackTrace trace) {
   return new Trace.from(trace).terse.foldFrames((frame) {
     return frame.package == 'scheduled_test' || frame.package == 'unittest' ||
         frame.isCore;
   }).toString().trim();
 }