Delete a bunch of packages that are now on GitHub.

pkg/scheduled_test/test/scheduled_stream/stream_matcher_test.dart

Index: pkg/scheduled_test/test/scheduled_stream/stream_matcher_test.dart
diff --git a/pkg/scheduled_test/test/scheduled_stream/stream_matcher_test.dart b/pkg/scheduled_test/test/scheduled_stream/stream_matcher_test.dart
deleted file mode 100644
index b34e0759ad31b227d1b58c9f8cc27eab4294298d..0000000000000000000000000000000000000000
--- a/pkg/scheduled_test/test/scheduled_stream/stream_matcher_test.dart
+++ /dev/null
@@ -1,335 +0,0 @@
-// 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_test;
-
-import 'dart:async';
-
-import 'package:scheduled_test/scheduled_stream.dart';
-import 'package:scheduled_test/scheduled_test.dart';
-import 'package:scheduled_test/src/utils.dart';
-
-import 'package:metatest/metatest.dart';
-import '../utils.dart';
-
-/// Returns a [ScheduledStream] that asynchronously emits the numbers 1 through
-/// 5 and then closes.
-ScheduledStream createStream() {
-  var controller = new StreamController();
-  var stream = new ScheduledStream(controller.stream);
-
-  var future = pumpEventQueue();
-  for (var i = 1; i <= 5; i++) {
-    future = future.then((_) {
-      controller.add(i);
-      return pumpEventQueue();
-    });
-  }
-  future.then((_) => controller.close());
-
-  return stream;
-}
-
-void main() => initTests(_test);
-
-void _test(message) {
-  initMetatest(message);
-
-  setUpTimeout();
-
-  expectTestPasses("expect() with matching values passes", () {
-    var stream = createStream();
-    stream.expect(1);
-    stream.expect(2);
-    stream.expect(3);
-    stream.expect(4);
-    stream.expect(5);
-  });
-
-  expectTestFails("expect() with a non-matching value fails", () {
-    var stream = createStream();
-    stream.expect(1);
-    stream.expect(2);
-    stream.expect(100);
-  }, (errors) {
-    expect(errors, hasLength(1));
-    expect(errors.first.error.message, equals(
-        "Expected: <100>\n"
-        " Emitted: * 1\n"
-        "          * 2\n"
-        "          * 3"));
-  });
-
-  expectTestFails("expect() with too few values fails", () {
-    var stream = createStream();
-    stream.expect(1);
-    stream.expect(2);
-    stream.expect(3);
-    stream.expect(4);
-    stream.expect(5);
-    stream.expect(6);
-  }, (errors) {
-    expect(errors, hasLength(1));
-    expect(errors.first.error.message, equals(
-        "Expected: <6>\n"
-        " Emitted: * 1\n"
-        "          * 2\n"
-        "          * 3\n"
-        "          * 4\n"
-        "          * 5\n"
-        "   Which: unexpected end of stream"));
-  });
-
-  expectTestPasses("expect() with matching matcher passes", () {
-    var stream = createStream();
-    stream.expect(greaterThan(0));
-    stream.expect(greaterThan(1));
-    stream.expect(greaterThan(2));
-    stream.expect(greaterThan(3));
-    stream.expect(greaterThan(4));
-  });
-
-  expectTestFails("expect() with a non-matching matcher fails", () {
-    var stream = createStream();
-    stream.expect(greaterThan(0));
-    stream.expect(greaterThan(1));
-    stream.expect(greaterThan(100));
-  }, (errors) {
-    expect(errors, hasLength(1));
-    expect(errors.first.error.message, equals(
-        "Expected: a value greater than <100>\n"
-        " Emitted: * 1\n"
-        "          * 2\n"
-        "          * 3\n"
-        "   Which: is not a value greater than <100>"));
-  });
-
-  expectTestPasses("nextValues() with matching values succeeds", () {
-    createStream().expect(nextValues(3, unorderedEquals([3, 2, 1])));
-  });
-
-  expectTestFails("nextValues() without enough values fails", () {
-    createStream().expect(nextValues(6, unorderedEquals([3, 2, 1])));
-  }, (errors) {
-    expect(errors, hasLength(1));
-    expect(errors.first.error.message, equals(
-        "Expected: 6 values that equals [3, 2, 1] unordered\n"
-        " Emitted: * 1\n"
-        "          * 2\n"
-        "          * 3\n"
-        "          * 4\n"
-        "          * 5\n"
-        "   Which: unexpected end of stream"));
-  });
-
-  expectTestFails("nextValues() with non-matching values fails", () {
-    createStream().expect(nextValues(3, unorderedEquals([2, 3, 4])));
-  }, (errors) {
-    expect(errors, hasLength(1));
-    expect(errors.first.error.message, equals(
-        "Expected: 3 values that equals [2, 3, 4] unordered\n"
-        " Emitted: * 1\n"
-        "          * 2\n"
-        "          * 3\n"
-        "   Which: has no match for <4> at index 2"));
-  });
-
-  expectTestPasses("inOrder() with several values matches and consumes those "
-      "values", () {
-    var stream = createStream();
-    stream.expect(inOrder([1, 2, 3, 4]));
-    stream.expect(5);
-  });
-
-  expectTestPasses("inOrder() with several stream matchers matches them", () {
-    createStream().expect(inOrder([
-      consumeThrough(3),
-      nextValues(2, unorderedEquals([5, 4]))
-    ]));
-  });
-
-  expectTestPasses("inOrder() with no values succeeds and consumes nothing",
-      () {
-    var stream = createStream();
-    stream.expect(inOrder([]));
-    stream.expect(1);
-  });
-
-  expectTestFails("inOrder() fails if a sub-matcher fails", () {
-    createStream().expect(inOrder([
-      nextValues(3, unorderedEquals([2, 3, 4])),
-      consumeThrough(5)
-    ]));
-  }, (errors) {
-    expect(errors, hasLength(1));
-    expect(errors.first.error.message, equals(
-        "Expected: * 3 values that equals [2, 3, 4] unordered\n"
-        "        | * values followed by <5>\n"
-        " Emitted: * 1\n"
-        "          * 2\n"
-        "          * 3\n"
-        "   Which: matcher #1 failed:\n"
-        "        | has no match for <4> at index 2"));
-  });
-
-  expectTestFails("inOrder() with one value has a simpler description", () {
-    createStream().expect(inOrder([100]));
-  }, (errors) {
-    expect(errors, hasLength(1));
-    expect(errors.first.error.message, equals(
-        "Expected: <100>\n"
-        " Emitted: * 1"));
-  });
-
-  expectTestPasses("consumeThrough() consumes values through the given matcher",
-      () {
-    var stream = createStream();
-    stream.expect(consumeThrough(inOrder([2, 3])));
-    stream.expect(4);
-  });
-
-  expectTestPasses("consumeThrough() will stop if the first value matches", () {
-    var stream = createStream();
-    stream.expect(consumeThrough(inOrder([1, 2])));
-    stream.expect(3);
-  });
-
-  expectTestFails("consumeThrough() will fail if the stream ends before the "
-      "value is reached", () {
-    createStream().expect(consumeThrough(inOrder([5, 6])));
-  }, (errors) {
-    expect(errors, hasLength(1));
-    expect(errors.first.error.message, equals(
-        "Expected: values followed by:\n"
-        "        |   * <5>\n"
-        "        |   * <6>\n"
-        " Emitted: * 1\n"
-        "          * 2\n"
-        "          * 3\n"
-        "          * 4\n"
-        "          * 5\n"
-        "   Which: unexpected end of stream"));
-  });
-
-  expectTestPasses("consumeWhile() consumes values while the given matcher "
-      "matches", () {
-    var stream = createStream();
-    stream.expect(consumeWhile(lessThan(4)));
-    stream.expect(4);
-  });
-
-  expectTestPasses("consumeWhile() consumes values in chunks", () {
-    var stream = createStream();
-    stream.expect(consumeWhile(inOrder([anything, anything])));
-    stream.expect(5);
-  });
-
-  expectTestPasses("consumeWhile() will stop if the first value doesn't match",
-      () {
-    var stream = createStream();
-    stream.expect(consumeWhile(inOrder([2, 3])));
-    stream.expect(1);
-  });
-
-  expectTestPasses("either() will match if the first branch matches", () {
-    createStream().expect(either(1, 100));
-  });
-
-  expectTestPasses("either() will match if the second branch matches", () {
-    createStream().expect(either(100, 1));
-  });
-
-  expectTestPasses("either() will consume the maximal number of values if both "
-      "branches match", () {
-    // First branch consumes more.
-    var stream = createStream();
-    stream.expect(either(inOrder([1, 2, 3]), 1));
-    stream.expect(4);
-
-    // Second branch consumes more.
-    stream = createStream();
-    stream.expect(either(1, inOrder([1, 2, 3])));
-    stream.expect(4);
-  });
-
-  expectTestFails("either() will fail if neither branch matches", () {
-    createStream().expect(either(
-        inOrder([3, 2, 1]),
-        nextValues(4, unorderedEquals([5, 4, 3, 2]))));
-  }, (errors) {
-    expect(errors, hasLength(1));
-    expect(errors.first.error.message, equals(
-        "Expected: either\n"
-        "        |   * <3>\n"
-        "        |   * <2>\n"
-        "        |   * <1>\n"
-        "        | or\n"
-        "        |   4 values that equals [5, 4, 3, 2] unordered\n"
-        " Emitted: * 1\n"
-        "          * 2\n"
-        "          * 3\n"
-        "          * 4\n"
-        "   Which: both\n"
-        "        |   matcher #1 failed\n"
-        "        | and\n"
-        "        |   has no match for <5> at index 0"));
-  });
-
-  expectTestPasses("allow() consumes the matcher if it matches", () {
-    var stream = createStream();
-    stream.expect(allow(inOrder([1, 2, 3])));
-    stream.expect(4);
-  });
-
-  expectTestPasses("allow() consumes nothing if the matcher doesn't match", () {
-    var stream = createStream();
-    stream.expect(allow(inOrder([1, 2, 100])));
-    stream.expect(1);
-  });
-
-  expectTestPasses("never() consumes everything if the matcher never matches",
-      () {
-    var stream = createStream();
-    stream.expect(never(inOrder([2, 1])));
-  });
-
-  expectTestFails("never() fails if the matcher matches", () {
-    var stream = createStream();
-    stream.expect(never(inOrder([2, 3])));
-  }, (errors) {
-    expect(errors, hasLength(1));
-    expect(errors.first.error.message, equals(
-        "Expected: never\n"
-        "        |   * <2>\n"
-        "        |   * <3>\n"
-        " Emitted: * 1\n"
-        "          * 2\n"
-        "          * 3\n"
-        "   Which: matched\n"
-        "        |   * <2>\n"
-        "        |   * <3>"));
-  });
-
-  expectTestPasses("isDone succeeds at the end of the stream", () {
-    var stream = createStream();
-    stream.expect(consumeThrough(5));
-    stream.expect(isDone);
-  });
-
-  expectTestFails("isDone fails before the end of the stream", () {
-    var stream = createStream();
-    stream.expect(consumeThrough(4));
-    stream.expect(isDone);
-  }, (errors) {
-    expect(errors, hasLength(1));
-    expect(errors.first.error.message, equals(
-        "Expected: is done\n"
-        " Emitted: * 1\n"
-        "          * 2\n"
-        "          * 3\n"
-        "          * 4\n"
-        "          * 5\n"
-        "   Which: stream wasn't finished"));
-  });
-}