/**

 * Sinon.JS 1.2.0, 2011/09/27

 *

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

 *

 * (The BSD License)

 * 

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

 * All rights reserved.

 * 

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

 * are permitted provided that the following conditions are met:

 * 

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

 *       this list of conditions and the following disclaimer.

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

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

 *       and/or other materials provided with the distribution.

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

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

 *       without specific prior written permission.

 * 

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

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

 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

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

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

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

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

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

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

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

 */

"use strict";

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

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

/**

 * Sinon core utilities. For internal use only.

 *

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

 * @license BSD

 *

 * Copyright (c) 2010-2011 Christian Johansen

 */

var sinon = (function () {

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

    function isNode(obj) {

        var success = false;

        try {

            obj.appendChild(div);

            success = div.parentNode == obj;

        } catch (e) {

            return false;

        } finally {

            try {

                obj.removeChild(div);

            } catch (e) {}

        }

        return success;

    }

    function isElement(obj) {

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

    }

    return {

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

            if (!object) {

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

            }

            if (typeof method != "function") {

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

            }

            var wrappedMethod = object[property];

            var type = typeof wrappedMethod;

            if (type != "function") {

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

                                    " as function");

            }

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

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

            }

            if (wrappedMethod.calledBefore) {

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

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

            }

            var owned = object.hasOwnProperty(property);

            object[property] = method;

            method.displayName = property;

            method.restore = function () {

                if(owned) {

                    object[property] = wrappedMethod;

                } else {

                    delete object[property];

                }

            };

            method.restore.sinon = true;

            return method;

        },

        extend: function extend(target) {

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

                for (var prop in arguments[i]) {

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

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

                    }

                    // DONT ENUM bug, only care about toString

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

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

                        target.toString = arguments[i].toString;

                    }

                }

            }

            return target;

        },

        create: function create(proto) {

            var F = function () {};

            F.prototype = proto;

            return new F();

        },

        deepEqual: function deepEqual(a, b) {

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

                return a === b;

            }

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

                return a === b;

            }

            if (a === b) {

                return true;

            }

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

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

                    return false;

                }

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

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

                        return false;

                    }

                }

                return true;

            }

            var prop, aLength = 0, bLength = 0;

            for (prop in a) {

                aLength += 1;

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

                    return false;

                }

            }

            for (prop in b) {

                bLength += 1;

            }

            if (aLength != bLength) {

                return false;

            }

            return true;

        },

        functionName: function functionName(func) {

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

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

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

            // doesn't debugging will be slightly less informative

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

            if (!name) {

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

                name = matches && matches[1];

            }

            return name;

        },

        functionToString: function toString() {

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

                var thisValue, prop, i = this.callCount;

                while (i--) {

                    thisValue = this.getCall(i).thisValue;

                    for (prop in thisValue) {

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

                            return prop;

                        }

                    }

                }

            }

            return this.displayName || "sinon fake";

        },

        getConfig: function (custom) {

            var config = {};

            custom = custom || {};

            var defaults = sinon.defaultConfig;

            for (var prop in defaults) {

                if (defaults.hasOwnProperty(prop)) {

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

                }

            }

            return config;

        },

        format: function (val) {

            return "" + val;

        },

        defaultConfig: {

            injectIntoThis: true,

            injectInto: null,

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

            useFakeTimers: true,

            useFakeServer: true

        },

        timesInWords: function timesInWords(count) {

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

                count == 2 && "twice" ||

                count == 3 && "thrice" ||

                (count || 0) + " times";

        },

        calledInOrder: function (spies) {

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

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

                    return false;

                }

            }

            return true;

        },

        orderByFirstCall: function (spies) {

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

                // uuid, won't ever be equal

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

            });

        }

    };

}());

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

    module.exports = sinon;

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

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

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

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

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

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

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

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

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

}

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

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

/*global module, require, sinon*/

/**

 * Spy functions

 *

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

 * @license BSD

 *

 * Copyright (c) 2010-2011 Christian Johansen

 */

(function (sinon) {

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

    var spyCall;

    var callId = 0;

    var push = [].push;

    if (!sinon && commonJSModule) {

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

    }

    if (!sinon) {

        return;

    }

    function spy(object, property) {

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

            return spy.create(object);

        }

        if (!object || !property) {

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

        }

        var method = object[property];

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

    }

    sinon.extend(spy, (function () {

        var slice = Array.prototype.slice;

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

            api[method] = function () {

                if (!this.called) {

                    return !!notCalled;

                }

                var currentCall;

                var matches = 0;

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

                    currentCall = this.getCall(i);

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

                        matches += 1;

                        if (matchAny) {

                            return true;

                        }

                    }

                }

                return matches === this.callCount;

            };

        }

        function matchingFake(fakes, args, strict) {

            if (!fakes) {

                return;

            }

            var alen = args.length;

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

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

                    return fakes[i];

                }

            }

        }

        var uuid = 0;

        // Public API

        var spyApi = {

            reset: function () {

                this.called = false;

                this.calledOnce = false;