Accommodate a race condition in pkg/scheduled_test/scheduled_process_test.

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';
 
 /// A pair of values.
 class Pair<E, F> {
@@ skipping 86 matching lines @@
       completer.completeError(e.error, e.stackTrace);
     }
   }, onDone: () {
     if (!cancelled) {
       completer.completeError(new StateError("No elements"));
     }
   }, unsubscribeOnError: true);
   return completer.future;
 }
 
-/// Returns a wrapped version of [stream] along with a [StreamSubscription] that
-/// can be used to control the wrapped stream.
-Pair<Stream, StreamSubscription> streamWithSubscription(Stream stream) {
+/// A function that can be called to cancel a [Stream] and send a done message.
+typedef void StreamCanceller();
+
+// TODO(nweiz): use a StreamSubscription when issue 9026 is fixed.
+/// Returns a wrapped version of [stream] along with a function that will cancel
+/// the wrapped stream. Unlike [StreamSubscription], this canceller will send a
+/// "done" message to the wrapped stream.
+Pair<Stream, StreamCanceller> streamWithCanceller(Stream stream) {
   var controller = stream.isBroadcast ?
       new StreamController.broadcast() :
       new StreamController();
-  var subscription = stream.listen(controller.add,
-      onError: controller.signalError,
-      onDone: controller.close);
-  return new Pair<Stream, StreamSubscription>(controller.stream, subscription);
+  var subscription = stream.listen((value) {
+    if (!controller.isClosed) controller.add(value);
+  }, onError: (error) {
+    if (!controller.isClosed) controller.signalError(error);
+  }, onDone: controller.close);
+  return new Pair<Stream, StreamCanceller>(controller.stream, controller.close);
 }
 
 // TODO(nweiz): remove this when issue 7787 is fixed.
 /// Creates two single-subscription [Stream]s that each emit all values and
 /// errors from [stream]. This is useful if [stream] is single-subscription but
 /// multiple subscribers are necessary.
 Pair<Stream, Stream> tee(Stream stream) {
   var controller1 = new StreamController();
   var controller2 = new StreamController();
   stream.listen((value) {
@@ skipping 26 matching lines @@
         .then((resolved) => new Pair(key, resolved)));
   });
   return Future.wait(pairs).then((resolvedPairs) {
     var map = {};
     for (var pair in resolvedPairs) {
       map[pair.first] = pair.last;
     }
     return map;
   });
 }