Support serving from multiple directories using "pub serve".

pkg/scheduled_test/lib/src/stream_matcher.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 scheduled_test.stream_matcher;
 
 import 'dart:async';
 import 'dart:collection';
 
 import '../scheduled_stream.dart';
@@ skipping 46 matching lines @@
 }
 
 /// A matcher that consumes values emitted by a stream until one matching
 /// [matcher] is emitted.
 ///
 /// This will fail if the stream never emits a value that matches [matcher].
 ///
 /// [matcher] can be a [Matcher] or an [Object], but not a [StreamMatcher].
 StreamMatcher consumeThrough(matcher) => new _ConsumeThroughMatcher(matcher);
 
+/// A matcher that consumes values emitted by a stream as long as they match
+/// [matcher].
+///
+/// This matcher will always match a stream. It exists to consume values.
+///
+/// [matcher] can be a [Matcher] or an [Object], but not a [StreamMatcher].
+StreamMatcher consumeWhile(matcher) => new _ConsumeWhileMatcher(matcher);
+
 /// A matcher that matches either [streamMatcher1], [streamMatcher2], or both.
 ///
 /// If both matchers match the stream, the one that consumed more values will be
 /// used.
 ///
 /// Both [streamMatcher1] and [streamMatcher2] can be a [StreamMatcher], a
 /// [Matcher], or an [Object].
 StreamMatcher either(streamMatcher1, streamMatcher2) =>
   new _EitherMatcher(streamMatcher1, streamMatcher2);
 
@@ skipping 127 matching lines @@
           return consumeNext();
         });
       });
     }
 
     return consumeNext();
   }
 
   String toString() {
     return new StringDescription('values followed by ')
-      .addDescriptionOf(_matcher).toString();
+        .addDescriptionOf(_matcher).toString();
   }
 }
 
+/// See [consumeWhile].
+class _ConsumeWhileMatcher implements StreamMatcher {
+  final Matcher _matcher;
+
+  _ConsumeWhileMatcher(matcher)
+      : _matcher = wrapMatcher(matcher);
+
+  Future<Description> tryMatch(ScheduledStream stream) {
+    consumeNext() {
+      return stream.hasNext.then((hasNext) {
+        if (!hasNext) return new Future.value();
+
+        return _peek(stream).then((value) {
+          if (!_matcher.matches(value, {})) return null;
+          return stream.next().then((_) => consumeNext());
+        });
+      });
+    }
+
+    return consumeNext();
+  }
+
+  String toString() {
+    return new StringDescription('any number of ')
+        .addDescriptionOf(_matcher).toString();
+  }
+}
+
 /// See [either].
 class _EitherMatcher implements StreamMatcher {
   final StreamMatcher _matcher1;
   final StreamMatcher _matcher2;
 
   _EitherMatcher(streamMatcher1, streamMatcher2)
       : _matcher1 = new StreamMatcher.wrap(streamMatcher1),
         _matcher2 = new StreamMatcher.wrap(streamMatcher2);
 
   Future<Description> tryMatch(ScheduledStream stream) {
@@ skipping 97 matching lines @@
 
   Future<Description> tryMatch(ScheduledStream stream) {
     return stream.hasNext.then((hasNext) {
       if (!hasNext) return null;
       return new StringDescription("stream wasn't finished");
     });
   }
 
   String toString() => 'is done';
 }
+
+/// Returns a [Future] that completes to the next value emitted by [stream]
+/// without actually consuming that value.
+Future _peek(ScheduledStream stream) {
+  var fork = stream.fork();
+  return fork.next().whenComplete(fork.close);
+}