Improved error messages from unittest.

pkg/unittest/lib/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.
 
 /**
  * A simple mocking/spy library.
  *
  * ## Installing ##
  *
  * Use [pub][] to install this package. Add the following to your `pubspec.yaml`
@@ skipping 118 matching lines @@
 
 import 'matcher.dart';
 
 /**
  * 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,
-                              MatchState matchState, bool verbose) {
+                              Map matchState, bool verbose) {
   var description = new StringDescription();
   description.add('Expected ${signature} ').addDescriptionOf(matcher).
       add('\n     but: ');
   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,
-                 MatchState matchState, bool verbose) {
+                 Map matchState, bool verbose) {
     proxy.fail(_mockingErrorFormatter(actual, matcher, reason,
         matchState, verbose));
   }
 }
 
 _MockFailureHandler _mockFailureHandler = null;
 
 /** Sentinel value for representing no argument. */
 class _Sentinel {
   const _Sentinel();
@@ skipping 110 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) {
-    var matchState = new MatchState();
+    var matchState = {};
     if (!nameFilter.matches(method, matchState)) {
       return false;
     }
     var numArgs = (arguments == null) ? 0 : arguments.length;
     if (numArgs < 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], matchState)) {
         return false;
@@ skipping 232 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();
+    var matchState = {};
     for (var i = 0; i < logs.length; i++) {
       LogEntry entry = logs[i];
       if (mockNameFilter.matches(entry.mockName, matchState) &&
           entryFilter(entry)) {
         if (actionMatcher == null ||
             actionMatcher.matches(entry, matchState)) {
           rtn.add(entry);
           if (destructive) {
             int startIndex = i--;
             logs.removeRange(startIndex, startIndex + 1);
@@ skipping 333 matching lines @@
     List scratch = null;
     int remainingCount = 0;
     if (isPreceding) {
       scratch = new List();
       remainingCount = logs.length;
     }
 
     var keyIterator = keys.logs.iterator;
     keyIterator.moveNext();
     LogEntry keyEntry = keyIterator.current;
-    MatchState matchState = new MatchState();
+    Map 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) {
@@ skipping 84 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, MatchState matchState) => logList.length >= min &&
+  bool matches(logList, Map matchState) => logList.length >= min &&
       (max < 0 || logList.length <= max);
 
   Description describe(Description description) {
     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,
-                               MatchState matchState, bool verbose) =>
+                               Map 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, MatchState matchState) {
+  bool matches(item, Map 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, 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,
-                               MatchState matchState, bool verbose) {
+                               Map 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, MatchState matchState) {
+  bool matches(logList, Map 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, matchState)) {
         if (frequency == _Frequency.NONE) {
-          matchState.state = {
-              'state' : matchState.state,
-              'entry' : entry
-          };
+          addStateInfo(matchState, {'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
-          };
+          addStateInfo(matchState, {'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,
-                               MatchState matchState, bool verbose) {
+                               Map matchState, bool verbose) {
     if (frequency != _Frequency.SOME) {
-      LogEntry entry = matchState.state['entry'];
+      LogEntry entry = matchState['entry'];
       if (entry.action == Action.RETURN || entry.action == Action.PROXY) {
         mismatchDescription.add('returned');
       } else {
         mismatchDescription.add('threw');
       }
       mismatchDescription.add(' value that ');
       value.describeMismatch(entry.value, mismatchDescription,
-        matchState.state['state'], verbose);
+        matchState['state'], verbose);
       mismatchDescription.add(' at least once');
     } else {
       mismatchDescription.add('never did');
     }
     return mismatchDescription;
   }
 }
 
 /**
  *[alwaysReturned] asserts that all matching calls to a method returned
@@ skipping 153 matching lines @@
       try {
         var result = mirror.delegate(invocation);
         log.add(new LogEntry(name, method, args, Action.PROXY, result));
         return result;
       } catch (e) {
         log.add(new LogEntry(name, method, args, Action.THROW, e));
         throw e;
       }
     }
     bool matchedMethodName = false;
-    MatchState matchState = new MatchState();
+    Map matchState = {};
     for (String k in _behaviors.keys) {
       Behavior b = _behaviors[k];
       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.
         }
@@ skipping 161 matching lines @@
       }
     }
   }
 
   /** Clear both logs and behavior. */
   void reset() {
     resetBehavior();
     clearLogs();
   }
 }