Make mock behaviors be ordered.

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 1218 matching lines @@
   new _ResultSetMatcher(Action.THROW, wrapMatcher(value), _Frequency.NONE);
 
 /** The shared log used for named mocks. */
 LogEntryList sharedLog = null;
 
 /** The base class for all mocked objects. */
 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. Behaviors are ordered, but are
+   * also keyed, so we keep a hash table of indices pointing to a List.
+   */
+  Map<String,int> _behaviorIndices;
+  List<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;
 
   /** 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 {
     logging = true;
-    _behaviors = new Map<String,Behavior>();
+    _behaviorIndices = new Map<String,int>();

[Siggi Cherem (dart-lang), 2013/04/30 03:25:31]

what about using LinkedHashMap instead of Map?

That should take care of iterating things in the order in which they are added
=)

[gram, 2013/04/30 16:53:39]

Done.

+    _behaviors = new List<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 {
     if (log != null && name == null) {
       throw new Exception("Mocks with shared logs must have a name.");
     }
     logging = enableLogging;
-    _behaviors = new Map<String,Behavior>();
+    _behaviorIndices = new Map<String,int>();
+    _behaviors = new List<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 (!_behaviorIndices.containsKey(key)) {
       Behavior b = new Behavior(logFilter);
-      _behaviors[key] = b;
+      _behaviorIndices[key] = _behaviors.length;
+      _behaviors.add(b);
       return b;
     } else {
-      return _behaviors[key];
+      return _behaviors[_behaviorIndices[key]];
     }
   }
 
   /**
    * This is the handler for method calls. We loop 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(Invocation invocation) {
     var method = MirrorSystem.getName(invocation.memberName);
     var args = invocation.positionalArguments;
     if (invocation.isGetter) {
       method = 'get $method';
     } else if (invocation.isSetter) {
       method = 'set $method';
       // Remove the trailing '='.
       if (method[method.length-1] == '=') {
         method = method.substring(0, method.length - 1);
       }
     }
     bool matchedMethodName = false;
     MatchState matchState = new MatchState();
-    for (String k in _behaviors.keys) {
-      Behavior b = _behaviors[k];
+    for (var i = 0; i < _behaviors.length; i++) {
+      Behavior b = _behaviors[i];
       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.
         }
         // Get the first response.
         Responder response = actions[0];
@@ skipping 139 matching lines @@
                        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));
 
   /** Clear the behaviors for the Mock. */
-  void resetBehavior() => _behaviors.clear();
+  void resetBehavior() {
+    _behaviorIndices.clear();
+    _behaviors.clear();
+  }
 
   /** Clear the logs for the Mock. */
   void clearLogs() {
     if (log != null) {
       if (name == null) { // This log is not shared.
         log.logs.clear();
       } else { // This log may be shared.
         log.logs = log.logs.where((e) => e.mockName != name).toList();
       }
     }
   }
 
   /** Clear both logs and behavior. */
   void reset() {
     resetBehavior();
     clearLogs();
   }
 }