Added the ability to tun off logging for individual behaviors.

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.
  */
@@ skipping 186 matching lines @@
       arg5, arg6, arg7, arg8, arg9);
 }
 
 /**
  * A [Behavior] represents how a [Mock] will respond to one particular
  * type of method call.
  */
 class Behavior {
   CallMatcher matcher; // The method call matcher.
   List<Responder> actions; // The values to return/throw or proxies to call.
+  bool logging = true;
 
   Behavior (this.matcher) {
     actions = new List<Responder>();
   }
 
   /**
    * Adds a [Responder] that returns a [value] for [count] calls
    * (1 by default).
    */
   Behavior thenReturn(value, [count = 1]) {
@@ skipping 203 matching lines @@
   LogEntryList verify(Matcher matcher) {
     if (_mockFailureHandler == null) {
       _mockFailureHandler =
           new _MockFailureHandler(getOrCreateExpectFailureHandler());
     }
     expect(logs, matcher, filter, _mockFailureHandler);
     return this;
   }
 
   /**
+   * Iterate through the list and call the [validator] function with the
+   * log [List] and position. The [validator] should return the number of
+   * positions to advance upon success, or zero upon failure. When zero is
+   * returned an error is reported. [reason] can be used to provide a
+   * more descriptive failure message. If a failure occurred false will be
+   * returned (unless the failure handler itself threw an exception);
+   * otherwise true is returned.
+   * The use case here is to perform more complex validations; for example
+   * we may want to assert that the return value from some function is
+   * later used as a parameter to a following function. If we filter the logs
+   * to include just these two functions we can write a simple validator to
+   * do this check.
+   */
+  bool stepwiseValidate(Function validator, [String reason = '']) {

[Siggi Cherem (dart-lang), 2012/08/07 23:58:47]

looking at the test, I think it is worth defining a typedef for validator:

#typedef int StepValidator(List<LogEntry> logs, int pos);

and move the documentation of [validator] there. 
1 type == 1000 words :-)

+    if (_mockFailureHandler == null) {
+      _mockFailureHandler =
+          new _MockFailureHandler(getOrCreateExpectFailureHandler());
+    }
+    var i = 0;
+    while (i < logs.length) {
+      var n = validator(logs, i);
+      if (n == 0) {
+        if (reason.length > 0) {
+          reason = ': $reason';
+        }
+        _mockFailureHandler.fail("Stepwise validation failed at $filter "
+                                 "position $i$reason");
+        return false;
+      } else {
+        i += n;
+      }
+    }
+    return true;
+  }
+
+  /**
    * Turn the logs into human-readable text. If [baseTime] is specified
    * then each entry is prefixed with the offset from that time in
    * milliseconds; otherwise the time of day is used.
    */
   String toString([Date baseTime]) {
     String s = '';
     for (var e in logs) {
       s = '$s${e.toString(baseTime)}\n';
     }
     return s;
   }
 
   /**
    *  Find the first log entry that satisfies [logFilter] and
    *  return its position. A search [start] position can be provided
    *  to allow for repeated searches. [logFilter] can be a [CallMatcher],
    *  or a predicate function that takes a [LogEntry] argument and returns
    *  a bool. If [logFilter] is null, it will match any [LogEntry].
    *  If no entry is found, then [failureReturnValue] is returned.
+   *  After each check the position is updated by [skip], so using
+   *  [skip] of -1 allows backward searches.
    */
-  int findLogEntry(logFilter, [int start = 0, int failureReturnValue = -1]) {
+  int findLogEntry(logFilter, [int start = 0, int failureReturnValue = -1,
+      skip = 1]) {
     logFilter = _makePredicate(logFilter);
     int pos = start;
-    while (pos < logs.length) {
+    while (pos >= 0 && pos < logs.length) {
       if (logFilter(logs[pos])) {
         return pos;
       }
-      ++pos;
+      pos += skip;
     }
     return failureReturnValue;
   }
 
   /**
    * Returns log events that happened up to the first one that
    * satisfies [logFilter]. If [inPlace] is true, then returns
    * this LogEntryList after removing the from the first satisfier;
    * onwards otherwise a new list is created. [description]
    * is used to create a new name for the resulting list.
@@ skipping 595 matching lines @@
 LogEntryList sharedLog = null;
 
 /**
  * [Mock] is the base class for all mocked objects, with
  * support for basic mocking.
  *
  * To create a mock objects for some class T, create a new class using:
  *
  *     class MockT extends Mock implements T {};
  *
- * Then specify the behavior of the Mock for different methods using
- * [when] (to select the method and parameters) and [thenReturn],
- * [alwaysReturn], [thenThrow], [alwaysThrow], [thenCall] or [alwaysCall].
+ * Then specify the [Behavior] of the Mock for different methods using
+ * [when] (to select the method and parameters) and then the [Action]s
+ * for the [Behavior] by calling [thenReturn], [alwaysReturn], [thenThrow],
+ * [alwaysThrow], [thenCall] or [alwaysCall].
+ *
  * [thenReturn], [thenThrow] and [thenCall] are one-shot so you would
  * typically call these more than once to specify a sequence of actions;
  * this can be done with chained calls, e.g.:
  *
  *      m.when(callsTo('foo')).
  *          thenReturn(0).thenReturn(1).thenReturn(2);
  *
  * [thenCall] and [alwaysCall] allow you to proxy mocked methods, chaining
  * to some other implementation. This provides a way to implement 'spies'.
  *
+ * You can disable logging for a particular [Behavior] easily:
+ *
+ *     m.when(callsTo('bar')).logging = false;
+ *
  * You can then use the mock object. Once you are done, to verify the
  * behavior, use [getLogs] to extract a relevant subset of method call
  * logs and apply [Matchers] to these through calling [verify].
  *
  * A Mock can be given a name when constructed. In this case instead of
  * keeping its own log, it uses a shared log. This can be useful to get an
  * audit trail of interleaved behavior. It is the responsibility of the user
  * to ensure that mock names, if used, are unique.
  *
  * Limitations:
@@ skipping 144 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) {
-          if (_logging) {
+          if (_logging && b.logging) {
             log.add(new LogEntry(name, method, args, action, value));
           }
           return value;
         } else if (action == Action.THROW) {
-          if (_logging) {
+          if (_logging && b.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:
@@ skipping 28 matching lines @@
                   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.");
           }
-          if (_logging) {
+          if (_logging && b.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 '
@@ skipping 59 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));
 }