Add a ScheduledStream class and some stream matchers.

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';
 
 /// A pair of values.
 class Pair<E, F> {
   E first;
   F last;
 
   Pair(this.first, this.last);
 
   String toString() => '($first, $last)';
 
   bool operator==(other) {
     if (other is! Pair) return false;
     return other.first == first && other.last == last;
   }
 
   int get hashCode => first.hashCode ^ last.hashCode;
 }
 
+/// A class that represents a value or an error.
+class Fallible<E> {
+  /// Whether [this] has a [value], as opposed to an [error].
+  final bool hasValue;
+
+  /// Whether [this] has an [error], as opposed to a [value].
+  bool get hasError => !hasValue;
+
+  /// The value.
+  ///
+  /// This will be `null` if [this] has an [error].
+  final E _value;
+
+  /// The value.
+  ///
+  /// This will throw a [StateError] if [this] has an [error].
+  E get value {
+    if (hasValue) return _value;
+    throw new StateError("Fallible has no value.\n"
+        "$_error$_stackTraceSuffix");
+  }
+
+  /// The error.
+  ///
+  /// This will be `null` if [this] has a [value].
+  final _error;
+
+  /// The error.
+  ///
+  /// This will throw a [StateError] if [this] has a [value].
+  get error {
+    if (hasError) return _error;
+    throw new StateError("Fallible has no error.");
+  }
+
+  /// The stack trace for [_error].
+  ///
+  /// This will be `null` if [this] has a [value], or if no stack trace was
+  /// provided.
+  final StackTrace _stackTrace;
+
+  /// The stack trace for [error].
+  ///
+  /// This will throw a [StateError] if [this] has a [value].
+  StackTrace get stackTrace {
+    if (hasError) return _stackTrace;
+    throw new StateError("Fallible has no error.");
+  }
+
+  Fallible.withValue(this._value)
+      : hasValue = true;
+
+  Fallible.withError(this._error, [this._stackTrace])
+      : hasValue = false;
+
+  /// Returns a completed Future with the same value or error as [this].
+  Future toFuture() {
+    if (hasValue) return new Future.value(value);
+    return new Future.error(error, stackTrace);
+  }
+
+  String toString() {
+    if (hasValue) return "Fallible value: $value";
+    return "Fallible error: $error$_stackTraceSuffix";
+  }
+
+  String get _stackTraceSuffix {
+    if (stackTrace == null) return "";
+    return "\nStack trace:\n${new Chain.from(_stackTrace).terse}";
+  }
+}
+
 /// Configures [future] so that its result (success or exception) is passed on
 /// to [completer].
 void chainToCompleter(Future future, Completer completer) {
   future.then(completer.complete, onError: completer.completeError);
 }
 
 /// Like [Future.sync], but wraps the Future in [Chain.track] as well.
 Future syncFuture(callback()) => Chain.track(new Future.sync(callback));
 
 /// Prepends each line in [text] with [prefix]. If [firstPrefix] is passed, the
@@ skipping 186 matching lines @@
 /// Returns whether [pattern] matches all of [string].
 bool fullMatch(String string, Pattern pattern) {
   var matches = pattern.allMatches(string);
   if (matches.isEmpty) return false;
   return matches.first.start == 0 && matches.first.end == string.length;
 }
 
 /// Returns a string representation of [trace] that has the core and test frames
 /// folded together.
 String terseTraceString(StackTrace trace) {
-  return new Chain(new Chain.forTrace(trace).traces.map((trace) {
-    return trace.foldFrames((frame) {
-      return frame.package == 'scheduled_test' ||
-             frame.package == 'unittest' ||
-             frame.package == 'stack_trace' ||
-             frame.isCore;
-    });
-  })).terse.toString().trim();
+  return new Chain.forTrace(trace).terse.toString().trim();
 }