Added a new matcher for pairwise comparison of iterables with a custom comparator.

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 [Iterable]s in which all elements
  * match the given [matcher].
  */
@@ skipping 166 matching lines @@
     if (item is! Iterable) {
       return mismatchDescription.
           addDescriptionOf(item).
           add(' not an Iterable');
     } else {
       return super.describeMismatch(item, mismatchDescription, matchState,
         verbose);
     }
   }
 }
+
+/**
+ * A pairwise matcher for iterable. You can pass an arbitrary [comparator]
+ * function that takes an expected and actual argument which will be applied
+ * to each pair in order. [description]  should be a meaningful name for
+ * the comparator.
+ */
+Matcher pairwiseCompare(Iterable expected, Function comparator,
+    String description) =>
+        new _PairwiseCompare(expected, comparator, description);
+
+class _PairwiseCompare extends _IterableMatcher {
+  Iterable _expected;

[Jennifer Messerly, 2013/05/08 00:16:25]

final?

+  Function _comparator;
+  String _description;
+
+  _PairwiseCompare(this._expected, this._comparator, this._description);
+
+  bool matches(item, MatchState matchState) {
+    if (item is! Iterable) return false;
+    if (item.length != _expected.length) return false;
+    for (var i = 0; i < item.length; i++) {
+      var e = _expected.elementAt(i);

[Jennifer Messerly, 2013/05/08 00:16:25]

any concern about the O(N^2) if this is a genuine iterable? I wonder if it's
better to convert to List first.

[Siggi Cherem (dart-lang), 2013/05/08 00:31:32]

you could use the iterable api and visit them concurrently?

var iterator = item.iterator;
var i = 0;
for (var e in _expected) {
  iterator.moveNext();
  if (!_comparator(e, iterator.current)) { ... 
  i++;

+      var a = item.elementAt(i);
+      if (!_comparator(e, a)) {
+        matchState.state = {
+            'index': i,
+            'expected': e,
+            'actual' : a,
+            'state': matchState.state
+        };
+        return false;
+      }
+    }
+    return true;
+  }
+    
+  Description describe(Description description) =>
+      description.add('pairwise $_description ').addDescriptionOf(_expected);
+
+  Description describeMismatch(item, Description mismatchDescription,
+                               MatchState matchState, bool verbose) {
+    if (item is !Iterable) {
+      return mismatchDescription.add('not an Iterable');
+    } else if (item.length != _expected.length) {
+      return mismatchDescription.
+          add('length was ${item.length} instead of ${_expected.length}');
+    } else {
+      return mismatchDescription.
+          addDescriptionOf(matchState.state["actual"]).
+          add(' not $_description ').
+          addDescriptionOf(matchState.state["expected"]).
+          add(' at position ${matchState.state["index"]}');
+    }
+  }
+}
+