Expose the Observatory URL when debugging.

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;
 
@@ skipping 321 matching lines @@
 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;
 }
 
-/// Returns the result of whichever of [futures] completes first, and cancels
-/// the others.
-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);
+/// Returns a single-subscription stream that emits the results of [futures] in
+/// the order they complete.
+///
+/// If any futures in [futures] are [CancelableFuture]s, this will cancel them
+/// if the subscription is canceled.
+Stream inCompletionOrder(Iterable<Future> futures) {
+  var futureSet = futures.toSet();
+  var controller = new StreamController(sync: true, onCancel: () {
+    return Future.wait(futureSet.map((future) {
+      return future is CancelableFuture ? future.cancel() : null;
+    }).where((future) => future != null));
+  });
+
+  for (var future in futureSet) {
+    future.then(controller.add).catchError(controller.addError)
+        .whenComplete(() {
+      futureSet.remove(future);
+      if (futureSet.isEmpty) controller.close();
     });
   }
 
-  return completer.future.whenComplete(() {
-    for (var future in futures) {
-      future.cancel();
-    }
-  });
+  return controller.stream;
 }
 
 /// 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 58 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;
   };
 }