pkg/unittest: tweaks to mock, re-enabled most tests

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 170 matching lines @@
 
   /** Throw a supplied value. */
   static const THROW = const Action._('THROW');
 
   /** Call a supplied function. */
   static const PROXY = const Action._('PROXY');
 
   const Action._(this.name);
 
   final String name;
+
+  String toString() => 'Action: $name';
 }
 
 /**
  * The behavior of a method call in the mock library is specified
  * with [Responder]s. A [Responder] has a [value] to throw
  * or return (depending on the type of [action]),
  * and can either be one-shot, multi-shot, or infinitely repeating,
  * depending on the value of [count (1, greater than 1, or 0 respectively).
  */
 class Responder {
-  var value;
-  Action action;
+  final Object value;
+  final Action action;
   int count;
   Responder(this.value, [this.count = 1, this.action = Action.RETURN]);
 }
 
 /**
  * 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.
@@ skipping 1030 matching lines @@
 /** The shared log used for named mocks. */
 LogEntryList sharedLog = null;
 
 /** The base class for all mocked objects. */
 @proxy
 class Mock {
   /** The mock name. Needed if the log is shared; optional otherwise. */
   final String name;
 
   /** The set of [Behavior]s supported. */
-  LinkedHashMap<String,Behavior> _behaviors;
-
-  /** The [log] of calls made. Only used if [name] is null. */
-  LogEntryList log;
+  final LinkedHashMap<String,Behavior> _behaviors;
 
   /** How to handle unknown method calls - swallow or throw. */
   final bool _throwIfNoBehavior;
 
   /** For spys, the real object that we are spying on. */
-  Object _realObject;
+  final Object _realObject;
+
+  /** The [log] of calls made. Only used if [name] is null. */
+  LogEntryList log;
 
   /** Whether to create an audit log or not. */
   bool _logging;
 
   bool get logging => _logging;
   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, log = null, name = null {
+  Mock() :
+    _throwIfNoBehavior = false, log = null, name = null, _realObject = null,
+    _behaviors = new LinkedHashMap<String,Behavior>() {
     logging = true;
-    _behaviors = new LinkedHashMap<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,
                throwIfNoBehavior: false,
-               enableLogging: true}) : _throwIfNoBehavior = throwIfNoBehavior {
+               enableLogging: true})
+      : _throwIfNoBehavior = throwIfNoBehavior, _realObject = null,
+        _behaviors = new LinkedHashMap<String,Behavior>() {
     if (log != null && name == null) {
       throw new Exception("Mocks with shared logs must have a name.");
     }
     logging = enableLogging;
-    _behaviors = new LinkedHashMap<String,Behavior>();
   }
 
   /**
    * This constructor creates a spy with no user-defined behavior.
    * This is simply a proxy for a real object that passes calls
    * through to that real object but captures an audit trail of
    * calls made to the object that can be queried and validated
    * later.
    */
   Mock.spy(this._realObject, {this.name, this.log})
@@ skipping 47 matching lines @@
         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;
     Map matchState = {};
+
+    print("hanging with behaviors");
+    print(new Map.from(_behaviors));
     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();
   }
 }