Added ability to disable logging in mocks, to avoid the memory overhead if you don't need behavior …

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) {
   var description = new StringDescription();
   description.add('Expected ${signature} ').addDescriptionOf(matcher).
       add('\n     but: ');
-  matcher.describeMismatch(actual, description);
+  matcher.describeMismatch(actual, description).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 {
@@ skipping 123 matching lines @@
 
   /**
    * 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)) {
       return false;
     }
     if (arguments.length < argMatchers.length) {
-      throw new Exception("Less arguments than matchers for $method");
+      throw new Exception("Less arguments than matchers for $method.");
     }
     for (var i = 0; i < argMatchers.length; i++) {
       if (!argMatchers[i].matches(arguments[i])) {
         return false;
       }
     }
     return true;
   }
 }
 
@@ skipping 558 matching lines @@
   /** The mock name. Needed if the log is shared; optional otherwise. */
   final String name;
 
   /** The set of [behavior]s supported. */
   Map<String,Behavior> behaviors;
 
   /** The [log] of calls made. Only used if [name] is null. */
   LogEntryList log;
 
   /** How to handle unknown method calls - swallow or throw. */
-  final bool throwIfNoBehavior = false;
+  final bool throwIfNoBehavior;
+
+  /** Whether to create an audit log or not. */
+  final bool logging;
 
   /**
    * Default constructor. Unknown method calls are allowed and logged,
    * the mock has no name, and has its own log.
    */
-  Mock() : throwIfNoBehavior = false, name = null {
+  Mock() : throwIfNoBehavior = false, logging = true, name = null {
     log = new LogEntryList();
     behaviors = new Map<String,Behavior>();
   }
 
   /**
    * This constructor makes a mock that has a [name] and possibly uses
    * a shared [log]. If [throwIfNoBehavior] is true, any calls to methods
    * that have no defined behaviors will throw an exception; otherwise they
-   * will be allowed and logged (but will not do anything).
+   * will be allowed and logged (but will not do anything). If [logging]
+   * is false, no logging will be done (whether or not a [log] is supplied).
    */
   Mock.custom([this.name,
                this.log,
-               this.throwIfNoBehavior = false]) {
-    if (log == null) {
+               this.throwIfNoBehavior = false,
+               this.logging = true]) {
+    if (!logging) {
+      log = null;
+    } else if (log == null) {
       log = new LogEntryList();
     }
     behaviors = new Map<String,Behavior>();
   }
 
   /**
    * [when] is used to create a new or extend an existing [Behavior].
    * A [CallMatcher] [filter] must be supplied, and the [Behavior]s for
    * that signature are returned (being created first if needed).
    *
@@ skipping 40 matching lines @@
         // Note that for endlessly repeating values, we started the count at
         // 0, so we get a potentially useful value here, which is the
         // (negation of) the number of times we returned the value.
         if (--response.count == 0) {
           actions.removeRange(0, 1);
         }
         // Do the response.
         _Action action = response.action;
         var value = response.value;
         if (action == _Action.RETURN) {
-          log.add(new LogEntry(name, method, args, action, value));
+          if (log != null) {

[Siggi Cherem (dart-lang), 2012/07/11 22:46:04]

why not continbue using the flag? ('if (logging)' reads more nicely)

[gram, 2012/07/11 23:24:07]

You're right - I originally didn't mean to make the flag a member. Given that I
did, I should use it; we could even have the logging turned on and off at
different times.

+            log.add(new LogEntry(name, method, args, action, value));
+          }
           return value;
         } else if (action == _Action.THROW) {
-          log.add(new LogEntry(name, method, args, action, value));
+          if (log != null) {
+            log.add(new LogEntry(name, method, args, action, value));
+          }
           throw value;
         } else if (action == _Action.PROXY) {
           var rtn;
           switch (args.length) {
             case 0:
               rtn = value();
               break;
             case 1:
               rtn = value(args[0]);
               break;
@@ skipping 24 matching lines @@
             case 9:
               rtn = value(args[0], args[1], args[2], args[3],
                   args[4], args[5], args[6], args[7], args[8]);
               break;
             case 9:
               rtn = value(args[0], args[1], args[2], args[3],
                   args[4], args[5], args[6], args[7], args[8], args[9]);
               break;
             default:
               throw new Exception(
-                  "Cannot proxy calls with more than 10 parameters");
+                  "Cannot proxy calls with more than 10 parameters.");
           }
-          log.add(new LogEntry(name, method, args, action, rtn));
+          if (log != null) {
+            log.add(new LogEntry(name, method, args, action, rtn));
+          }
           return rtn;
         }
       }
     }
     if (matchedMethodName) {
       // User did specify behavior for this method, but all the
       // actions are exhausted. This is considered an error.
       throw new Exception('No more actions for method '
-          '${_qualifiedName(name, method)}');
+          '${_qualifiedName(name, method)}.');
     } else if (throwIfNoBehavior) {
       throw new Exception('No behavior specified for method '
-          '${_qualifiedName(name, method)}');
+          '${_qualifiedName(name, method)}.');
     }
-    // User hasn't specified behavior for this method; we don't throw
+    // Otherwise user hasn't specified behavior for this method; we don't throw
     // so we can underspecify.
-    log.add(new LogEntry(name, method, args, _Action.IGNORE));
+    if (log != null) {
+      log.add(new LogEntry(name, method, args, _Action.IGNORE));
+    }
   }
 
   /** [verifyZeroInteractions] returns true if no calls were made */
-  bool verifyZeroInteractions() => log.logs.length == 0;
+  bool verifyZeroInteractions() {
+    if (log == null) {
+      throw new Exception("Can't verify behavior when logging is disabled.");
+    }
+    return log.logs.length == 0;
+  }
 
   /**
    * [getLogs] extracts all calls from the call log that match the
    * [logFilter] [CallMatcher], and returns the matching list of
    * [LogEntry]s. If [destructive] is false (the default) the matching
    * calls are left in the log, else they are removed. Removal allows
    * us to verify a set of interactions and then verify that there are
    * no other interactions left. [actionMatcher] can be used to further
    * restrict the returned logs based on the action the mock performed.
    *
    * Typical usage:
    *
    *     getLogs(callsTo(...)).verify(...);
    */
   LogEntryList getLogs([CallMatcher logFilter,
                         Matcher actionMatcher,
                         bool destructive = false]) {
-    return log.getMatches(name, logFilter, actionMatcher, destructive);
+    if (log == null) {
+      throw new Exception("Can't retrieve logs when logging is disabled.");
+    } else {
+      return log.getMatches(name, logFilter, actionMatcher, destructive);
+    }
   }
 }