Remove unittest and matcher from the repo.

pkg/matcher/lib/src/iterable_matchers.dart

Index: pkg/matcher/lib/src/iterable_matchers.dart
diff --git a/pkg/matcher/lib/src/iterable_matchers.dart b/pkg/matcher/lib/src/iterable_matchers.dart
deleted file mode 100644
index 60ef32d09b2abdbc0c9504c3c864b020d0475062..0000000000000000000000000000000000000000
--- a/pkg/matcher/lib/src/iterable_matchers.dart
+++ /dev/null
@@ -1,266 +0,0 @@
-// Copyright (c) 2012, 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 matcher.iterable_matchers;
-
-import 'core_matchers.dart';
-import 'description.dart';
-import 'interfaces.dart';
-import 'util.dart';
-
-/// Returns a matcher which matches [Iterable]s in which all elements
-/// match the given [matcher].
-Matcher everyElement(matcher) => new _EveryElement(wrapMatcher(matcher));
-
-class _EveryElement extends _IterableMatcher {
-  final Matcher _matcher;
-
-  _EveryElement(Matcher this._matcher);
-
-  bool matches(item, Map matchState) {
-    if (item is! Iterable) {
-      return false;
-    }
-    var i = 0;
-    for (var element in item) {
-      if (!_matcher.matches(element, matchState)) {
-        addStateInfo(matchState, {'index': i, 'element': element});
-        return false;
-      }
-      ++i;
-    }
-    return true;
-  }
-
-  Description describe(Description description) =>
-      description.add('every element(').addDescriptionOf(_matcher).add(')');
-
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
-    if (matchState['index'] != null) {
-      var index = matchState['index'];
-      var element = matchState['element'];
-      mismatchDescription.add('has value ').addDescriptionOf(element).
-          add(' which ');
-      var subDescription = new StringDescription();
-      _matcher.describeMismatch(element, subDescription, matchState['state'],
-          verbose);
-      if (subDescription.length > 0) {
-        mismatchDescription.add(subDescription.toString());
-      } else {
-        mismatchDescription.add("doesn't match ");
-        _matcher.describe(mismatchDescription);
-      }
-      mismatchDescription.add(' at index $index');
-      return mismatchDescription;
-    }
-    return super.describeMismatch(item, mismatchDescription,
-          matchState, verbose);
-  }
-}
-
-/// Returns a matcher which matches [Iterable]s in which at least one
-/// element matches the given [matcher].
-Matcher anyElement(matcher) => new _AnyElement(wrapMatcher(matcher));
-
-class _AnyElement extends _IterableMatcher {
-  final Matcher _matcher;
-
-  _AnyElement(this._matcher);
-
-  bool matches(item, Map matchState) {
-    return item.any((e) => _matcher.matches(e, matchState));
-  }
-
-  Description describe(Description description) =>
-      description.add('some element ').addDescriptionOf(_matcher);
-}
-
-/// Returns a matcher which matches [Iterable]s that have the same
-/// length and the same elements as [expected], in the same order.
-///
-/// This is equivalent to [equals] but does not recurse.
-Matcher orderedEquals(Iterable expected) => new _OrderedEquals(expected);
-
-class _OrderedEquals extends Matcher {
-  final Iterable _expected;
-  Matcher _matcher;
-
-  _OrderedEquals(this._expected) {
-    _matcher = equals(_expected, 1);
-  }
-
-  bool matches(item, Map matchState) =>
-      (item is Iterable) && _matcher.matches(item, matchState);
-
-  Description describe(Description description) =>
-      description.add('equals ').addDescriptionOf(_expected).add(' ordered');
-
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
-    if (item is !Iterable) {
-      return mismatchDescription.add('is not an Iterable');
-    } else {
-      return _matcher.describeMismatch(item, mismatchDescription,
-          matchState, verbose);
-    }
-  }
-}
-
-/// Returns a matcher which matches [Iterable]s that have the same length and
-/// the same elements as [expected], but not necessarily in the same order.
-///
-/// Note that this is O(n^2) so should only be used on small objects.
-Matcher unorderedEquals(Iterable expected) => new _UnorderedEquals(expected);
-
-class _UnorderedEquals extends _UnorderedMatches {
-  final List _expectedValues;
-
-  _UnorderedEquals(Iterable expected)
-      : super(expected.map(equals)),
-        _expectedValues = expected.toList();
-
-  Description describe(Description description) =>
-    description
-        .add('equals ')
-        .addDescriptionOf(_expectedValues)
-        .add(' unordered');
-}
-
-/// Iterable matchers match against [Iterable]s. We add this intermediate
-/// class to give better mismatch error messages than the base Matcher class.
-abstract class _IterableMatcher extends Matcher {
-  const _IterableMatcher();
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
-    if (item is! Iterable) {
-      return mismatchDescription.
-          addDescriptionOf(item).
-          add(' not an Iterable');
-    } else {
-      return super.describeMismatch(item, mismatchDescription, matchState,
-          verbose);
-    }
-  }
-}
-
-/// Returns a matcher which matches [Iterable]s whose elements match the
-/// matchers in [expected], but not necessarily in the same order.
-///
-///  Note that this is `O(n^2)` and so should only be used on small objects.
-Matcher unorderedMatches(Iterable expected) => new _UnorderedMatches(expected);
-
-class _UnorderedMatches extends Matcher {
-  final List<Matcher> _expected;
-
-  _UnorderedMatches(Iterable expected)
-      : _expected = expected.map(wrapMatcher).toList();
-
-  String _test(item) {
-    if (item is! Iterable) return 'not iterable';
-    item = item.toList();
-
-    // Check the lengths are the same.
-    if (_expected.length > item.length) {
-      return 'has too few elements (${item.length} < ${_expected.length})';
-    } else if (_expected.length < item.length) {
-      return 'has too many elements (${item.length} > ${_expected.length})';
-    }
-
-    var matched = new List<bool>.filled(item.length, false);
-    var expectedPosition = 0;
-    for (var expectedMatcher in _expected) {
-      var actualPosition = 0;
-      var gotMatch = false;
-      for (var actualElement in item) {
-        if (!matched[actualPosition]) {
-          if (expectedMatcher.matches(actualElement, {})) {
-            matched[actualPosition] = gotMatch = true;
-            break;
-          }
-        }
-        ++actualPosition;
-      }
-
-      if (!gotMatch) {
-        return new StringDescription()
-            .add('has no match for ')
-            .addDescriptionOf(expectedMatcher)
-            .add(' at index ${expectedPosition}')
-            .toString();
-      }
-
-      ++expectedPosition;
-    }
-    return null;
-  }
-
-  bool matches(item, Map mismatchState) => _test(item) == null;
-
-  Description describe(Description description) =>
-    description
-      .add('matches ')
-      .addAll('[', ', ', ']', _expected)
-      .add(' unordered');
-
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) =>
-      mismatchDescription.add(_test(item));
-}
-
-/// A pairwise matcher for [Iterable]s.
-///
-/// The [comparator] function, taking an expected and an actual argument, and
-/// returning whether they match, will be applied to each pair in order.
-/// [description] should be a meaningful name for the comparator.
-Matcher pairwiseCompare(Iterable expected, bool comparator(a, b),
-    String description) =>
-        new _PairwiseCompare(expected, comparator, description);
-
-typedef bool _Comparator(a, b);
-
-class _PairwiseCompare extends _IterableMatcher {
-  final Iterable _expected;
-  final _Comparator _comparator;
-  final String _description;
-
-  _PairwiseCompare(this._expected, this._comparator, this._description);
-
-  bool matches(item, Map matchState) {
-    if (item is! Iterable) return false;
-    if (item.length != _expected.length) return false;
-    var iterator = item.iterator;
-    var i = 0;
-    for (var e in _expected) {
-      iterator.moveNext();
-      if (!_comparator(e, iterator.current)) {
-        addStateInfo(matchState, {'index': i, 'expected': e,
-            'actual': iterator.current});
-        return false;
-      }
-      i++;
-    }
-    return true;
-  }
-
-  Description describe(Description description) =>
-      description.add('pairwise $_description ').addDescriptionOf(_expected);
-
-  Description describeMismatch(item, Description mismatchDescription,
-                               Map matchState, bool verbose) {
-    if (item is !Iterable) {
-      return mismatchDescription.add('is not an Iterable');
-    } else if (item.length != _expected.length) {
-      return mismatchDescription.
-          add('has length ${item.length} instead of ${_expected.length}');
-    } else {
-      return mismatchDescription.
-          add('has ').
-          addDescriptionOf(matchState["actual"]).
-          add(' which is not $_description ').
-          addDescriptionOf(matchState["expected"]).
-          add(' at index ${matchState["index"]}');
-    }
-  }
-}