Remove Collection, Collections and clean up List/Set/Queue implementations of retain/remove.

pkg/unittest/lib/src/iterable_matchers.dart

 // 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.
 
 part of matcher;
 
 /**
- * Returns a matcher which matches [Collection]s in which all elements
+ * 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 _CollectionMatcher {
+class _EveryElement extends _IterableMatcher {
   Matcher _matcher;
 
   _EveryElement(Matcher this._matcher);
 
   bool matches(item, MatchState matchState) {
     if (item is! Iterable) {
       return false;
     }
     var i = 0;
     for (var element in item) {
@@ skipping 20 matching lines @@
       var element = matchState.state['element'];
       return _matcher.describeMismatch(element, mismatchDescription,
             matchState.state['state'], verbose).add(' at position $index');
     }
     return super.describeMismatch(item, mismatchDescription,
           matchState, verbose);
   }
 }
 
 /**
- * Returns a matcher which matches [Collection]s in which at least one
+ * Returns a matcher which matches [Iterable]s in which at least one
  * element matches the given [matcher].
  */
 Matcher someElement(matcher) => new _SomeElement(wrapMatcher(matcher));
 
-class _SomeElement extends _CollectionMatcher {
+class _SomeElement extends _IterableMatcher {
   Matcher _matcher;
 
   _SomeElement(this._matcher);
 
   bool matches(item, MatchState matchState) {
     return item.any((e) => _matcher.matches(e, matchState));
   }
 
   Description describe(Description description) =>
       description.add('some element ').addDescriptionOf(_matcher);
@@ skipping 43 matching lines @@
 class _UnorderedEquals extends BaseMatcher {
   Iterable _expected;
 
   _UnorderedEquals(Iterable this._expected);
 
   String _test(item) {
     if (item is !Iterable) {
       return 'not iterable';
     }
     // Check the lengths are the same.
-    var expectedLength = 0;
-    if (_expected is Collection) {
-      Collection cast = _expected; // "_expected as Collection"
-      expectedLength = cast.length;
-    } else {
-      for (var element in _expected) {
-        ++expectedLength;
-      }
-    }
-    var actualLength = 0;
-    if (item is Collection) {
-      actualLength = item.length;
-    } else {
-      for (var element in item) {
-        ++actualLength;
-      }
-    }
+    var expectedLength = _expected.length;
+    var actualLength = item.length;
     if (expectedLength > actualLength) {
       return 'has too few elements (${actualLength} < ${expectedLength})';
     } else if (expectedLength < actualLength) {
       return 'has too many elements (${actualLength} > ${expectedLength})';
     }
     List<bool> matched = new List<bool>(actualLength);
     for (var i = 0; i < actualLength; i++) {
       matched[i] = false;
     }
     var expectedPosition = 0;
@@ skipping 25 matching lines @@
 
   Description describe(Description description) =>
       description.add('equals ').addDescriptionOf(_expected).add(' unordered');
 
   Description describeMismatch(item, Description mismatchDescription,
                                MatchState matchState, bool verbose) =>
       mismatchDescription.add(_test(item));
 }
 
 /**
- * Collection matchers match against [Collection]s. We add this intermediate
+ * Iterable matchers match against [Iterable]s. We add this intermediate
  * class to give better mismatch error messages than the base Matcher class.
  */
-abstract class _CollectionMatcher extends BaseMatcher {
-  const _CollectionMatcher();
+abstract class _IterableMatcher extends BaseMatcher {
+  const _IterableMatcher();
   Description describeMismatch(item, Description mismatchDescription,
                                MatchState matchState, bool verbose) {
     if (item is! Iterable) {
       return mismatchDescription.
           addDescriptionOf(item).
           add(' not an Iterable');
     } else {
       return super.describeMismatch(item, mismatchDescription, matchState,
         verbose);
     }
   }
 }