Improved the way we generate mismatch descriptions.

tests/lib/unittest/matchers_test.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.
 
 #library('matcherTest');
 #import('../../../lib/unittest/unittest.dart');
 #source('test_utils.dart');
 
 doesNotThrow() {}
 doesThrow() { throw 'X'; }
 
 class PrefixMatcher extends BaseMatcher {
   final String _prefix;
   const PrefixMatcher(this._prefix);
-  bool matches(item) {
+  bool matches(item, MatchState matchState) {
     return item is String &&
         (collapseWhitespace(item)).startsWith(collapseWhitespace(_prefix));
   }
 
   Description describe(Description description) =>
     description.add('a string starting with ').
         addDescriptionOf(collapseWhitespace(_prefix)).
         add(' ignoring whitespace');
 }
 
@@ skipping 50 matching lines @@
     test('throws', () {
       shouldFail(doesNotThrow, throws,
         "Expected: throws an exception but: no exception.");
       shouldPass(doesThrow, throws);
     });
 
     test('throwsA', () {
       shouldPass(doesThrow, throwsA(equals('X')));
       shouldFail(doesThrow, throwsA(equals('Y')),
         "Expected: throws an exception which matches 'Y' "
-        "but:  no exception or exception does not match 'Y'.");
+        "but:  exception 'X' does not match 'Y'.");
     });
 
     test('throwsBadNumberFormatException', () {
       shouldPass(() { throw new BadNumberFormatException(''); },
           throwsBadNumberFormatException);
       shouldFail(() { throw new Exception(); },
           throwsBadNumberFormatException,
         "Expected: throws an exception which matches BadNumberFormatException "
-        "but:  no exception or exception does not match "
+        "but:  exception <Exception> does not match "
             "BadNumberFormatException.");
     });
 
     test('throwsIllegalArgumentException', () {
       shouldPass(() { throw new IllegalArgumentException(''); },
           throwsIllegalArgumentException);
       shouldFail(() { throw new Exception(); },
           throwsIllegalArgumentException,
         "Expected: throws an exception which matches IllegalArgumentException "
-        "but:  no exception or exception does not match "
+        "but:  exception <Exception> does not match "
             "IllegalArgumentException.");
     });
 
     test('throwsIllegalJSRegExpException', () {
       shouldPass(() { throw new IllegalJSRegExpException('',''); },
           throwsIllegalJSRegExpException);
       shouldFail(() { throw new Exception(); },
           throwsIllegalJSRegExpException,
         "Expected: throws an exception which matches IllegalJSRegExpException "
-        "but:  no exception or exception does not match "
+        "but:  exception <Exception> does not match "
             "IllegalJSRegExpException.");
     });
 
     test('throwsIndexOutOfRangeException', () {
       shouldPass(() { throw new IndexOutOfRangeException(0); },
           throwsIndexOutOfRangeException);
       shouldFail(() { throw new Exception(); },
           throwsIndexOutOfRangeException,
         "Expected: throws an exception which matches IndexOutOfRangeException "
-        "but:  no exception or exception does not match "
+        "but:  exception <Exception> does not match "
             "IndexOutOfRangeException.");
     });
 
     test('throwsNoSuchMethodException', () {
       shouldPass(() { throw new NoSuchMethodException(null, '', null); },
           throwsNoSuchMethodException);
       shouldFail(() { throw new Exception(); },
           throwsNoSuchMethodException,
         "Expected: throws an exception which matches NoSuchMethodException "
-        "but:  no exception or exception does not match "
+        "but:  exception <Exception> does not match "
             "NoSuchMethodException.");
     });
 
     test('throwsNotImplementedException', () {
       shouldPass(() { throw new NotImplementedException(''); },
           throwsNotImplementedException);
       shouldFail(() { throw new Exception(); },
           throwsNotImplementedException,
         "Expected: throws an exception which matches NotImplementedException "
-        "but:  no exception or exception does not match "
+        "but:  exception <Exception> does not match "
             "NotImplementedException.");
     });
 
     test('throwsNullPointerException', () {
       shouldPass(() { throw new NullPointerException(''); },
           throwsNullPointerException);
       shouldFail(() { throw new Exception(); },
           throwsNullPointerException,
         "Expected: throws an exception which matches NullPointerException "
-        "but:  no exception or exception does not match "
+        "but:  exception <Exception> does not match "
             "NullPointerException.");
     });
 
     test('throwsUnsupportedOperationException', () {
       shouldPass(() { throw new UnsupportedOperationException(''); },
           throwsUnsupportedOperationException);
       shouldFail(() { throw new Exception(); },
           throwsUnsupportedOperationException,
         "Expected: throws an exception which matches "
             "UnsupportedOperationException "
-        "but:  no exception or exception does not match "
+        "but:  exception <Exception> does not match "
             "UnsupportedOperationException.");
     });
 
     test('returnsNormally', () {
       shouldPass(doesNotThrow, returnsNormally);
       shouldFail(doesThrow, returnsNormally,
-        "Expected: return normally but: threw exception.");
+        "Expected: return normally but: threw 'X'.");
     });
 
     test('hasLength', () {
       var a = new Map();
       var b = new List();
       shouldPass(a, hasLength(0));
       shouldPass(b, hasLength(0));
       shouldPass('a', hasLength(1));
       shouldFail(0, hasLength(0), new PrefixMatcher(
         "Expected: an object with length of <0> "
@@ skipping 221 matching lines @@
     test('isIn', () {
       var d = [1, 2];
       shouldPass(1, isIn(d));
       shouldFail(0, isIn(d), "Expected: is in <[1, 2]> but: was <0>.");
     });
 
     test('everyElement', () {
       var d = [1, 2];
       var e = [1, 1, 1];
       shouldFail(d, everyElement(1),
-          "Expected: every element <1> but: was <[1, 2]>.");
+          "Expected: every element <1> but: was <2> at position 1.");
       shouldPass(e, everyElement(1));
     });
 
     test('someElement', () {
       var d = [1, 2];
       var e = [1, 1, 1];
       shouldPass(d, someElement(2));
       shouldFail(e, someElement(2),
           "Expected: some element <2> but: was <[1, 1, 1]>.");
     });
@@ skipping 92 matching lines @@
 
   group('Predicate Matchers', () {
     test('isInstanceOf', () {
       shouldFail(0, predicate((x) => x is String, "an instance of String"),
         "Expected: an instance of String but: was <0>.");
       shouldPass('cow', predicate((x) => x is String, "an instance of String"));
     });
   });
 }