1 /**

     2  * Sinon.JS 1.2.0, 2011/09/27

     3  *

     4  * @author Christian Johansen (christian@cjohansen.no)

     5  *

     6  * (The BSD License)

     7  * 

     8  * Copyright (c) 2010-2011, Christian Johansen, christian@cjohansen.no

     9  * All rights reserved.

    10  * 

    11  * Redistribution and use in source and binary forms, with or without modification,

    12  * are permitted provided that the following conditions are met:

    13  * 

    14  *     * Redistributions of source code must retain the above copyright notice,

    15  *       this list of conditions and the following disclaimer.

    16  *     * Redistributions in binary form must reproduce the above copyright notice,

    17  *       this list of conditions and the following disclaimer in the documentation

    18  *       and/or other materials provided with the distribution.

    19  *     * Neither the name of Christian Johansen nor the names of his contributors

    20  *       may be used to endorse or promote products derived from this software

    21  *       without specific prior written permission.

    22  * 

    23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

    24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

    25  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    26  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

    27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

    28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

    29  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

    30  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

    31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

    32  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    33  */

    34 

    35 "use strict";

    36 /*jslint eqeqeq: false, onevar: false, forin: true, nomen: false, regexp: false, plusplus: false*/

    37 /*global module, require, __dirname, document*/

    38 /**

    39  * Sinon core utilities. For internal use only.

    40  *

    41  * @author Christian Johansen (christian@cjohansen.no)

    42  * @license BSD

    43  *

    44  * Copyright (c) 2010-2011 Christian Johansen

    45  */

    46 

    47 var sinon = (function () {

    48     var div = typeof document != "undefined" && document.createElement("div");

    49 

    50     function isNode(obj) {

    51         var success = false;

    52 

    53         try {

    54             obj.appendChild(div);

    55             success = div.parentNode == obj;

    56         } catch (e) {

    57             return false;

    58         } finally {

    59             try {

    60                 obj.removeChild(div);

    61             } catch (e) {}

    62         }

    63 

    64         return success;

    65     }

    66 

    67     function isElement(obj) {

    68         return div && obj && obj.nodeType === 1 && isNode(obj);

    69     }

    70 

    71     return {

    72         wrapMethod: function wrapMethod(object, property, method) {

    73             if (!object) {

    74                 throw new TypeError("Should wrap property of object");

    75             }

    76 

    77             if (typeof method != "function") {

    78                 throw new TypeError("Method wrapper should be function");

    79             }

    80 

    81             var wrappedMethod = object[property];

    82             var type = typeof wrappedMethod;

    83 

    84             if (type != "function") {

    85                 throw new TypeError("Attempted to wrap " + type + " property " + property +

    86                                     " as function");

    87             }

    88 

    89             if (wrappedMethod.restore && wrappedMethod.restore.sinon) {

    90                 throw new TypeError("Attempted to wrap " + property + " which is already wrapped");

    91             }

    92 

    93             if (wrappedMethod.calledBefore) {

    94                 var verb = !!wrappedMethod.returns ? "stubbed" : "spied on";

    95                 throw new TypeError("Attempted to wrap " + property + " which is already " + verb);

    96             }

    97 

    98             var owned = object.hasOwnProperty(property);

    99             object[property] = method;

   100             method.displayName = property;

   101 

   102             method.restore = function () {

   103                 if(owned) {

   104                     object[property] = wrappedMethod;

   105                 } else {

   106                     delete object[property];

   107                 }

   108             };

   109 

   110             method.restore.sinon = true;

   111 

   112             return method;

   113         },

   114 

   115         extend: function extend(target) {

   116             for (var i = 1, l = arguments.length; i < l; i += 1) {

   117                 for (var prop in arguments[i]) {

   118                     if (arguments[i].hasOwnProperty(prop)) {

   119                         target[prop] = arguments[i][prop];

   120                     }

   121 

   122                     // DONT ENUM bug, only care about toString

   123                     if (arguments[i].hasOwnProperty("toString") &&

   124                         arguments[i].toString != target.toString) {

   125                         target.toString = arguments[i].toString;

   126                     }

   127                 }

   128             }

   129 

   130             return target;

   131         },

   132 

   133         create: function create(proto) {

   134             var F = function () {};

   135             F.prototype = proto;

   136             return new F();

   137         },

   138 

   139         deepEqual: function deepEqual(a, b) {

   140             if (typeof a != "object" || typeof b != "object") {

   141                 return a === b;

   142             }

   143 

   144             if (isElement(a) || isElement(b)) {

   145                 return a === b;

   146             }

   147 

   148             if (a === b) {

   149                 return true;

   150             }

   151 

   152             if (Object.prototype.toString.call(a) == "[object Array]") {

   153                 if (a.length !== b.length) {

   154                     return false;

   155                 }

   156 

   157                 for (var i = 0, l = a.length; i < l; i += 1) {

   158                     if (!deepEqual(a[i], b[i])) {

   159                         return false;

   160                     }

   161                 }

   162 

   163                 return true;

   164             }

   165 

   166             var prop, aLength = 0, bLength = 0;

   167 

   168             for (prop in a) {

   169                 aLength += 1;

   170 

   171                 if (!deepEqual(a[prop], b[prop])) {

   172                     return false;

   173                 }

   174             }

   175 

   176             for (prop in b) {

   177                 bLength += 1;

   178             }

   179 

   180             if (aLength != bLength) {

   181                 return false;

   182             }

   183 

   184             return true;

   185         },

   186 

   187         functionName: function functionName(func) {

   188             var name = func.displayName || func.name;

   189 

   190             // Use function decomposition as a last resort to get function

   191             // name. Does not rely on function decomposition to work - if it

   192             // doesn't debugging will be slightly less informative

   193             // (i.e. toString will say 'spy' rather than 'myFunc').

   194             if (!name) {

   195                 var matches = func.toString().match(/function ([^\s\(]+)/);

   196                 name = matches && matches[1];

   197             }

   198 

   199             return name;

   200         },

   201 

   202         functionToString: function toString() {

   203             if (this.getCall && this.callCount) {

   204                 var thisValue, prop, i = this.callCount;

   205 

   206                 while (i--) {

   207                     thisValue = this.getCall(i).thisValue;

   208 

   209                     for (prop in thisValue) {

   210                         if (thisValue[prop] === this) {

   211                             return prop;

   212                         }

   213                     }

   214                 }

   215             }

   216 

   217             return this.displayName || "sinon fake";

   218         },

   219 

   220         getConfig: function (custom) {

   221             var config = {};

   222             custom = custom || {};

   223             var defaults = sinon.defaultConfig;

   224 

   225             for (var prop in defaults) {

   226                 if (defaults.hasOwnProperty(prop)) {

   227                     config[prop] = custom.hasOwnProperty(prop) ? custom[prop] : defaults[prop];

   228                 }

   229             }

   230 

   231             return config;

   232         },

   233 

   234         format: function (val) {

   235             return "" + val;

   236         },

   237 

   238         defaultConfig: {

   239             injectIntoThis: true,

   240             injectInto: null,

   241             properties: ["spy", "stub", "mock", "clock", "server", "requests"],

   242             useFakeTimers: true,

   243             useFakeServer: true

   244         },

   245 

   246         timesInWords: function timesInWords(count) {

   247             return count == 1 && "once" ||

   248                 count == 2 && "twice" ||

   249                 count == 3 && "thrice" ||

   250                 (count || 0) + " times";

   251         },

   252 

   253         calledInOrder: function (spies) {

   254             for (var i = 1, l = spies.length; i < l; i++) {

   255                 if (!spies[i - 1].calledBefore(spies[i])) {

   256                     return false;

   257                 }

   258             }

   259 

   260             return true;

   261         },

   262 

   263         orderByFirstCall: function (spies) {

   264             return spies.sort(function (a, b) {

   265                 // uuid, won't ever be equal

   266                 return a.getCall(0).callId < b.getCall(0).callId ? -1 : 1;

   267             });

   268         }

   269     };

   270 }());

   271 

   272 if (typeof module == "object" && typeof require == "function") {

   273     module.exports = sinon;

   274     module.exports.spy = require("./sinon/spy");

   275     module.exports.stub = require("./sinon/stub");

   276     module.exports.mock = require("./sinon/mock");

   277     module.exports.collection = require("./sinon/collection");

   278     module.exports.assert = require("./sinon/assert");

   279     module.exports.sandbox = require("./sinon/sandbox");

   280     module.exports.test = require("./sinon/test");

   281     module.exports.testCase = require("./sinon/test_case");

   282     module.exports.assert = require("./sinon/assert");

   283 }

   284 

   285 /* @depend ../sinon.js */

   286 /*jslint eqeqeq: false, onevar: false, plusplus: false*/

   287 /*global module, require, sinon*/

   288 /**

   289  * Spy functions

   290  *

   291  * @author Christian Johansen (christian@cjohansen.no)

   292  * @license BSD

   293  *

   294  * Copyright (c) 2010-2011 Christian Johansen

   295  */

   296 

   297 (function (sinon) {

   298     var commonJSModule = typeof module == "object" && typeof require == "function";

   299     var spyCall;

   300     var callId = 0;

   301     var push = [].push;

   302 

   303     if (!sinon && commonJSModule) {

   304         sinon = require("../sinon");

   305     }

   306 

   307     if (!sinon) {

   308         return;

   309     }

   310 

   311     function spy(object, property) {

   312         if (!property && typeof object == "function") {

   313             return spy.create(object);

   314         }

   315 

   316         if (!object || !property) {

   317             return spy.create(function () {});

   318         }

   319 

   320         var method = object[property];

   321         return sinon.wrapMethod(object, property, spy.create(method));

   322     }

   323 

   324     sinon.extend(spy, (function () {

   325         var slice = Array.prototype.slice;

   326 

   327         function delegateToCalls(api, method, matchAny, actual, notCalled) {

   328             api[method] = function () {

   329                 if (!this.called) {

   330                     return !!notCalled;

   331                 }

   332 

   333                 var currentCall;

   334                 var matches = 0;

   335 

   336                 for (var i = 0, l = this.callCount; i < l; i += 1) {

   337                     currentCall = this.getCall(i);

   338 

   339                     if (currentCall[actual || method].apply(currentCall, arguments)) {

   340                         matches += 1;

   341 

   342                         if (matchAny) {

   343                             return true;

   344                         }

   345                     }

   346                 }

   347 

   348                 return matches === this.callCount;

   349             };

   350         }

   351 

   352         function matchingFake(fakes, args, strict) {

   353             if (!fakes) {

   354                 return;

   355             }

   356 

   357             var alen = args.length;

   358 

   359             for (var i = 0, l = fakes.length; i < l; i++) {

   360                 if (fakes[i].matches(args, strict)) {

   361                     return fakes[i];

   362                 }

   363             }

   364         }

   365 

   366         var uuid = 0;

   367 

   368         // Public API

   369         var spyApi = {

   370             reset: function () {

   371                 this.called = false;

   372                 this.calledOnce = false;

   373                 this.calledTwice = false;

   374                 this.calledThrice = false;

   375                 this.callCount = 0;

   376                 this.args = [];

   377                 this.returnValues = [];

   378                 this.thisValues = [];

   379                 this.exceptions = [];

   380                 this.callIds = [];

   381             },

   382 

   383             create: function create(func) {

   384                 var name;

   385 

   386                 if (typeof func != "function") {

   387                     func = function () {};

   388                 } else {

   389                     name = sinon.functionName(func);

   390                 }

   391 

   392                 function proxy() {

   393                     return proxy.invoke(func, this, slice.call(arguments));

   394                 }

   395 

   396                 sinon.extend(proxy, spy);

   397                 delete proxy.create;

   398                 sinon.extend(proxy, func);

   399 

   400                 proxy.reset();

   401                 proxy.prototype = func.prototype;

   402                 proxy.displayName = name || "spy";

   403                 proxy.toString = sinon.functionToString;

   404                 proxy._create = sinon.spy.create;

   405                 proxy.id = "spy#" + uuid++;

   406 

   407                 return proxy;

   408             },

   409 

   410             invoke: function invoke(func, thisValue, args) {

   411                 var matching = matchingFake(this.fakes, args);

   412                 var exception, returnValue;

   413                 this.called = true;

   414                 this.callCount += 1;

   415                 this.calledOnce = this.callCount == 1;

   416                 this.calledTwice = this.callCount == 2;

   417                 this.calledThrice = this.callCount == 3;

   418                 push.call(this.thisValues, thisValue);

   419                 push.call(this.args, args);

   420                 push.call(this.callIds, callId++);

   421 

   422                 try {

   423                     if (matching) {

   424                         returnValue = matching.invoke(func, thisValue, args);

   425                     } else {

   426                         returnValue = (this.func || func).apply(thisValue, args);

   427                     }

   428                 } catch (e) {

   429                     push.call(this.returnValues, undefined);

   430                     exception = e;

   431                     throw e;

   432                 } finally {

   433                     push.call(this.exceptions, exception);

   434                 }

   435 

   436                 push.call(this.returnValues, returnValue);

   437 

   438                 return returnValue;

   439             },

   440 

   441             getCall: function getCall(i) {

   442                 if (i < 0 || i >= this.callCount) {

   443                     return null;

   444                 }

   445 

   446                 return spyCall.create(this, this.thisValues[i], this.args[i],

   447                                       this.returnValues[i], this.exceptions[i],

   448                                       this.callIds[i]);

   449             },

   450 

   451             calledBefore: function calledBefore(spyFn) {

   452                 if (!this.called) {

   453                     return false;

   454                 }

   455 

   456                 if (!spyFn.called) {

   457                     return true;

   458                 }

   459 

   460                 return this.callIds[0] < spyFn.callIds[0];

   461             },

   462 

   463             calledAfter: function calledAfter(spyFn) {

   464                 if (!this.called || !spyFn.called) {

   465                     return false;

   466                 }

   467 

   468                 return this.callIds[this.callCount - 1] > spyFn.callIds[spyFn.callCount - 1];

   469             },

   470 

   471             withArgs: function () {

   472                 var args = slice.call(arguments);

   473 

   474                 if (this.fakes) {

   475                     var match = matchingFake(this.fakes, args, true);

   476 

   477                     if (match) {

   478                         return match;

   479                     }

   480                 } else {

   481                     this.fakes = [];

   482                 }

   483 

   484                 var original = this;

   485                 var fake = this._create();

   486                 fake.matchingAguments = args;

   487                 push.call(this.fakes, fake);

   488 

   489                 fake.withArgs = function () {

   490                     return original.withArgs.apply(original, arguments);

   491                 };

   492 

   493                 return fake;

   494             },

   495 

   496             matches: function (args, strict) {

   497                 var margs = this.matchingAguments;

   498 

   499                 if (margs.length <= args.length &&

   500                     sinon.deepEqual(margs, args.slice(0, margs.length))) {

   501                     return !strict || margs.length == args.length;

   502                 }

   503             },

   504 

   505             printf: function (format) {

   506                 var spy = this;

   507                 var args = [].slice.call(arguments, 1);

   508                 var formatter;

   509 

   510                 return (format || "").replace(/%(.)/g, function (match, specifyer) {

   511                     formatter = spyApi.formatters[specifyer];

   512 

   513                     if (typeof formatter == "function") {

   514                         return formatter.call(null, spy, args);

   515                     } else if (!isNaN(parseInt(specifyer), 10)) {

   516                         return sinon.format(args[specifyer - 1]);

   517                     }

   518 

   519                     return "%" + specifyer;

   520                 });

   521             }

   522         };

   523 

   524         delegateToCalls(spyApi, "calledOn", true);

   525         delegateToCalls(spyApi, "alwaysCalledOn", false, "calledOn");

   526         delegateToCalls(spyApi, "calledWith", true);

   527         delegateToCalls(spyApi, "alwaysCalledWith", false, "calledWith");

   528         delegateToCalls(spyApi, "calledWithExactly", true);

   529         delegateToCalls(spyApi, "alwaysCalledWithExactly", false, "calledWithExactly");

   530         delegateToCalls(spyApi, "neverCalledWith", false, "notCalledWith", true);

   531         delegateToCalls(spyApi, "threw", true);

   532         delegateToCalls(spyApi, "alwaysThrew", false, "threw");

   533         delegateToCalls(spyApi, "returned", true);

   534         delegateToCalls(spyApi, "alwaysReturned", false, "returned");

   535         delegateToCalls(spyApi, "calledWithNew", true);

   536         delegateToCalls(spyApi, "alwaysCalledWithNew", false, "calledWithNew");

   537 

   538         spyApi.formatters = {

   539             "c": function (spy) {

   540                 return sinon.timesInWords(spy.callCount);

   541             },

   542 

   543             "n": function (spy) {

   544                 return spy.toString();

   545             },

   546 

   547             "C": function (spy) {

   548                 var calls = [];

   549 

   550                 for (var i = 0, l = spy.callCount; i < l; ++i) {

   551                     push.call(calls, "    " + spy.getCall(i).toString());

   552                 }

   553 

   554                 return calls.length > 0 ? "\n" + calls.join("\n") : "";

   555             },

   556 

   557             "t": function (spy) {

   558                 var objects = [];

   559 

   560                 for (var i = 0, l = spy.callCount; i < l; ++i) {

   561                     push.call(objects, sinon.format(spy.thisValues[i]));

   562                 }

   563 

   564                 return objects.join(", ");

   565             },

   566 

   567             "*": function (spy, args) {

   568                 return args.join(", ");

   569             }

   570         };

   571 

   572         return spyApi;

   573     }()));

   574 

   575     spyCall = (function () {

   576         return {

   577             create: function create(spy, thisValue, args, returnValue, exception, id) {

   578                 var proxyCall = sinon.create(spyCall);

   579                 delete proxyCall.create;

   580                 proxyCall.proxy = spy;

   581                 proxyCall.thisValue = thisValue;

   582                 proxyCall.args = args;

   583                 proxyCall.returnValue = returnValue;

   584                 proxyCall.exception = exception;

   585                 proxyCall.callId = typeof id == "number" && id || callId++;

   586 

   587                 return proxyCall;

   588             },

   589 

   590             calledOn: function calledOn(thisValue) {

   591                 return this.thisValue === thisValue;

   592             },

   593 

   594             calledWith: function calledWith() {

   595                 for (var i = 0, l = arguments.length; i < l; i += 1) {

   596                     if (!sinon.deepEqual(arguments[i], this.args[i])) {

   597                         return false;

   598                     }

   599                 }

   600 

   601                 return true;

   602             },

   603 

   604             calledWithExactly: function calledWithExactly() {

   605                 return arguments.length == this.args.length &&

   606                     this.calledWith.apply(this, arguments);

   607             },

   608 

   609             notCalledWith: function notCalledWith() {

   610                 for (var i = 0, l = arguments.length; i < l; i += 1) {

   611                     if (!sinon.deepEqual(arguments[i], this.args[i])) {

   612                         return true;

   613                     }

   614                 }

   615                 return false;

   616             },

   617 

   618             returned: function returned(value) {

   619                 return this.returnValue === value;

   620             },

   621 

   622             threw: function threw(error) {

   623                 if (typeof error == "undefined" || !this.exception) {

   624                     return !!this.exception;

   625                 }

   626 

   627                 if (typeof error == "string") {

   628                     return this.exception.name == error;

   629                 }

   630 

   631                 return this.exception === error;

   632             },

   633 

   634             calledWithNew: function calledWithNew(thisValue) {

   635                 return this.thisValue instanceof this.proxy;

   636             },

   637 

   638             calledBefore: function (other) {

   639                 return this.callId < other.callId;

   640             },

   641 

   642             calledAfter: function (other) {

   643                 return this.callId > other.callId;

   644             },

   645 

   646             toString: function () {

   647                 var callStr = this.proxy.toString() + "(";

   648                 var args = [];

   649 

   650                 for (var i = 0, l = this.args.length; i < l; ++i) {

   651                     push.call(args, sinon.format(this.args[i]));

   652                 }

   653 

   654                 callStr = callStr + args.join(", ") + ")";

   655 

   656                 if (typeof this.returnValue != "undefined") {

   657                     callStr += " => " + sinon.format(this.returnValue);

   658                 }

   659 

   660                 if (this.exception) {

   661                     callStr += " !" + this.exception.name;

   662 

   663                     if (this.exception.message) {

   664                         callStr += "(" + this.exception.message + ")";

   665                     }

   666                 }

   667 

   668                 return callStr;

   669             }

   670         };

   671     }());

   672 

   673     spy.spyCall = spyCall;

   674 

   675     // This steps outside the module sandbox and will be removed

   676     sinon.spyCall = spyCall;

   677 

   678     if (commonJSModule) {

   679         module.exports = spy;

   680     } else {

   681         sinon.spy = spy;

   682     }

   683 }(typeof sinon == "object" && sinon || null));

   684 

   685 /**

   686  * @depend ../sinon.js

   687  * @depend spy.js

   688  */

   689 /*jslint eqeqeq: false, onevar: false*/

   690 /*global module, require, sinon*/

   691 /**

   692  * Stub functions

   693  *

   694  * @author Christian Johansen (christian@cjohansen.no)

   695  * @license BSD

   696  *

   697  * Copyright (c) 2010-2011 Christian Johansen

   698  */

   699 

   700 (function (sinon) {

   701     var commonJSModule = typeof module == "object" && typeof require == "function";

   702 

   703     if (!sinon && commonJSModule) {

   704         sinon = require("../sinon");

   705     }

   706 

   707     if (!sinon) {

   708         return;

   709     }

   710 

   711     function stub(object, property, func) {

   712         if (!!func && typeof func != "function") {

   713             throw new TypeError("Custom stub should be function");

   714         }

   715 

   716         var wrapper;

   717 

   718         if (func) {

   719             wrapper = sinon.spy && sinon.spy.create ? sinon.spy.create(func) : func;

   720         } else {

   721             wrapper = stub.create();

   722         }

   723 

   724         if (!object && !property) {

   725             return sinon.stub.create();

   726         }

   727 

   728         if (!property && !!object && typeof object == "object") {

   729             for (var prop in object) {

   730                 if (object.hasOwnProperty(prop) && typeof object[prop] == "function") {

   731                     stub(object, prop);

   732                 }

   733             }

   734 

   735             return object;

   736         }

   737 

   738         return sinon.wrapMethod(object, property, wrapper);

   739     }

   740 

   741     function getCallback(stub, args) {

   742         if (stub.callArgAt < 0) {

   743             for (var i = 0, l = args.length; i < l; ++i) {

   744                 if (!stub.callArgProp && typeof args[i] == "function") {

   745                     return args[i];

   746                 }

   747 

   748                 if (stub.callArgProp && args[i] &&

   749                     typeof args[i][stub.callArgProp] == "function") {

   750                     return args[i][stub.callArgProp];

   751                 }

   752             }

   753 

   754             return null;

   755         }

   756 

   757         return args[stub.callArgAt];

   758     }

   759 

   760     var join = Array.prototype.join;

   761 

   762     function getCallbackError(stub, func, args) {

   763         if (stub.callArgAt < 0) {

   764             var msg;

   765 

   766             if (stub.callArgProp) {

   767                 msg = sinon.functionName(stub) +

   768                     " expected to yield to '" + stub.callArgProp +

   769                     "', but no object with such a property was passed."

   770             } else {

   771                 msg = sinon.functionName(stub) +

   772                             " expected to yield, but no callback was passed."

   773             }

   774 

   775             if (args.length > 0) {

   776                 msg += " Received [" + join.call(args, ", ") + "]";

   777             }

   778 

   779             return msg;

   780         }

   781 

   782         return "argument at index " + stub.callArgAt + " is not a function: " + func;

   783     }

   784 

   785     function callCallback(stub, args) {

   786         if (typeof stub.callArgAt == "number") {

   787             var func = getCallback(stub, args);

   788 

   789             if (typeof func != "function") {

   790                 throw new TypeError(getCallbackError(stub, func, args));

   791             }

   792 

   793             func.apply(null, stub.callbackArguments);

   794         }

   795     }

   796 

   797     var uuid = 0;

   798 

   799     sinon.extend(stub, (function () {

   800         var slice = Array.prototype.slice;

   801 

   802         function throwsException(error, message) {

   803             if (typeof error == "string") {

   804                 this.exception = new Error(message || "");

   805                 this.exception.name = error;

   806             } else if (!error) {

   807                 this.exception = new Error("Error");

   808             } else {

   809                 this.exception = error;

   810             }

   811             

   812             return this;

   813         }

   814 

   815         return {

   816             create: function create() {

   817                 var functionStub = function () {

   818                     if (functionStub.exception) {

   819                         throw functionStub.exception;

   820                     }

   821 

   822                     callCallback(functionStub, arguments);

   823 

   824                     return functionStub.returnValue;

   825                 };

   826 

   827                 functionStub.id = "stub#" + uuid++;

   828                 var orig = functionStub;

   829                 functionStub = sinon.spy.create(functionStub);

   830                 functionStub.func = orig;

   831 

   832                 sinon.extend(functionStub, stub);

   833                 functionStub._create = sinon.stub.create;

   834                 functionStub.displayName = "stub";

   835                 functionStub.toString = sinon.functionToString;

   836 

   837                 return functionStub;

   838             },

   839 

   840             returns: function returns(value) {

   841                 this.returnValue = value;

   842 

   843                 return this;

   844             },

   845 

   846             "throws": throwsException,

   847             throwsException: throwsException,

   848 

   849             callsArg: function callsArg(pos) {

   850                 if (typeof pos != "number") {

   851                     throw new TypeError("argument index is not number");

   852                 }

   853 

   854                 this.callArgAt = pos;

   855                 this.callbackArguments = [];

   856 

   857                 return this;

   858             },

   859 

   860             callsArgWith: function callsArgWith(pos) {

   861                 if (typeof pos != "number") {

   862                     throw new TypeError("argument index is not number");

   863                 }

   864 

   865                 this.callArgAt = pos;

   866                 this.callbackArguments = slice.call(arguments, 1);

   867 

   868                 return this;

   869             },

   870 

   871             yields: function () {

   872                 this.callArgAt = -1;

   873                 this.callbackArguments = slice.call(arguments, 0);

   874 

   875                 return this;

   876             },

   877 

   878             yieldsTo: function (prop) {

   879                 this.callArgAt = -1;

   880                 this.callArgProp = prop;

   881                 this.callbackArguments = slice.call(arguments, 1);

   882 

   883                 return this;

   884             }

   885         };

   886     }()));

   887 

   888     if (commonJSModule) {

   889         module.exports = stub;

   890     } else {

   891         sinon.stub = stub;

   892     }

   893 }(typeof sinon == "object" && sinon || null));

   894 

   895 /**

   896  * @depend ../sinon.js

   897  * @depend stub.js

   898  */

   899 /*jslint eqeqeq: false, onevar: false, nomen: false*/

   900 /*global module, require, sinon*/

   901 /**

   902  * Mock functions.

   903  *

   904  * @author Christian Johansen (christian@cjohansen.no)

   905  * @license BSD

   906  *

   907  * Copyright (c) 2010-2011 Christian Johansen

   908  */

   909 

   910 (function (sinon) {

   911     var commonJSModule = typeof module == "object" && typeof require == "function";

   912     var push = [].push;

   913 

   914     if (!sinon && commonJSModule) {

   915         sinon = require("../sinon");

   916     }

   917 

   918     if (!sinon) {

   919         return;

   920     }

   921 

   922     function mock(object) {

   923         if (!object) {

   924             return sinon.expectation.create("Anonymous mock");

   925         }

   926 

   927         return mock.create(object);

   928     }

   929 

   930     sinon.mock = mock;

   931 

   932     sinon.extend(mock, (function () {

   933         function each(collection, callback) {

   934             if (!collection) {

   935                 return;

   936             }

   937 

   938             for (var i = 0, l = collection.length; i < l; i += 1) {

   939                 callback(collection[i]);

   940             }

   941         }

   942 

   943         return {

   944             create: function create(object) {

   945                 if (!object) {

   946                     throw new TypeError("object is null");

   947                 }

   948 

   949                 var mockObject = sinon.extend({}, mock);

   950                 mockObject.object = object;

   951                 delete mockObject.create;

   952 

   953                 return mockObject;

   954             },

   955 

   956             expects: function expects(method) {

   957                 if (!method) {

   958                     throw new TypeError("method is falsy");

   959                 }

   960 

   961                 if (!this.expectations) {

   962                     this.expectations = {};

   963                     this.proxies = [];

   964                 }

   965 

   966                 if (!this.expectations[method]) {

   967                     this.expectations[method] = [];

   968                     var mockObject = this;

   969 

   970                     sinon.wrapMethod(this.object, method, function () {

   971                         return mockObject.invokeMethod(method, this, arguments);

   972                     });

   973 

   974                     push.call(this.proxies, method);

   975                 }

   976 

   977                 var expectation = sinon.expectation.create(method);

   978                 push.call(this.expectations[method], expectation);

   979 

   980                 return expectation;

   981             },

   982 

   983             restore: function restore() {

   984                 var object = this.object;

   985 

   986                 each(this.proxies, function (proxy) {

   987                     if (typeof object[proxy].restore == "function") {

   988                         object[proxy].restore();

   989                     }

   990                 });

   991             },

   992 

   993             verify: function verify() {

   994                 var expectations = this.expectations || {};

   995                 var messages = [], met = [];

   996 

   997                 each(this.proxies, function (proxy) {

   998                     each(expectations[proxy], function (expectation) {

   999                         if (!expectation.met()) {

  1000                             push.call(messages, expectation.toString());

  1001                         } else {

  1002                             push.call(met, expectation.toString());

  1003                         }

  1004                     });

  1005                 });

  1006 

  1007                 this.restore();

  1008 

  1009                 if (messages.length > 0) {

  1010                     sinon.expectation.fail(messages.concat(met).join("\n"));

  1011                 }

  1012 

  1013                 return true;

  1014             },

  1015 

  1016             invokeMethod: function invokeMethod(method, thisValue, args) {

  1017                 var expectations = this.expectations && this.expectations[method];

  1018                 var length = expectations && expectations.length || 0;

  1019 

  1020                 for (var i = 0; i < length; i += 1) {

  1021                     if (!expectations[i].met() &&

  1022                         expectations[i].allowsCall(thisValue, args)) {

  1023                         return expectations[i].apply(thisValue, args);

  1024                     }

  1025                 }

  1026 

  1027                 var messages = [];

  1028 

  1029                 for (i = 0; i < length; i += 1) {

  1030                     push.call(messages, "    " + expectations[i].toString());

  1031                 }

  1032 

  1033                 messages.unshift("Unexpected call: " + sinon.spyCall.toString.call({

  1034                     proxy: method,

  1035                     args: args

  1036                 }));

  1037 

  1038                 sinon.expectation.fail(messages.join("\n"));

  1039             }

  1040         };

  1041     }()));

  1042 

  1043     var times = sinon.timesInWords;

  1044 

  1045     sinon.expectation = (function () {

  1046         var slice = Array.prototype.slice;

  1047         var _invoke = sinon.spy.invoke;

  1048 

  1049         function callCountInWords(callCount) {

  1050             if (callCount == 0) {

  1051                 return "never called";

  1052             } else {

  1053                 return "called " + times(callCount);

  1054             }

  1055         }

  1056 

  1057         function expectedCallCountInWords(expectation) {

  1058             var min = expectation.minCalls;

  1059             var max = expectation.maxCalls;

  1060 

  1061             if (typeof min == "number" && typeof max == "number") {

  1062                 var str = times(min);

  1063 

  1064                 if (min != max) {

  1065                     str = "at least " + str + " and at most " + times(max);

  1066                 }

  1067 

  1068                 return str;

  1069             }

  1070 

  1071             if (typeof min == "number") {

  1072                 return "at least " + times(min);

  1073             }

  1074 

  1075             return "at most " + times(max);

  1076         }

  1077 

  1078         function receivedMinCalls(expectation) {

  1079             var hasMinLimit = typeof expectation.minCalls == "number";

  1080             return !hasMinLimit || expectation.callCount >= expectation.minCalls;

  1081         }

  1082 

  1083         function receivedMaxCalls(expectation) {

  1084             if (typeof expectation.maxCalls != "number") {

  1085                 return false;

  1086             }

  1087 

  1088             return expectation.callCount == expectation.maxCalls;

  1089         }

  1090 

  1091         return {

  1092             minCalls: 1,

  1093             maxCalls: 1,

  1094 

  1095             create: function create(methodName) {

  1096                 var expectation = sinon.extend(sinon.stub.create(), sinon.expectation);

  1097                 delete expectation.create;

  1098                 expectation.method = methodName;

  1099 

  1100                 return expectation;

  1101             },

  1102 

  1103             invoke: function invoke(func, thisValue, args) {

  1104                 this.verifyCallAllowed(thisValue, args);

  1105 

  1106                 return _invoke.apply(this, arguments);

  1107             },

  1108 

  1109             atLeast: function atLeast(num) {

  1110                 if (typeof num != "number") {

  1111                     throw new TypeError("'" + num + "' is not number");

  1112                 }

  1113 

  1114                 if (!this.limitsSet) {

  1115                     this.maxCalls = null;

  1116                     this.limitsSet = true;

  1117                 }

  1118 

  1119                 this.minCalls = num;

  1120 

  1121                 return this;

  1122             },

  1123 

  1124             atMost: function atMost(num) {

  1125                 if (typeof num != "number") {

  1126                     throw new TypeError("'" + num + "' is not number");

  1127                 }

  1128 

  1129                 if (!this.limitsSet) {

  1130                     this.minCalls = null;

  1131                     this.limitsSet = true;

  1132                 }

  1133 

  1134                 this.maxCalls = num;