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 551 matching lines @@
  *         real = new Foo();
  *         this.when(callsTo('bar')).alwaysCall(real.bar);
  *       }
  *     }
  *
  */
 class Mock {
   /** 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 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. */
+  bool _logging;
+
+  bool get logging() => _logging;
+  bool set logging(bool value) {
+    if (value && log == null) {
+      log = new LogEntryList();
+    }
+    _logging = value;
+  }
 
   /**
    * Default constructor. Unknown method calls are allowed and logged,
    * the mock has no name, and has its own log.
    */
-  Mock() : throwIfNoBehavior = false, name = null {
-    log = new LogEntryList();
-    behaviors = new Map<String,Behavior>();
+  Mock() : _throwIfNoBehavior = false, log = null, name = null {
+    logging = true;
+    _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).
+   * If [enableLogging] is false, no logging will be done initially (whether
+   * or not a [log] is supplied), but [logging] can be set to true later.
    */
   Mock.custom([this.name,
                this.log,
-               this.throwIfNoBehavior = false]) {
-    if (log == null) {
-      log = new LogEntryList();
-    }
-    behaviors = new Map<String,Behavior>();
+               throwIfNoBehavior = false,
+               enableLogging = true]) : _throwIfNoBehavior = throwIfNoBehavior {
+    logging = enableLogging;
+    _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).
    *
    * Typical use case:
    *
    *     mock.when(callsTo(...)).alwaysReturn(...);
    */
   Behavior when(CallMatcher logFilter) {
     String key = logFilter.toString();
-    if (!behaviors.containsKey(key)) {
+    if (!_behaviors.containsKey(key)) {
       Behavior b = new Behavior(logFilter);
-      behaviors[key] = b;
+      _behaviors[key] = b;
       return b;
     } else {
-      return behaviors[key];
+      return _behaviors[key];
     }
   }
 
   /**
    * This is the handler for method calls. We loo through the list
    * 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;
-    for (String k in behaviors.getKeys()) {
-      Behavior b = behaviors[k];
+    for (String k in _behaviors.getKeys()) {
+      Behavior b = _behaviors[k];
       if (b.matcher.nameFilter.matches(method)) {
         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.
         // 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 (_logging) {
+            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 (_logging) {
+            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 (_logging) {
+            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)}');
-    } else if (throwIfNoBehavior) {
+          '${_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 (_logging) {
+      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) {
+      // This means we created the mock with logging off and have never turned
+      // it on, so it doesn't make sense to verify behavior on such a mock.
+      throw new
+          Exception("Can't verify behavior when logging was never enabled.");
+    }
+    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) {
+      // This means we created the mock with logging off and have never turned
+      // it on, so it doesn't make sense to get logs from such a mock.
+      throw new
+          Exception("Can't retrieve logs when logging was never enabled.");
+    } else {
+      return log.getMatches(name, logFilter, actionMatcher, destructive);
+    }
   }
 }