Roll to pickup pool changes

packages/matcher/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.
 
 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);
+  _EveryElement(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;
@@ skipping 120 matching lines @@
 ///  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();
+    if (item is Iterable) {
+      var list = 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;
+      // Check the lengths are the same.
+      if (_expected.length > list.length) {
+        return 'has too few elements (${list.length} < ${_expected.length})';
+      } else if (_expected.length < list.length) {
+        return 'has too many elements (${list.length} > ${_expected.length})';
       }
 
-      if (!gotMatch) {
-        return new StringDescription()
-            .add('has no match for ')
-            .addDescriptionOf(expectedMatcher)
-            .add(' at index ${expectedPosition}')
-            .toString();
+      var matched = new List<bool>.filled(list.length, false);
+      var expectedPosition = 0;
+      for (var expectedMatcher in _expected) {
+        var actualPosition = 0;
+        var gotMatch = false;
+        for (var actualElement in list) {
+          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;
       }
-
-      ++expectedPosition;
+      return null;
+    } else {
+      return 'not iterable';
     }
-    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) =>
+Matcher pairwiseCompare<S, T>(
+        Iterable<S> expected, bool comparator(S a, T b), String description) =>
     new _PairwiseCompare(expected, comparator, description);
 
-typedef bool _Comparator(a, b);
+typedef bool _Comparator<S, T>(S a, T b);
 
-class _PairwiseCompare extends _IterableMatcher {
-  final Iterable _expected;
-  final _Comparator _comparator;
+class _PairwiseCompare<S, T> extends _IterableMatcher {
+  final Iterable<S> _expected;
+  final _Comparator<S, T> _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;
+    if (item is Iterable) {
+      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++;
       }
-      i++;
+      return true;
+    } else {
+      return false;
     }
-    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) {
@@ skipping 46 matching lines @@
   Description describe(Description description) => description
       .add('contains in order(')
       .addDescriptionOf(_expected)
       .add(')');
 
   @override
   Description describeMismatch(item, Description mismatchDescription,
           Map matchState, bool verbose) =>
       mismatchDescription.add(_test(item, matchState));
 }