Add an Environment class that's exposed through RunnerSuite.

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 test.utils;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:math' as math;
 
 import 'package:crypto/crypto.dart';
 import 'package:path/path.dart' as p;
 import 'package:shelf/shelf.dart' as shelf;
 import 'package:stack_trace/stack_trace.dart';
 
 import 'backend/operating_system.dart';
+import 'util/cancelable_future.dart';
 import 'util/path_handler.dart';
+import 'util/stream_queue.dart';
 
 /// The maximum console line length.
 const _lineLength = 100;
 
 /// A typedef for a possibly-asynchronous function.
 ///
 /// The return type should only ever by [Future] or void.
 typedef AsyncFunction();
 
 /// A typedef for a zero-argument callback function.
@@ skipping 286 matching lines @@
   }, onError: (error, stackTrace) {
     completer.completeError(error, stackTrace);
     subscription.cancel();
   }, onDone: () {
     completer.complete();
   });
 
   return completer.future;
 }
 
+CancelableFuture cancelableNext(StreamQueue queue) {
+  var fork = queue.fork();
+  var completer = new CancelableCompleter(() => fork.cancel(immediate: true));
+  completer.complete(fork.next.then((_) {
+    fork.cancel();
+    return queue.next;
+  }));
+  return completer.future;
+}
+
+Future race(Iterable<CancelableFuture> futures) {
+  var completer = new Completer.sync();
+  for (var future in futures) {
+    future.then((value) {
+      if (!completer.isCompleted) completer.complete(value);
+    }).catchError((error, stackTrace) {
+      if (!completer.isCompleted) completer.completeError(error, stackTrace);
+    });
+  }
+
+  return completer.future.whenComplete(() {
+    for (var future in futures) {
+      future.cancel();
+    }
+  });
+}
+
 /// Returns a stream that emits [error] and [stackTrace], then closes.
 ///
 /// This is useful for adding errors to streams defined via `async*`.
 Stream errorStream(error, StackTrace stackTrace) {
   var controller = new StreamController();
   controller.addError(error, stackTrace);
   controller.close();
   return controller.stream;
 }
 
@@ skipping 56 matching lines @@
   }
 }
 
 /// Returns middleware that nests all requests beneath the URL prefix [beneath].
 shelf.Middleware nestingMiddleware(String beneath) {
   return (handler) {
     var pathHandler = new PathHandler()..add(beneath, handler);
     return pathHandler.handler;
   };
 }