CallMatchers can now be null, or take null for a method name. This might be

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 66 matching lines @@
  * A [CallMatcher] is a special matcher used to match method calls (i.e.
  * a method name and set of arguments). It is not a [Matcher] like the
  * unit test [Matcher], but instead represents a method name and a
  * collection of [Matcher]s, one per argument, that will be applied
  * to the parameters to decide if the method call is a match.
  */
 class CallMatcher {
   String name;
   List<Matcher> argMatchers;
 
-  CallMatcher(this.name, [
+  CallMatcher([this.name,
               arg0 = _noArg,
               arg1 = _noArg,
               arg2 = _noArg,
               arg3 = _noArg,
               arg4 = _noArg,
               arg5 = _noArg,
               arg6 = _noArg,
               arg7 = _noArg,
               arg8 = _noArg,
               arg9 = _noArg]) {
@@ skipping 21 matching lines @@
   }
 
   /**
    * We keep our behavior specifications in a Map, which is keyed
    * by the [CallMatcher]. To make the keys unique and to get a
    * descriptive value for the [CallMatcher] we have this override
    * of [toString()].
    */
   String toString() {
     Description d = new StringDescription();
-    d.add(name).add('(');
+    if (name != null) d.add(name);
+    d.add('(');
     for (var i = 0; i < argMatchers.length; i++) {
       if (i > 0) d.add(', ');
       d.addDescriptionOf(argMatchers[i]);
     }
     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 (method != this.name) {
+    if (this.name != null && method != this.name) {
       return false;
     }
     if (arguments.length < argMatchers.length) {
       throw new Exception("Less arguments than matchers for $name");
     }
     for (var i = 0; i < argMatchers.length; i++) {
       if (!argMatchers[i].matches(arguments[i])) {
         return false;
       }
     }
     return true;
   }
 }
 
 /** [callsTo] returns a CallMatcher for the specified signature. */
-CallMatcher callsTo(String method, [
-                        arg0 = _noArg,
-                        arg1 = _noArg,
-                        arg2 = _noArg,
-                        arg3 = _noArg,
-                        arg4 = _noArg,
-                        arg5 = _noArg,
-                        arg6 = _noArg,
-                        arg7 = _noArg,
-                        arg8 = _noArg,
-                        arg9 = _noArg]) {
+CallMatcher callsTo([String method,
+                     arg0 = _noArg,
+                     arg1 = _noArg,
+                     arg2 = _noArg,
+                     arg3 = _noArg,
+                     arg4 = _noArg,
+                     arg5 = _noArg,
+                     arg6 = _noArg,
+                     arg7 = _noArg,
+                     arg8 = _noArg,
+                     arg9 = _noArg]) {
   return new CallMatcher(method, arg0, arg1, arg2, arg3, arg4,
       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.
@@ skipping 138 matching lines @@
   LogEntryList([this.filter]) {
     logs = new List<LogEntry>();
   }
 
   /** Add a [LogEntry] to the log. */
   add(LogEntry entry) => logs.add(entry);
 
   /**
    * Create a new [LogEntryList] consisting of [LogEntry]s from
    * this list that match the specified [mockName] and [logFilter].
-   * If [mockName] is null, all entries will be checked. If [destructive]
+   * If [mockName] is null, all entries will be checked. If [logFilter]
+   * is null, all entries in the log will be returned. If [destructive]
    * is true, the log entries are removed from the original list.
    */
-  LogEntryList getMatches(String mockName,
+  LogEntryList getMatches([String mockName,
                           CallMatcher logFilter,
-                          [Matcher actionMatcher,
+                          Matcher actionMatcher,
                           bool destructive = false]) {
+    if (logFilter == null) {
+      logFilter = new CallMatcher();
+    }
     String filterName = _qualifiedName(mockName, logFilter.toString());
     LogEntryList rtn = new LogEntryList(filterName);
     for (var i = 0; i < logs.length; i++) {
       LogEntry entry = logs[i];
       if (mockName != null && mockName != entry.mockName) {
         continue;
       }
       if (logFilter.matches(entry.methodName, entry.args)) {
         if (actionMatcher == null || actionMatcher.matches(entry)) {
           rtn.add(entry);
@@ skipping 519 matching lines @@
    * [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]) {
+  LogEntryList getLogs([CallMatcher logFilter,
+                        Matcher actionMatcher,
+                        bool destructive = false]) {
     return log.getMatches(name, logFilter, actionMatcher, destructive);
   }
 }