Improved the way we generate mismatch descriptions.

lib/unittest/mock.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.
 
 /**
  * The error formatter for mocking is a bit different from the default one
  * for unit testing; instead of the third argument being a 'reason'
  * it is instead a [signature] describing the method signature filter
  * that was used to select the logs that were verified.
  */
-String _mockingErrorFormatter(actual, Matcher matcher, String signature) {
+String _mockingErrorFormatter(actual, Matcher matcher, String signature,
+                              MatchState matchState, bool verbose) {
   var description = new StringDescription();
   description.add('Expected ${signature} ').addDescriptionOf(matcher).
       add('\n     but: ');
-  matcher.describeMismatch(actual, description).add('.');
+  matcher.describeMismatch(actual, description, matchState, verbose).add('.');
   return description.toString();
 }
 
 /**
  * The failure handler for the [expect()] calls that occur in [verify()]
  * methods in the mock objects. This calls the real failure handler used
  * by the unit test library after formatting the error message with
  * the custom formatter.
  */
 class _MockFailureHandler implements FailureHandler {
   FailureHandler proxy;
   _MockFailureHandler(this.proxy);
   void fail(String reason) {
     proxy.fail(reason);
   }
-  void failMatch(actual, Matcher matcher, String reason) {
-    proxy.fail(_mockingErrorFormatter(actual, matcher, reason));
+  void failMatch(actual, Matcher matcher, String reason,
+                 MatchState matchState, bool verbose) {
+    proxy.fail(_mockingErrorFormatter(actual, matcher, reason,
+        matchState, verbose));
   }
 }
 
 _MockFailureHandler _mockFailureHandler = null;
 
 /**
  * [_noArg] is a sentinel value representing no argument.
  */
 final _noArg = const _Sentinel();
 
@@ skipping 107 matching lines @@
     }
     d.add(')');
     return d.toString();
   }
 
   /**
    * Given a [method] name and list of [arguments], return true
    * if it matches this [CallMatcher.
    */
   bool matches(String method, List arguments) {
-    if (!nameFilter.matches(method)) {
+    var matchState = new MatchState();
+    if (!nameFilter.matches(method, matchState)) {
       return false;
     }
     if (arguments.length < argMatchers.length) {
       throw new Exception("Less arguments than matchers for $method.");
     }
     for (var i = 0; i < argMatchers.length; i++) {
-      if (!argMatchers[i].matches(arguments[i])) {
+      if (!argMatchers[i].matches(arguments[i], matchState)) {
         return false;
       }
     }
     return true;
   }
 }
 
 /**
  * Returns a [CallMatcher] for the specified signature. [method] can be
  * null to match anything, or a literal [String], a predicate [Function],
@@ skipping 207 matching lines @@
                           Matcher actionMatcher,
                           bool destructive = false]) {
     if (mockNameFilter == null) {
       mockNameFilter = anything;
     } else {
       mockNameFilter = wrapMatcher(mockNameFilter);
     }
     Function entryFilter = _makePredicate(logFilter);
     String filterName = _qualifiedName(mockNameFilter, logFilter.toString());
     LogEntryList rtn = new LogEntryList(filterName);
+    MatchState matchState = new MatchState();
     for (var i = 0; i < logs.length; i++) {
       LogEntry entry = logs[i];
-      if (mockNameFilter.matches(entry.mockName) && entryFilter(entry)) {
-        if (actionMatcher == null || actionMatcher.matches(entry)) {
+      if (mockNameFilter.matches(entry.mockName, matchState) &&
+          entryFilter(entry)) {
+        if (actionMatcher == null ||
+            actionMatcher.matches(entry, matchState)) {
           rtn.add(entry);
           if (destructive) {
             logs.removeRange(i--, 1);
           }
         }
       }
     }
     return rtn;
   }
 
@@ skipping 278 matching lines @@
     // we get our first key match).
     List scratch = null;
     int remainingCount = 0;
     if (isPreceding) {
       scratch = new List();
       remainingCount = logs.length;
     }
 
     var keyIterator = keys.logs.iterator();
     LogEntry keyEntry = keyIterator.next();
+    MatchState matchState = new MatchState();
 
     for (LogEntry logEntry in logs) {
       // If we have a log entry match, copy the saved matches from the
       // scratch buffer into the return list, as well as the matching entry,
       // if appropriate, and reset the scratch buffer. Continue processing
       // from the next key entry.
       if (keyEntry == logEntry) {
         if (scratch != null) {
           int numToCopy = scratch.length;
           if (distance > 0 && distance < numToCopy) {
             numToCopy = distance;
           }
           for (var i = scratch.length - numToCopy; i < scratch.length; i++) {
             rtn.logs.add(scratch[i]);
           }
           scratch.clear();
         } else {
           remainingCount = distance > 0 ? distance : logs.length;
         }
         if (includeKeys) {
           rtn.logs.add(keyEntry);
         }
         if (keyIterator.hasNext()) {
           keyEntry = keyIterator.next();
         } else if (isPreceding) { // We're done.
           break;
         }
       } else if (remainingCount > 0 &&
-                 mockNameFilter.matches(logEntry.mockName) &&
+                 mockNameFilter.matches(logEntry.mockName, matchState) &&
                  logFilter(logEntry)) {
         if (scratch != null) {
           scratch.add(logEntry);
         } else {
           rtn.logs.add(logEntry);
           --remainingCount;
         }
       }
     }
     return rtn;
@@ skipping 55 matching lines @@
 
 /**
  * [_TimesMatcher]s are used to make assertions about the number of
  * times a method was called.
  */
 class _TimesMatcher extends BaseMatcher {
   final int min, max;
 
   const _TimesMatcher(this.min, [this.max = -1]);
 
-  bool matches(logList) => logList.length >= min &&
+  bool matches(logList, MatchState matchState) => logList.length >= min &&
       (max < 0 || logList.length <= max);
 
   Description describe(Description description) {
-    description.add(' to be called ');
+    description.add('to be called ');
     if (max < 0) {
       description.add('at least $min');
     } else if (max == min) {
       description.add('$max');
     } else if (min == 0) {
       description.add('at most $max');
     } else {
       description.add('between $min and $max');
     }
     return description.add(' times');
   }
 
-  Description describeMismatch(logList, Description mismatchDescription) =>
+  Description describeMismatch(logList, Description mismatchDescription,
+                               MatchState matchState, bool verbose) =>
       mismatchDescription.add('was called ${logList.length} times');
 }
 
 /** [happenedExactly] matches an exact number of calls. */
 Matcher happenedExactly(count) {
   return new _TimesMatcher(count, count);
 }
 
 /** [happenedAtLeast] matches a minimum number of calls. */
 Matcher happenedAtLeast(count) {
@@ skipping 20 matching lines @@
 /**
  * [_ResultMatcher]s are used to make assertions about the results
  * of method calls. These can be used as optional parameters to [getLogs].
  */
 class _ResultMatcher extends BaseMatcher {
   final Action action;
   final Matcher value;
 
   const _ResultMatcher(this.action, this.value);
 
-  bool matches(item) {
+  bool matches(item, MatchState matchState) {
     if (item is! LogEntry) {
      return false;
     }
     // normalize the action; _PROXY is like _RETURN.
     Action eaction = item.action;
     if (eaction == Action.PROXY) {
       eaction = Action.RETURN;
     }
-    return (eaction == action && value.matches(item.value));
+    return (eaction == action && value.matches(item.value, matchState));
   }
 
   Description describe(Description description) {
     description.add(' to ');
     if (action == Action.RETURN || action == Action.PROXY)
       description.add('return ');
     else
       description.add('throw ');
     return description.addDescriptionOf(value);
   }
 
-  Description describeMismatch(item, Description mismatchDescription) {
+  Description describeMismatch(item, Description mismatchDescription,
+                               MatchState matchState, bool verbose) {
     if (item.action == Action.RETURN || item.action == Action.PROXY) {
       mismatchDescription.add('returned ');
     } else {
       mismatchDescription.add('threw ');
     }
     mismatchDescription.add(item.value);
     return mismatchDescription;
   }
 }
 
@@ skipping 37 matching lines @@
  * We could make this class use _ResultMatcher but it doesn't buy that
  * match and adds some perf hit, so there is some duplication here.
  */
 class _ResultSetMatcher extends BaseMatcher {
   final Action action;
   final Matcher value;
   final _Frequency frequency; // ALL, SOME, or NONE.
 
   const _ResultSetMatcher(this.action, this.value, this.frequency);
 
-  bool matches(logList) {
+  bool matches(logList, MatchState matchState) {
     for (LogEntry entry in logList) {
       // normalize the action; PROXY is like RETURN.
       Action eaction = entry.action;
       if (eaction == Action.PROXY) {
         eaction = Action.RETURN;
       }
-      if (eaction == action && value.matches(entry.value)) {
+      if (eaction == action && value.matches(entry.value, matchState)) {
         if (frequency == _Frequency.NONE) {
+          matchState.state = {
+              'state' : matchState.state,
+              'entry' : entry
+          };
           return false;
         } else if (frequency == _Frequency.SOME) {
           return true;
         }
       } else {
         // Mismatch.
         if (frequency == _Frequency.ALL) { // We need just one mismatch to fail.
+          matchState.state = {
+              'state' : matchState.state,
+              'entry' : entry
+          };
           return false;
         }
       }
     }
     // If we get here, then if count is _ALL we got all matches and
     // this is success; otherwise we got all mismatched which is
     // success for count == _NONE and failure for count == _SOME.
     return (frequency != _Frequency.SOME);
   }
 
   Description describe(Description description) {
     description.add(' to ');
     description.add(frequency == _Frequency.ALL ? 'alway ' :
         (frequency == _Frequency.NONE ? 'never ' : 'sometimes '));
     if (action == Action.RETURN || action == Action.PROXY)
       description.add('return ');
     else
       description.add('throw ');
     return description.addDescriptionOf(value);
   }
 
-  Description describeMismatch(logList, Description mismatchDescription) {
+  Description describeMismatch(logList, Description mismatchDescription,
+                               MatchState matchState, bool verbose) {
     if (frequency != _Frequency.SOME) {
-      for (LogEntry entry in logList) {
-        if (entry.action != action || !value.matches(entry.value)) {
-          if (entry.action == Action.RETURN || entry.action == Action.PROXY)
-            mismatchDescription.add('returned ');
-          else
-            mismatchDescription.add('threw ');
-          mismatchDescription.add(entry.value);
-          mismatchDescription.add(' at least once');
-          break;
-        }
+      LogEntry entry = matchState.state['entry'];
+      if (entry.action == Action.RETURN || entry.action == Action.PROXY) {
+        mismatchDescription.add('returned ');
+      } else {
+        mismatchDescription.add('threw ');
       }
+      mismatchDescription.add(entry.value);
+      mismatchDescription.add(' that ');
+      value.describeMismatch(entry.value, mismatchDescription,
+        matchState.state['state'], verbose);
+      mismatchDescription.add(' at least once');
     } else {
       mismatchDescription.add('never did');
     }
     return mismatchDescription;
   }
 }
 
 /**
  *[alwaysReturned] asserts that all matching calls to a method returned
  * a value that matched [value].
@@ skipping 193 matching lines @@
    * of [Behavior]s, and find the first match that still has return
    * values available, and then do the action specified by that
    * return value. If we find no [Behavior] to apply an exception is
    * thrown.
    */
   noSuchMethod(String method, List args) {
     if (method.startsWith('get:')) {
       method = 'get ${method.substring(4)}';
     }
     bool matchedMethodName = false;
+    MatchState matchState = new MatchState();
     for (String k in _behaviors.getKeys()) {
       Behavior b = _behaviors[k];
-      if (b.matcher.nameFilter.matches(method)) {
+      if (b.matcher.nameFilter.matches(method, matchState)) {
         matchedMethodName = true;
       }
       if (b.matches(method, args)) {
         List actions = b.actions;
         if (actions == null || actions.length == 0) {
           continue; // No return values left in this Behavior.
         }
         // Get the first response.
         Responder response = actions[0];
         // If it is exhausted, remove it from the list.
@@ skipping 134 matching lines @@
                        arg3 = _noArg,
                        arg4 = _noArg,
                        arg5 = _noArg,
                        arg6 = _noArg,
                        arg7 = _noArg,
                        arg8 = _noArg,
                        arg9 = _noArg]) =>
       getLogs(callsTo(method, arg0, arg1, arg2, arg3, arg4,
           arg5, arg6, arg7, arg8, arg9));
 }