Improved the way we generate mismatch descriptions.

lib/unittest/collection_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.
 
 /**
  * Returns a matcher which matches [Collection]s in which all elements
  * match the given [matcher].
  */
 Matcher everyElement(matcher) => new _EveryElement(wrapMatcher(matcher));
 
 class _EveryElement extends _CollectionMatcher {
   Matcher _matcher;
 
   _EveryElement(Matcher this._matcher);
 
-  bool matches(item) {
-    return item.every((e) => _matcher.matches(e));
+  bool matches(item, MatchState matchState) {
+    if (item is! Iterable) {
+      return false;
+    }
+    var i = 0;
+    for (var element in item) {
+      if (!_matcher.matches(element, matchState)) {
+        matchState.state = {
+            'index': i,
+            'element': element,
+            'state': matchState.state

[Siggi Cherem (dart-lang), 2012/07/31 17:16:40]

so state is a list of states?

[gram, 2012/07/31 17:56:01]

No; we fail fast, so it has the mismatch state just for the first failure.

+        };
+        return false;
+      }
+      ++i;
+    }
+    return true;
   }
 
   Description describe(Description description) =>
       description.add('every element ').addDescriptionOf(_matcher);
+
+  Description describeMismatch(item, Description mismatchDescription,
+                               MatchState matchState, bool verbose) {
+    if (matchState.state != null) {
+      var index = matchState.state['index'];
+      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
  * element matches the given [matcher].
  */
 Matcher someElement(matcher) => new _SomeElement(wrapMatcher(matcher));
 
 class _SomeElement extends _CollectionMatcher {
   Matcher _matcher;
 
   _SomeElement(this._matcher);
 
-  bool matches(item) {
-    return item.some( (e) => _matcher.matches(e) );
+  bool matches(item, MatchState matchState) {
+    return item.some( (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], and in the same order.
  * This is equivalent to equals but does not recurse.
  */
 
 Matcher orderedEquals(Iterable expected) => new _OrderedEquals(expected);
 
 class _OrderedEquals extends BaseMatcher {
   final Iterable _expected;
   Matcher _matcher;
 
   _OrderedEquals(this._expected) {
     _matcher = equals(_expected, 1);
   }
 
-  bool matches(item) => (item is Iterable) && _matcher.matches(item);
+  bool matches(item, MatchState matchState) =>
+      (item is Iterable) && _matcher.matches(item, matchState);
 
   Description describe(Description description) =>
       description.add('equals ').addDescriptionOf(_expected).add(' ordered');
 
-  Description describeMismatch(item, Description mismatchDescription) {
+  Description describeMismatch(item, Description mismatchDescription,
+                               MatchState matchState, bool verbose) {
     if (item is !Iterable) {
       return mismatchDescription.add('not an Iterable');
     } else {
-      return _matcher.describeMismatch(item, mismatchDescription);
+      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) =>
@@ skipping 53 matching lines @@
         reason.add('has no match for element ').
             addDescriptionOf(expectedElement).
             add(' at position ${expectedPosition}');
         return reason.toString();
       }
       ++expectedPosition;
     }
     return null;
   }
 
-  bool matches(item) => (_test(item) == null);
+  bool matches(item, MatchState mismatchState) => (_test(item) == null);
 
   Description describe(Description description) =>
       description.add('equals ').addDescriptionOf(_expected).add(' unordered');
 
-  Description describeMismatch(item, Description mismatchDescription) =>
+  Description describeMismatch(item, Description mismatchDescription,
+                               MatchState matchState, bool verbose) =>
       mismatchDescription.add(_test(item));
 }
 
 /**
  * Collection matchers match against [Collection]s. We add this intermediate
  * class to give better mismatch error messages than the base Matcher class.
  */
 /* abstract */ class _CollectionMatcher extends BaseMatcher {
   const _CollectionMatcher();
-  Description describeMismatch(item, Description mismatchDescription) {
+  Description describeMismatch(item, Description mismatchDescription,
+                               MatchState matchState, bool verbose) {
     if (item is !Collection) {
       return mismatchDescription.
           addDescriptionOf(item).
           add(' not a collection');
     } else {
-      return super.describeMismatch(item, mismatchDescription);
+      return super.describeMismatch(item, mismatchDescription, matchState,
+        verbose);
     }
   }
 }