Effects: Add tests for jQuery.Tween

1 files changed, 5931 insertions, 0 deletions

diff --git a/external/sinon/sinon-1.14.1.js b/external/sinon/sinon-1.14.1.js
new file mode 100644
index 000000000..dfbeae46a
--- /dev/null
+++ b/external/sinon/sinon-1.14.1.js
@@ -0,0 +1,5931 @@
+/**
+ * Sinon.JS 1.14.1, 2015/03/16
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @author Contributors: https://github.com/cjohansen/Sinon.JS/blob/master/AUTHORS
+ *
+ * (The BSD License)
+ *
+ * Copyright (c) 2010-2014, 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.
+ */
+
+(function (root, factory) {
+	if (typeof define === 'function' && define.amd) {
+		define('sinon', [], function () {
+			return (root.sinon = factory());
+		});
+	} else if (typeof exports === 'object') {
+		module.exports = factory();
+	} else {
+		root.sinon = factory();
+	}
+}(this, function () {
+	var samsam, formatio;
+	(function () {
+								function define(mod, deps, fn) {
+									if (mod == "samsam") {
+										samsam = deps();
+									} else if (typeof deps === "function" && mod.length === 0) {
+										lolex = deps();
+									} else if (typeof fn === "function") {
+										formatio = fn(samsam);
+									}
+								}
+		define.amd = {};
+((typeof define === "function" && define.amd && function (m) { define("samsam", m); }) ||
+ (typeof module === "object" &&
+			function (m) { module.exports = m(); }) || // Node
+ function (m) { this.samsam = m(); } // Browser globals
+)(function () {
+		var o = Object.prototype;
+		var div = typeof document !== "undefined" && document.createElement("div");
+
+		function isNaN(value) {
+				// Unlike global isNaN, this avoids type coercion
+				// typeof check avoids IE host object issues, hat tip to
+				// lodash
+				var val = value; // JsLint thinks value !== value is "weird"
+				return typeof value === "number" && value !== val;
+		}
+
+		function getClass(value) {
+				// Returns the internal [[Class]] by calling Object.prototype.toString
+				// with the provided value as this. Return value is a string, naming the
+				// internal class, e.g. "Array"
+				return o.toString.call(value).split(/[ \]]/)[1];
+		}
+
+		/**
+		 * @name samsam.isArguments
+		 * @param Object object
+		 *
+		 * Returns ``true`` if ``object`` is an ``arguments`` object,
+		 * ``false`` otherwise.
+		 */
+		function isArguments(object) {
+				if (getClass(object) === 'Arguments') { return true; }
+				if (typeof object !== "object" || typeof object.length !== "number" ||
+								getClass(object) === "Array") {
+						return false;
+				}
+				if (typeof object.callee == "function") { return true; }
+				try {
+						object[object.length] = 6;
+						delete object[object.length];
+				} catch (e) {
+						return true;
+				}
+				return false;
+		}
+
+		/**
+		 * @name samsam.isElement
+		 * @param Object object
+		 *
+		 * Returns ``true`` if ``object`` is a DOM element node. Unlike
+		 * Underscore.js/lodash, this function will return ``false`` if ``object``
+		 * is an *element-like* object, i.e. a regular object with a ``nodeType``
+		 * property that holds the value ``1``.
+		 */
+		function isElement(object) {
+				if (!object || object.nodeType !== 1 || !div) { return false; }
+				try {
+						object.appendChild(div);
+						object.removeChild(div);
+				} catch (e) {
+						return false;
+				}
+				return true;
+		}
+
+		/**
+		 * @name samsam.keys
+		 * @param Object object
+		 *
+		 * Return an array of own property names.
+		 */
+		function keys(object) {
+				var ks = [], prop;
+				for (prop in object) {
+						if (o.hasOwnProperty.call(object, prop)) { ks.push(prop); }
+				}
+				return ks;
+		}
+
+		/**
+		 * @name samsam.isDate
+		 * @param Object value
+		 *
+		 * Returns true if the object is a ``Date``, or *date-like*. Duck typing
+		 * of date objects work by checking that the object has a ``getTime``
+		 * function whose return value equals the return value from the object's
+		 * ``valueOf``.
+		 */
+		function isDate(value) {
+				return typeof value.getTime == "function" &&
+						value.getTime() == value.valueOf();
+		}
+
+		/**
+		 * @name samsam.isNegZero
+		 * @param Object value
+		 *
+		 * Returns ``true`` if ``value`` is ``-0``.
+		 */
+		function isNegZero(value) {
+				return value === 0 && 1 / value === -Infinity;
+		}
+
+		/**
+		 * @name samsam.equal
+		 * @param Object obj1
+		 * @param Object obj2
+		 *
+		 * Returns ``true`` if two objects are strictly equal. Compared to
+		 * ``===`` there are two exceptions:
+		 *
+		 *   - NaN is considered equal to NaN
+		 *   - -0 and +0 are not considered equal
+		 */
+		function identical(obj1, obj2) {
+				if (obj1 === obj2 || (isNaN(obj1) && isNaN(obj2))) {
+						return obj1 !== 0 || isNegZero(obj1) === isNegZero(obj2);
+				}
+		}
+
+
+		/**
+		 * @name samsam.deepEqual
+		 * @param Object obj1
+		 * @param Object obj2
+		 *
+		 * Deep equal comparison. Two values are "deep equal" if:
+		 *
+		 *   - They are equal, according to samsam.identical
+		 *   - They are both date objects representing the same time
+		 *   - They are both arrays containing elements that are all deepEqual
+		 *   - They are objects with the same set of properties, and each property
+		 *     in ``obj1`` is deepEqual to the corresponding property in ``obj2``
+		 *
+		 * Supports cyclic objects.
+		 */
+		function deepEqualCyclic(obj1, obj2) {
+
+				// used for cyclic comparison
+				// contain already visited objects
+				var objects1 = [],
+						objects2 = [],
+				// contain pathes (position in the object structure)
+				// of the already visited objects
+				// indexes same as in objects arrays
+						paths1 = [],
+						paths2 = [],
+				// contains combinations of already compared objects
+				// in the manner: { "$1['ref']$2['ref']": true }
+						compared = {};
+
+				/**
+				 * used to check, if the value of a property is an object
+				 * (cyclic logic is only needed for objects)
+				 * only needed for cyclic logic
+				 */
+				function isObject(value) {
+
+						if (typeof value === 'object' && value !== null &&
+										!(value instanceof Boolean) &&
+										!(value instanceof Date)    &&
+										!(value instanceof Number)  &&
+										!(value instanceof RegExp)  &&
+										!(value instanceof String)) {
+
+								return true;
+						}
+
+						return false;
+				}
+
+				/**
+				 * returns the index of the given object in the
+				 * given objects array, -1 if not contained
+				 * only needed for cyclic logic
+				 */
+				function getIndex(objects, obj) {
+
+						var i;
+						for (i = 0; i < objects.length; i++) {
+								if (objects[i] === obj) {
+										return i;
+								}
+						}
+
+						return -1;
+				}
+
+				// does the recursion for the deep equal check
+				return (function deepEqual(obj1, obj2, path1, path2) {
+						var type1 = typeof obj1;
+						var type2 = typeof obj2;
+
+						// == null also matches undefined
+						if (obj1 === obj2 ||
+										isNaN(obj1) || isNaN(obj2) ||
+										obj1 == null || obj2 == null ||
+										type1 !== "object" || type2 !== "object") {
+
+								return identical(obj1, obj2);
+						}
+
+						// Elements are only equal if identical(expected, actual)
+						if (isElement(obj1) || isElement(obj2)) { return false; }
+
+						var isDate1 = isDate(obj1), isDate2 = isDate(obj2);
+						if (isDate1 || isDate2) {
+								if (!isDate1 || !isDate2 || obj1.getTime() !== obj2.getTime()) {
+										return false;
+								}
+						}
+
+						if (obj1 instanceof RegExp && obj2 instanceof RegExp) {
+								if (obj1.toString() !== obj2.toString()) { return false; }
+						}
+
+						var class1 = getClass(obj1);
+						var class2 = getClass(obj2);
+						var keys1 = keys(obj1);
+						var keys2 = keys(obj2);
+
+						if (isArguments(obj1) || isArguments(obj2)) {
+								if (obj1.length !== obj2.length) { return false; }
+						} else {
+								if (type1 !== type2 || class1 !== class2 ||
+												keys1.length !== keys2.length) {
+										return false;
+								}
+						}
+
+						var key, i, l,
+								// following vars are used for the cyclic logic
+								value1, value2,
+								isObject1, isObject2,
+								index1, index2,
+								newPath1, newPath2;
+
+						for (i = 0, l = keys1.length; i < l; i++) {
+								key = keys1[i];
+								if (!o.hasOwnProperty.call(obj2, key)) {
+										return false;
+								}
+
+								// Start of the cyclic logic
+
+								value1 = obj1[key];
+								value2 = obj2[key];
+
+								isObject1 = isObject(value1);
+								isObject2 = isObject(value2);
+
+								// determine, if the objects were already visited
+								// (it's faster to check for isObject first, than to
+								// get -1 from getIndex for non objects)
+								index1 = isObject1 ? getIndex(objects1, value1) : -1;
+								index2 = isObject2 ? getIndex(objects2, value2) : -1;
+
+								// determine the new pathes of the objects
+								// - for non cyclic objects the current path will be extended
+								//   by current property name
+								// - for cyclic objects the stored path is taken
+								newPath1 = index1 !== -1
+										? paths1[index1]
+										: path1 + '[' + JSON.stringify(key) + ']';
+								newPath2 = index2 !== -1
+										? paths2[index2]
+										: path2 + '[' + JSON.stringify(key) + ']';
+
+								// stop recursion if current objects are already compared
+								if (compared[newPath1 + newPath2]) {
+										return true;
+								}
+
+								// remember the current objects and their pathes
+								if (index1 === -1 && isObject1) {
+										objects1.push(value1);
+										paths1.push(newPath1);
+								}
+								if (index2 === -1 && isObject2) {
+										objects2.push(value2);
+										paths2.push(newPath2);
+								}
+
+								// remember that the current objects are already compared
+								if (isObject1 && isObject2) {
+										compared[newPath1 + newPath2] = true;
+								}
+
+								// End of cyclic logic
+
+								// neither value1 nor value2 is a cycle
+								// continue with next level
+								if (!deepEqual(value1, value2, newPath1, newPath2)) {
+										return false;
+								}
+						}
+
+						return true;
+
+				}(obj1, obj2, '$1', '$2'));
+		}
+
+		var match;
+
+		function arrayContains(array, subset) {
+				if (subset.length === 0) { return true; }
+				var i, l, j, k;
+				for (i = 0, l = array.length; i < l; ++i) {
+						if (match(array[i], subset[0])) {
+								for (j = 0, k = subset.length; j < k; ++j) {
+										if (!match(array[i + j], subset[j])) { return false; }
+								}
+								return true;
+						}
+				}
+				return false;
+		}
+
+		/**
+		 * @name samsam.match
+		 * @param Object object
+		 * @param Object matcher
+		 *
+		 * Compare arbitrary value ``object`` with matcher.
+		 */
+		match = function match(object, matcher) {
+				if (matcher && typeof matcher.test === "function") {
+						return matcher.test(object);
+				}
+
+				if (typeof matcher === "function") {
+						return matcher(object) === true;
+				}
+
+				if (typeof matcher === "string") {
+						matcher = matcher.toLowerCase();
+						var notNull = typeof object === "string" || !!object;
+						return notNull &&
+								(String(object)).toLowerCase().indexOf(matcher) >= 0;
+				}
+
+				if (typeof matcher === "number") {
+						return matcher === object;
+				}
+
+				if (typeof matcher === "boolean") {
+						return matcher === object;
+				}
+
+				if (typeof(matcher) === "undefined") {
+						return typeof(object) === "undefined";
+				}
+
+				if (matcher === null) {
+						return object === null;
+				}
+
+				if (getClass(object) === "Array" && getClass(matcher) === "Array") {
+						return arrayContains(object, matcher);
+				}
+
+				if (matcher && typeof matcher === "object") {
+						if (matcher === object) {
+								return true;
+						}
+						var prop;
+						for (prop in matcher) {
+								var value = object[prop];
+								if (typeof value === "undefined" &&
+												typeof object.getAttribute === "function") {
+										value = object.getAttribute(prop);
+								}
+								if (matcher[prop] === null || typeof matcher[prop] === 'undefined') {
+										if (value !== matcher[prop]) {
+												return false;
+										}
+								} else if (typeof  value === "undefined" || !match(value, matcher[prop])) {
+										return false;
+								}
+						}
+						return true;
+				}
+
+				throw new Error("Matcher was not a string, a number, a " +
+												"function, a boolean or an object");
+		};
+
+		return {
+				isArguments: isArguments,
+				isElement: isElement,
+				isDate: isDate,
+				isNegZero: isNegZero,
+				identical: identical,
+				deepEqual: deepEqualCyclic,
+				match: match,
+				keys: keys
+		};
+});
+((typeof define === "function" && define.amd && function (m) {
+		define("formatio", ["samsam"], m);
+}) || (typeof module === "object" && function (m) {
+		module.exports = m(require("samsam"));
+}) || function (m) { this.formatio = m(this.samsam); }
+)(function (samsam) {
+
+		var formatio = {
+				excludeConstructors: ["Object", /^.$/],
+				quoteStrings: true,
+				limitChildrenCount: 0
+		};
+
+		var hasOwn = Object.prototype.hasOwnProperty;
+
+		var specialObjects = [];
+		if (typeof global !== "undefined") {
+				specialObjects.push({ object: global, value: "[object global]" });
+		}
+		if (typeof document !== "undefined") {
+				specialObjects.push({
+						object: document,
+						value: "[object HTMLDocument]"
+				});
+		}
+		if (typeof window !== "undefined") {
+				specialObjects.push({ object: window, value: "[object Window]" });
+		}
+
+		function functionName(func) {
+				if (!func) { return ""; }
+				if (func.displayName) { return func.displayName; }
+				if (func.name) { return func.name; }
+				var matches = func.toString().match(/function\s+([^\(]+)/m);
+				return (matches && matches[1]) || "";
+		}
+
+		function constructorName(f, object) {
+				var name = functionName(object && object.constructor);
+				var excludes = f.excludeConstructors ||
+								formatio.excludeConstructors || [];
+
+				var i, l;
+				for (i = 0, l = excludes.length; i < l; ++i) {
+						if (typeof excludes[i] === "string" && excludes[i] === name) {
+								return "";
+						} else if (excludes[i].test && excludes[i].test(name)) {
+								return "";
+						}
+				}
+
+				return name;
+		}
+
+		function isCircular(object, objects) {
+				if (typeof object !== "object") { return false; }
+				var i, l;
+				for (i = 0, l = objects.length; i < l; ++i) {
+						if (objects[i] === object) { return true; }
+				}
+				return false;
+		}
+
+		function ascii(f, object, processed, indent) {
+				if (typeof object === "string") {
+						var qs = f.quoteStrings;
+						var quote = typeof qs !== "boolean" || qs;
+						return processed || quote ? '"' + object + '"' : object;
+				}
+
+				if (typeof object === "function" && !(object instanceof RegExp)) {
+						return ascii.func(object);
+				}
+
+				processed = processed || [];
+
+				if (isCircular(object, processed)) { return "[Circular]"; }
+
+				if (Object.prototype.toString.call(object) === "[object Array]") {
+						return ascii.array.call(f, object, processed);
+				}
+
+				if (!object) { return String((1/object) === -Infinity ? "-0" : object); }
+				if (samsam.isElement(object)) { return ascii.element(object); }
+
+				if (typeof object.toString === "function" &&
+								object.toString !== Object.prototype.toString) {
+						return object.toString();
+				}
+
+				var i, l;
+				for (i = 0, l = specialObjects.length; i < l; i++) {
+						if (object === specialObjects[i].object) {
+								return specialObjects[i].value;
+						}
+				}
+
+				return ascii.object.call(f, object, processed, indent);
+		}
+
+		ascii.func = function (func) {
+				return "function " + functionName(func) + "() {}";
+		};
+
+		ascii.array = function (array, processed) {
+				processed = processed || [];
+				processed.push(array);
+				var pieces = [];
+				var i, l;
+				l = (this.limitChildrenCount > 0) ?
+						Math.min(this.limitChildrenCount, array.length) : array.length;
+
+				for (i = 0; i < l; ++i) {
+						pieces.push(ascii(this, array[i], processed));
+				}
+
+				if(l < array.length)
+						pieces.push("[... " + (array.length - l) + " more elements]");
+
+				return "[" + pieces.join(", ") + "]";
+		};
+
+		ascii.object = function (object, processed, indent) {
+				processed = processed || [];
+				processed.push(object);
+				indent = indent || 0;
+				var pieces = [], properties = samsam.keys(object).sort();
+				var length = 3;
+				var prop, str, obj, i, k, l;
+				l = (this.limitChildrenCount > 0) ?
+						Math.min(this.limitChildrenCount, properties.length) : properties.length;
+
+				for (i = 0; i < l; ++i) {
+						prop = properties[i];
+						obj = object[prop];
+
+						if (isCircular(obj, processed)) {
+								str = "[Circular]";
+						} else {
+								str = ascii(this, obj, processed, indent + 2);
+						}
+
+						str = (/\s/.test(prop) ? '"' + prop + '"' : prop) + ": " + str;
+						length += str.length;
+						pieces.push(str);
+				}
+
+				var cons = constructorName(this, object);
+				var prefix = cons ? "[" + cons + "] " : "";
+				var is = "";
+				for (i = 0, k = indent; i < k; ++i) { is += " "; }
+
+				if(l < properties.length)
+						pieces.push("[... " + (properties.length - l) + " more elements]");
+
+				if (length + indent > 80) {
+						return prefix + "{\n  " + is + pieces.join(",\n  " + is) + "\n" +
+								is + "}";
+				}
+				return prefix + "{ " + pieces.join(", ") + " }";
+		};
+
+		ascii.element = function (element) {
+				var tagName = element.tagName.toLowerCase();
+				var attrs = element.attributes, attr, pairs = [], attrName, i, l, val;
+
+				for (i = 0, l = attrs.length; i < l; ++i) {
+						attr = attrs.item(i);
+						attrName = attr.nodeName.toLowerCase().replace("html:", "");
+						val = attr.nodeValue;
+						if (attrName !== "contenteditable" || val !== "inherit") {
+								if (!!val) { pairs.push(attrName + "=\"" + val + "\""); }
+						}
+				}
+
+				var formatted = "<" + tagName + (pairs.length > 0 ? " " : "");
+				var content = element.innerHTML;
+
+				if (content.length > 20) {
+						content = content.substr(0, 20) + "[...]";
+				}
+
+				var res = formatted + pairs.join(" ") + ">" + content +
+								"</" + tagName + ">";
+
+				return res.replace(/ contentEditable="inherit"/, "");
+		};
+
+		function Formatio(options) {
+				for (var opt in options) {
+						this[opt] = options[opt];
+				}
+		}
+
+		Formatio.prototype = {
+				functionName: functionName,
+
+				configure: function (options) {
+						return new Formatio(options);
+				},
+
+				constructorName: function (object) {
+						return constructorName(this, object);
+				},
+
+				ascii: function (object, processed, indent) {
+						return ascii(this, object, processed, indent);
+				}
+		};
+
+		return Formatio.prototype;
+});
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var f;"undefined"!=typeof window?f=window:"undefined"!=typeof global?f=global:"undefined"!=typeof self&&(f=self),f.lolex=e()}}(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+(function (global){
+/*jslint eqeqeq: false, plusplus: false, evil: true, onevar: false, browser: true, forin: false*/
+/*global global*/
+/**
+ * @author Christian Johansen (christian@cjohansen.no) and contributors
+ * @license BSD
+ *
+ * Copyright (c) 2010-2014 Christian Johansen
+ */
+
+// node expects setTimeout/setInterval to return a fn object w/ .ref()/.unref()
+// browsers, a number.
+// see https://github.com/cjohansen/Sinon.JS/pull/436
+var timeoutResult = setTimeout(function() {}, 0);
+var addTimerReturnsObject = typeof timeoutResult === "object";
+clearTimeout(timeoutResult);
+
+var NativeDate = Date;
+var id = 1;
+
+/**
+ * Parse strings like "01:10:00" (meaning 1 hour, 10 minutes, 0 seconds) into
+ * number of milliseconds. This is used to support human-readable strings passed
+ * to clock.tick()
+ */
+function parseTime(str) {
+		if (!str) {
+				return 0;
+		}
+
+		var strings = str.split(":");
+		var l = strings.length, i = l;
+		var ms = 0, parsed;
+
+		if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
+				throw new Error("tick only understands numbers and 'h:m:s'");
+		}
+
+		while (i--) {
+				parsed = parseInt(strings[i], 10);
+
+				if (parsed >= 60) {
+						throw new Error("Invalid time " + str);
+				}
+
+				ms += parsed * Math.pow(60, (l - i - 1));
+		}
+
+		return ms * 1000;
+}
+
+/**
+ * Used to grok the `now` parameter to createClock.
+ */
+function getEpoch(epoch) {
+		if (!epoch) { return 0; }
+		if (typeof epoch.getTime === "function") { return epoch.getTime(); }
+		if (typeof epoch === "number") { return epoch; }
+		throw new TypeError("now should be milliseconds since UNIX epoch");
+}
+
+function inRange(from, to, timer) {
+		return timer && timer.callAt >= from && timer.callAt <= to;
+}
+
+function mirrorDateProperties(target, source) {
+		if (source.now) {
+				target.now = function now() {
+						return target.clock.now;
+				};
+		} else {
+				delete target.now;
+		}
+
+		if (source.toSource) {
+				target.toSource = function toSource() {
+						return source.toSource();
+				};
+		} else {
+				delete target.toSource;
+		}
+
+		target.toString = function toString() {
+				return source.toString();
+		};
+
+		target.prototype = source.prototype;
+		target.parse = source.parse;
+		target.UTC = source.UTC;
+		target.prototype.toUTCString = source.prototype.toUTCString;
+
+		for (var prop in source) {
+				if (source.hasOwnProperty(prop)) {
+						target[prop] = source[prop];
+				}
+		}
+
+		return target;
+}
+
+function createDate() {
+		function ClockDate(year, month, date, hour, minute, second, ms) {
+				// Defensive and verbose to avoid potential harm in passing
+				// explicit undefined when user does not pass argument
+				switch (arguments.length) {
+				case 0:
+						return new NativeDate(ClockDate.clock.now);
+				case 1:
+						return new NativeDate(year);
+				case 2:
+						return new NativeDate(year, month);
+				case 3:
+						return new NativeDate(year, month, date);
+				case 4:
+						return new NativeDate(year, month, date, hour);
+				case 5:
+						return new NativeDate(year, month, date, hour, minute);
+				case 6:
+						return new NativeDate(year, month, date, hour, minute, second);
+				default:
+						return new NativeDate(year, month, date, hour, minute, second, ms);
+				}
+		}
+
+		return mirrorDateProperties(ClockDate, NativeDate);
+}
+
+function addTimer(clock, timer) {
+		if (typeof timer.func === "undefined") {
+				throw new Error("Callback must be provided to timer calls");
+		}
+
+		if (!clock.timers) {
+				clock.timers = {};
+		}
+
+		timer.id = id++;
+		timer.createdAt = clock.now;
+		timer.callAt = clock.now + (timer.delay || 0);
+
+		clock.timers[timer.id] = timer;
+
+		if (addTimerReturnsObject) {
+				return {
+						id: timer.id,
+						ref: function() {},
+						unref: function() {}
+				};
+		}
+		else {
+				return timer.id;
+		}
+}
+
+function firstTimerInRange(clock, from, to) {
+		var timers = clock.timers, timer = null;
+
+		for (var id in timers) {
+				if (!inRange(from, to, timers[id])) {
+						continue;
+				}
+
+				if (!timer || ~compareTimers(timer, timers[id])) {
+						timer = timers[id];
+				}
+		}
+
+		return timer;
+}
+
+function compareTimers(a, b) {
+		// Sort first by absolute timing
+		if (a.callAt < b.callAt) {
+				return -1;
+		}
+		if (a.callAt > b.callAt) {
+				return 1;
+		}
+
+		// Sort next by immediate, immediate timers take precedence
+		if (a.immediate && !b.immediate) {
+				return -1;
+		}
+		if (!a.immediate && b.immediate) {
+				return 1;
+		}
+
+		// Sort next by creation time, earlier-created timers take precedence
+		if (a.createdAt < b.createdAt) {
+				return -1;
+		}
+		if (a.createdAt > b.createdAt) {
+				return 1;
+		}
+
+		// Sort next by id, lower-id timers take precedence
+		if (a.id < b.id) {
+				return -1;
+		}
+		if (a.id > b.id) {
+				return 1;
+		}
+
+		// As timer ids are unique, no fallback `0` is necessary
+}
+
+function callTimer(clock, timer) {
+		if (typeof timer.interval == "number") {
+				clock.timers[timer.id].callAt += timer.interval;
+		} else {
+				delete clock.timers[timer.id];
+		}
+
+		try {
+				if (typeof timer.func == "function") {
+						timer.func.apply(null, timer.args);
+				} else {
+						eval(timer.func);
+				}
+		} catch (e) {
+				var exception = e;
+		}
+
+		if (!clock.timers[timer.id]) {
+				if (exception) {
+						throw exception;
+				}
+				return;
+		}
+
+		if (exception) {
+				throw exception;
+		}
+}
+
+function uninstall(clock, target) {
+		var method;
+
+		for (var i = 0, l = clock.methods.length; i < l; i++) {
+				method = clock.methods[i];
+
+				if (target[method].hadOwnProperty) {
+						target[method] = clock["_" + method];
+				} else {
+						try {
+								delete target[method];
+						} catch (e) {}
+				}
+		}
+
+		// Prevent multiple executions which will completely remove these props
+		clock.methods = [];
+}
+
+function hijackMethod(target, method, clock) {
+		clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(target, method);
+		clock["_" + method] = target[method];
+
+		if (method == "Date") {
+				var date = mirrorDateProperties(clock[method], target[method]);
+				target[method] = date;
+		} else {
+				target[method] = function () {
+						return clock[method].apply(clock, arguments);
+				};
+
+				for (var prop in clock[method]) {
+						if (clock[method].hasOwnProperty(prop)) {
+								target[method][prop] = clock[method][prop];
+						}
+				}
+		}
+
+		target[method].clock = clock;
+}
+
+var timers = {
+		setTimeout: setTimeout,
+		clearTimeout: clearTimeout,
+		setImmediate: (typeof setImmediate !== "undefined" ? setImmediate : undefined),
+		clearImmediate: (typeof clearImmediate !== "undefined" ? clearImmediate: undefined),
+		setInterval: setInterval,
+		clearInterval: clearInterval,
+		Date: Date
+};
+
+var keys = Object.keys || function (obj) {
+		var ks = [];
+		for (var key in obj) {
+				ks.push(key);
+		}
+		return ks;
+};
+
+exports.timers = timers;
+
+var createClock = exports.createClock = function (now) {
+		var clock = {
+				now: getEpoch(now),
+				timeouts: {},
+				Date: createDate()
+		};
+
+		clock.Date.clock = clock;
+
+		clock.setTimeout = function setTimeout(func, timeout) {
+				return addTimer(clock, {
+						func: func,
+						args: Array.prototype.slice.call(arguments, 2),
+						delay: timeout
+				});
+		};
+
+		clock.clearTimeout = function clearTimeout(timerId) {
+				if (!timerId) {
+						// null appears to be allowed in most browsers, and appears to be
+						// relied upon by some libraries, like Bootstrap carousel
+						return;
+				}
+				if (!clock.timers) {
+						clock.timers = [];
+				}
+				// in Node, timerId is an object with .ref()/.unref(), and
+				// its .id field is the actual timer id.
+				if (typeof timerId === "object") {
+						timerId = timerId.id
+				}
+				if (timerId in clock.timers) {
+						delete clock.timers[timerId];
+				}
+		};
+
+		clock.setInterval = function setInterval(func, timeout) {
+				return addTimer(clock, {
+						func: func,
+						args: Array.prototype.slice.call(arguments, 2),
+						delay: timeout,
+						interval: timeout
+				});
+		};
+
+		clock.clearInterval = function clearInterval(timerId) {
+				clock.clearTimeout(timerId);
+		};
+
+		clock.setImmediate = function setImmediate(func) {
+				return addTimer(clock, {
+						func: func,
+						args: Array.prototype.slice.call(arguments, 1),
+						immediate: true
+				});
+		};
+
+		clock.clearImmediate = function clearImmediate(timerId) {
+				clock.clearTimeout(timerId);
+		};
+
+		clock.tick = function tick(ms) {
+				ms = typeof ms == "number" ? ms : parseTime(ms);
+				var tickFrom = clock.now, tickTo = clock.now + ms, previous = clock.now;
+				var timer = firstTimerInRange(clock, tickFrom, tickTo);
+
+				var firstException;
+				while (timer && tickFrom <= tickTo) {
+						if (clock.timers[timer.id]) {
+								tickFrom = clock.now = timer.callAt;
+								try {
+										callTimer(clock, timer);
+								} catch (e) {
+										firstException = firstException || e;
+								}
+						}
+
+						timer = firstTimerInRange(clock, previous, tickTo);
+						previous = tickFrom;
+				}
+
+				clock.now = tickTo;
+
+				if (firstException) {
+						throw firstException;
+				}
+
+				return clock.now;
+		};
+
+		clock.reset = function reset() {
+				clock.timers = {};
+		};
+
+		return clock;
+};
+
+exports.install = function install(target, now, toFake) {
+		if (typeof target === "number") {
+				toFake = now;
+				now = target;
+				target = null;
+		}
+
+		if (!target) {
+				target = global;
+		}
+
+		var clock = createClock(now);
+
+		clock.uninstall = function () {
+				uninstall(clock, target);
+		};
+
+		clock.methods = toFake || [];
+
+		if (clock.methods.length === 0) {
+				clock.methods = keys(timers);
+		}
+
+		for (var i = 0, l = clock.methods.length; i < l; i++) {
+				hijackMethod(target, clock.methods[i], clock);
+		}
+
+		return clock;
+};
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+},{}]},{},[1])(1)
+});
+	})();
+	var define;
+/**
+ * Sinon core utilities. For internal use only.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+
+var sinon = (function () {
+"use strict";
+
+		var sinon;
+		var isNode = typeof module !== "undefined" && module.exports && typeof require === "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, exports, module) {
+				sinon = module.exports = require("./sinon/util/core");
+				require("./sinon/extend");
+				require("./sinon/typeOf");
+				require("./sinon/times_in_words");
+				require("./sinon/spy");
+				require("./sinon/call");
+				require("./sinon/behavior");
+				require("./sinon/stub");
+				require("./sinon/mock");
+				require("./sinon/collection");
+				require("./sinon/assert");
+				require("./sinon/sandbox");
+				require("./sinon/test");
+				require("./sinon/test_case");
+				require("./sinon/match");
+				require("./sinon/format");
+				require("./sinon/log_error");
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+				sinon = module.exports;
+		} else {
+				sinon = {};
+		}
+
+		return sinon;
+}());
+
+/**
+ * @depend ../../sinon.js
+ */
+/**
+ * Sinon core utilities. For internal use only.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+
+(function (sinon) {
+		var div = typeof document != "undefined" && document.createElement("div");
+		var hasOwn = Object.prototype.hasOwnProperty;
+
+		function isDOMNode(obj) {
+				var success = false;
+
+				try {
+						obj.appendChild(div);
+						success = div.parentNode == obj;
+				} catch (e) {
+						return false;
+				} finally {
+						try {
+								obj.removeChild(div);
+						} catch (e) {
+								// Remove failed, not much we can do about that
+						}
+				}
+
+				return success;
+		}
+
+		function isElement(obj) {
+				return div && obj && obj.nodeType === 1 && isDOMNode(obj);
+		}
+
+		function isFunction(obj) {
+				return typeof obj === "function" || !!(obj && obj.constructor && obj.call && obj.apply);
+		}
+
+		function isReallyNaN(val) {
+				return typeof val === "number" && isNaN(val);
+		}
+
+		function mirrorProperties(target, source) {
+				for (var prop in source) {
+						if (!hasOwn.call(target, prop)) {
+								target[prop] = source[prop];
+						}
+				}
+		}
+
+		function isRestorable(obj) {
+				return typeof obj === "function" && typeof obj.restore === "function" && obj.restore.sinon;
+		}
+
+		// Cheap way to detect if we have ES5 support.
+		var hasES5Support = "keys" in Object;
+
+		function makeApi(sinon) {
+				sinon.wrapMethod = function wrapMethod(object, property, method) {
+						if (!object) {
+								throw new TypeError("Should wrap property of object");
+						}
+
+						if (typeof method != "function" && typeof method != "object") {
+								throw new TypeError("Method wrapper should be a function or a property descriptor");
+						}
+
+						function checkWrappedMethod(wrappedMethod) {
+								if (!isFunction(wrappedMethod)) {
+										error = new TypeError("Attempted to wrap " + (typeof wrappedMethod) + " property " +
+																				property + " as function");
+								} else if (wrappedMethod.restore && wrappedMethod.restore.sinon) {
+										error = new TypeError("Attempted to wrap " + property + " which is already wrapped");
+								} else if (wrappedMethod.calledBefore) {
+										var verb = !!wrappedMethod.returns ? "stubbed" : "spied on";
+										error = new TypeError("Attempted to wrap " + property + " which is already " + verb);
+								}
+
+								if (error) {
+										if (wrappedMethod && wrappedMethod.stackTrace) {
+												error.stack += "\n--------------\n" + wrappedMethod.stackTrace;
+										}
+										throw error;
+								}
+						}
+
+						var error, wrappedMethod;
+
+						// IE 8 does not support hasOwnProperty on the window object and Firefox has a problem
+						// when using hasOwn.call on objects from other frames.
+						var owned = object.hasOwnProperty ? object.hasOwnProperty(property) : hasOwn.call(object, property);
+
+						if (hasES5Support) {
+								var methodDesc = (typeof method == "function") ? {value: method} : method,
+										wrappedMethodDesc = sinon.getPropertyDescriptor(object, property),
+										i;
+
+								if (!wrappedMethodDesc) {
+										error = new TypeError("Attempted to wrap " + (typeof wrappedMethod) + " property " +
+																				property + " as function");
+								} else if (wrappedMethodDesc.restore && wrappedMethodDesc.restore.sinon) {
+										error = new TypeError("Attempted to wrap " + property + " which is already wrapped");
+								}
+								if (error) {
+										if (wrappedMethodDesc && wrappedMethodDesc.stackTrace) {
+												error.stack += "\n--------------\n" + wrappedMethodDesc.stackTrace;
+										}
+										throw error;
+								}
+
+								var types = sinon.objectKeys(methodDesc);
+								for (i = 0; i < types.length; i++) {
+										wrappedMethod = wrappedMethodDesc[types[i]];
+										checkWrappedMethod(wrappedMethod);
+								}
+
+								mirrorProperties(methodDesc, wrappedMethodDesc);
+								for (i = 0; i < types.length; i++) {
+										mirrorProperties(methodDesc[types[i]], wrappedMethodDesc[types[i]]);
+								}
+								Object.defineProperty(object, property, methodDesc);
+						} else {
+								wrappedMethod = object[property];
+								checkWrappedMethod(wrappedMethod);
+								object[property] = method;
+								method.displayName = property;
+						}
+
+						method.displayName = property;
+
+						// Set up a stack trace which can be used later to find what line of
+						// code the original method was created on.
+						method.stackTrace = (new Error("Stack Trace for original")).stack;
+
+						method.restore = function () {
+								// For prototype properties try to reset by delete first.
+								// If this fails (ex: localStorage on mobile safari) then force a reset
+								// via direct assignment.
+								if (!owned) {
+										try {
+												delete object[property];
+										} catch (e) {}
+										// For native code functions `delete` fails without throwing an error
+										// on Chrome < 43, PhantomJS, etc.
+										// Use strict equality comparison to check failures then force a reset
+										// via direct assignment.
+										if (object[property] === method) {
+												object[property] = wrappedMethod;
+										}
+								} else if (hasES5Support) {
+										Object.defineProperty(object, property, wrappedMethodDesc);
+								}
+
+								if (!hasES5Support && object[property] === method) {
+										object[property] = wrappedMethod;
+								}
+						};
+
+						method.restore.sinon = true;
+
+						if (!hasES5Support) {
+								mirrorProperties(method, wrappedMethod);
+						}
+
+						return method;
+				};
+
+				sinon.create = function create(proto) {
+						var F = function () {};
+						F.prototype = proto;
+						return new F();
+				};
+
+				sinon.deepEqual = function deepEqual(a, b) {
+						if (sinon.match && sinon.match.isMatcher(a)) {
+								return a.test(b);
+						}
+
+						if (typeof a != "object" || typeof b != "object") {
+								if (isReallyNaN(a) && isReallyNaN(b)) {
+										return true;
+								} else {
+										return a === b;
+								}
+						}
+
+						if (isElement(a) || isElement(b)) {
+								return a === b;
+						}
+
+						if (a === b) {
+								return true;
+						}
+
+						if ((a === null && b !== null) || (a !== null && b === null)) {
+								return false;
+						}
+
+						if (a instanceof RegExp && b instanceof RegExp) {
+								return (a.source === b.source) && (a.global === b.global) &&
+										(a.ignoreCase === b.ignoreCase) && (a.multiline === b.multiline);
+						}
+
+						var aString = Object.prototype.toString.call(a);
+						if (aString != Object.prototype.toString.call(b)) {
+								return false;
+						}
+
+						if (aString == "[object Date]") {
+								return a.valueOf() === b.valueOf();
+						}
+
+						var prop, aLength = 0, bLength = 0;
+
+						if (aString == "[object Array]" && a.length !== b.length) {
+								return false;
+						}
+
+						for (prop in a) {
+								aLength += 1;
+
+								if (!(prop in b)) {
+										return false;
+								}
+
+								if (!deepEqual(a[prop], b[prop])) {
+										return false;
+								}
+						}
+
+						for (prop in b) {
+								bLength += 1;
+						}
+
+						return aLength == bLength;
+				};
+
+				sinon.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;
+				};
+
+				sinon.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";
+				};
+
+				sinon.objectKeys = function objectKeys(obj) {
+						if (obj !== Object(obj)) {
+								throw new TypeError("sinon.objectKeys called on a non-object");
+						}
+
+						var keys = [];
+						var key;
+						for (key in obj) {
+								if (hasOwn.call(obj, key)) {
+										keys.push(key);
+								}
+						}
+
+						return keys;
+				};
+
+				sinon.getPropertyDescriptor = function getPropertyDescriptor(object, property) {
+						var proto = object, descriptor;
+						while (proto && !(descriptor = Object.getOwnPropertyDescriptor(proto, property))) {
+								proto = Object.getPrototypeOf(proto);
+						}
+						return descriptor;
+				}
+
+				sinon.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;
+				};
+
+				sinon.defaultConfig = {
+						injectIntoThis: true,
+						injectInto: null,
+						properties: ["spy", "stub", "mock", "clock", "server", "requests"],
+						useFakeTimers: true,
+						useFakeServer: true
+				};
+
+				sinon.timesInWords = function timesInWords(count) {
+						return count == 1 && "once" ||
+								count == 2 && "twice" ||
+								count == 3 && "thrice" ||
+								(count || 0) + " times";
+				};
+
+				sinon.calledInOrder = function (spies) {
+						for (var i = 1, l = spies.length; i < l; i++) {
+								if (!spies[i - 1].calledBefore(spies[i]) || !spies[i].called) {
+										return false;
+								}
+						}
+
+						return true;
+				};
+
+				sinon.orderByFirstCall = function (spies) {
+						return spies.sort(function (a, b) {
+								// uuid, won't ever be equal
+								var aCall = a.getCall(0);
+								var bCall = b.getCall(0);
+								var aId = aCall && aCall.callId || -1;
+								var bId = bCall && bCall.callId || -1;
+
+								return aId < bId ? -1 : 1;
+						});
+				};
+
+				sinon.createStubInstance = function (constructor) {
+						if (typeof constructor !== "function") {
+								throw new TypeError("The constructor should be a function.");
+						}
+						return sinon.stub(sinon.create(constructor.prototype));
+				};
+
+				sinon.restore = function (object) {
+						if (object !== null && typeof object === "object") {
+								for (var prop in object) {
+										if (isRestorable(object[prop])) {
+												object[prop].restore();
+										}
+								}
+						} else if (isRestorable(object)) {
+								object.restore();
+						}
+				};
+
+				return sinon;
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, exports) {
+				makeApi(exports);
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports);
+		} else if (!sinon) {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend util/core.js
+ */
+
+(function (sinon) {
+		function makeApi(sinon) {
+
+				// Adapted from https://developer.mozilla.org/en/docs/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug
+				var hasDontEnumBug = (function () {
+						var obj = {
+								constructor: function () {
+										return "0";
+								},
+								toString: function () {
+										return "1";
+								},
+								valueOf: function () {
+										return "2";
+								},
+								toLocaleString: function () {
+										return "3";
+								},
+								prototype: function () {
+										return "4";
+								},
+								isPrototypeOf: function () {
+										return "5";
+								},
+								propertyIsEnumerable: function () {
+										return "6";
+								},
+								hasOwnProperty: function () {
+										return "7";
+								},
+								length: function () {
+										return "8";
+								},
+								unique: function () {
+										return "9"
+								}
+						};
+
+						var result = [];
+						for (var prop in obj) {
+								result.push(obj[prop]());
+						}
+						return result.join("") !== "0123456789";
+				})();
+
+				/* Public: Extend target in place with all (own) properties from sources in-order. Thus, last source will
+				 *         override properties in previous sources.
+				 *
+				 * target - The Object to extend
+				 * sources - Objects to copy properties from.
+				 *
+				 * Returns the extended target
+				 */
+				function extend(target /*, sources */) {
+						var sources = Array.prototype.slice.call(arguments, 1),
+								source, i, prop;
+
+						for (i = 0; i < sources.length; i++) {
+								source = sources[i];
+
+								for (prop in source) {
+										if (source.hasOwnProperty(prop)) {
+												target[prop] = source[prop];
+										}
+								}
+
+								// Make sure we copy (own) toString method even when in JScript with DontEnum bug
+								// See https://developer.mozilla.org/en/docs/ECMAScript_DontEnum_attribute#JScript_DontEnum_Bug
+								if (hasDontEnumBug && source.hasOwnProperty("toString") && source.toString !== target.toString) {
+										target.toString = source.toString;
+								}
+						}
+
+						return target;
+				};
+
+				sinon.extend = extend;
+				return sinon.extend;
+		}
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./util/core");
+				module.exports = makeApi(sinon);
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (!sinon) {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend util/core.js
+ */
+
+(function (sinon) {
+		function makeApi(sinon) {
+
+				function timesInWords(count) {
+						switch (count) {
+								case 1:
+										return "once";
+								case 2:
+										return "twice";
+								case 3:
+										return "thrice";
+								default:
+										return (count || 0) + " times";
+						}
+				}
+
+				sinon.timesInWords = timesInWords;
+				return sinon.timesInWords;
+		}
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./util/core");
+				module.exports = makeApi(sinon);
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (!sinon) {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend util/core.js
+ */
+/**
+ * Format functions
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2014 Christian Johansen
+ */
+
+(function (sinon, formatio) {
+		function makeApi(sinon) {
+				function typeOf(value) {
+						if (value === null) {
+								return "null";
+						} else if (value === undefined) {
+								return "undefined";
+						}
+						var string = Object.prototype.toString.call(value);
+						return string.substring(8, string.length - 1).toLowerCase();
+				};
+
+				sinon.typeOf = typeOf;
+				return sinon.typeOf;
+		}
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./util/core");
+				module.exports = makeApi(sinon);
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (!sinon) {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+}(
+		(typeof sinon == "object" && sinon || null),
+		(typeof formatio == "object" && formatio)
+));
+
+/**
+ * @depend util/core.js
+ * @depend typeOf.js
+ */
+/*jslint eqeqeq: false, onevar: false, plusplus: false*/
+/*global module, require, sinon*/
+/**
+ * Match functions
+ *
+ * @author Maximilian Antoni (mail@maxantoni.de)
+ * @license BSD
+ *
+ * Copyright (c) 2012 Maximilian Antoni
+ */
+
+(function (sinon) {
+		function makeApi(sinon) {
+				function assertType(value, type, name) {
+						var actual = sinon.typeOf(value);
+						if (actual !== type) {
+								throw new TypeError("Expected type of " + name + " to be " +
+										type + ", but was " + actual);
+						}
+				}
+
+				var matcher = {
+						toString: function () {
+								return this.message;
+						}
+				};
+
+				function isMatcher(object) {
+						return matcher.isPrototypeOf(object);
+				}
+
+				function matchObject(expectation, actual) {
+						if (actual === null || actual === undefined) {
+								return false;
+						}
+						for (var key in expectation) {
+								if (expectation.hasOwnProperty(key)) {
+										var exp = expectation[key];
+										var act = actual[key];
+										if (match.isMatcher(exp)) {
+												if (!exp.test(act)) {
+														return false;
+												}
+										} else if (sinon.typeOf(exp) === "object") {
+												if (!matchObject(exp, act)) {
+														return false;
+												}
+										} else if (!sinon.deepEqual(exp, act)) {
+												return false;
+										}
+								}
+						}
+						return true;
+				}
+
+				matcher.or = function (m2) {
+						if (!arguments.length) {
+								throw new TypeError("Matcher expected");
+						} else if (!isMatcher(m2)) {
+								m2 = match(m2);
+						}
+						var m1 = this;
+						var or = sinon.create(matcher);
+						or.test = function (actual) {
+								return m1.test(actual) || m2.test(actual);
+						};
+						or.message = m1.message + ".or(" + m2.message + ")";
+						return or;
+				};
+
+				matcher.and = function (m2) {
+						if (!arguments.length) {
+								throw new TypeError("Matcher expected");
+						} else if (!isMatcher(m2)) {
+								m2 = match(m2);
+						}
+						var m1 = this;
+						var and = sinon.create(matcher);
+						and.test = function (actual) {
+								return m1.test(actual) && m2.test(actual);
+						};
+						and.message = m1.message + ".and(" + m2.message + ")";
+						return and;
+				};
+
+				var match = function (expectation, message) {
+						var m = sinon.create(matcher);
+						var type = sinon.typeOf(expectation);
+						switch (type) {
+						case "object":
+								if (typeof expectation.test === "function") {
+										m.test = function (actual) {
+												return expectation.test(actual) === true;
+										};
+										m.message = "match(" + sinon.functionName(expectation.test) + ")";
+										return m;
+								}
+								var str = [];
+								for (var key in expectation) {
+										if (expectation.hasOwnProperty(key)) {
+												str.push(key + ": " + expectation[key]);
+										}
+								}
+								m.test = function (actual) {
+										return matchObject(expectation, actual);
+								};
+								m.message = "match(" + str.join(", ") + ")";
+								break;
+						case "number":
+								m.test = function (actual) {
+										return expectation == actual;
+								};
+								break;
+						case "string":
+								m.test = function (actual) {
+										if (typeof actual !== "string") {
+												return false;
+										}
+										return actual.indexOf(expectation) !== -1;
+								};
+								m.message = "match(\"" + expectation + "\")";
+								break;
+						case "regexp":
+								m.test = function (actual) {
+										if (typeof actual !== "string") {
+												return false;
+										}
+										return expectation.test(actual);
+								};
+								break;
+						case "function":
+								m.test = expectation;
+								if (message) {
+										m.message = message;
+								} else {
+										m.message = "match(" + sinon.functionName(expectation) + ")";
+								}
+								break;
+						default:
+								m.test = function (actual) {
+										return sinon.deepEqual(expectation, actual);
+								};
+						}
+						if (!m.message) {
+								m.message = "match(" + expectation + ")";
+						}
+						return m;
+				};
+
+				match.isMatcher = isMatcher;
+
+				match.any = match(function () {
+						return true;
+				}, "any");
+
+				match.defined = match(function (actual) {
+						return actual !== null && actual !== undefined;
+				}, "defined");
+
+				match.truthy = match(function (actual) {
+						return !!actual;
+				}, "truthy");
+
+				match.falsy = match(function (actual) {
+						return !actual;
+				}, "falsy");
+
+				match.same = function (expectation) {
+						return match(function (actual) {
+								return expectation === actual;
+						}, "same(" + expectation + ")");
+				};
+
+				match.typeOf = function (type) {
+						assertType(type, "string", "type");
+						return match(function (actual) {
+								return sinon.typeOf(actual) === type;
+						}, "typeOf(\"" + type + "\")");
+				};
+
+				match.instanceOf = function (type) {
+						assertType(type, "function", "type");
+						return match(function (actual) {
+								return actual instanceof type;
+						}, "instanceOf(" + sinon.functionName(type) + ")");
+				};
+
+				function createPropertyMatcher(propertyTest, messagePrefix) {
+						return function (property, value) {
+								assertType(property, "string", "property");
+								var onlyProperty = arguments.length === 1;
+								var message = messagePrefix + "(\"" + property + "\"";
+								if (!onlyProperty) {
+										message += ", " + value;
+								}
+								message += ")";
+								return match(function (actual) {
+										if (actual === undefined || actual === null ||
+														!propertyTest(actual, property)) {
+												return false;
+										}
+										return onlyProperty || sinon.deepEqual(value, actual[property]);
+								}, message);
+						};
+				}
+
+				match.has = createPropertyMatcher(function (actual, property) {
+						if (typeof actual === "object") {
+								return property in actual;
+						}
+						return actual[property] !== undefined;
+				}, "has");
+
+				match.hasOwn = createPropertyMatcher(function (actual, property) {
+						return actual.hasOwnProperty(property);
+				}, "hasOwn");
+
+				match.bool = match.typeOf("boolean");
+				match.number = match.typeOf("number");
+				match.string = match.typeOf("string");
+				match.object = match.typeOf("object");
+				match.func = match.typeOf("function");
+				match.array = match.typeOf("array");
+				match.regexp = match.typeOf("regexp");
+				match.date = match.typeOf("date");
+
+				sinon.match = match;
+				return match;
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./util/core");
+				require("./typeOf");
+				module.exports = makeApi(sinon);
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (!sinon) {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend util/core.js
+ */
+/**
+ * Format functions
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2014 Christian Johansen
+ */
+
+(function (sinon, formatio) {
+		function makeApi(sinon) {
+				function valueFormatter(value) {
+						return "" + value;
+				}
+
+				function getFormatioFormatter() {
+						var formatter = formatio.configure({
+										quoteStrings: false,
+										limitChildrenCount: 250
+								});
+
+						function format() {
+								return formatter.ascii.apply(formatter, arguments);
+						};
+
+						return format;
+				}
+
+				function getNodeFormatter(value) {
+						function format(value) {
+								return typeof value == "object" && value.toString === Object.prototype.toString ? util.inspect(value) : value;
+						};
+
+						try {
+								var util = require("util");
+						} catch (e) {
+								/* Node, but no util module - would be very old, but better safe than sorry */
+						}
+
+						return util ? format : valueFormatter;
+				}
+
+				var isNode = typeof module !== "undefined" && module.exports && typeof require == "function",
+						formatter;
+
+				if (isNode) {
+						try {
+								formatio = require("formatio");
+						} catch (e) {}
+				}
+
+				if (formatio) {
+						formatter = getFormatioFormatter()
+				} else if (isNode) {
+						formatter = getNodeFormatter();
+				} else {
+						formatter = valueFormatter;
+				}
+
+				sinon.format = formatter;
+				return sinon.format;
+		}
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./util/core");
+				module.exports = makeApi(sinon);
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (!sinon) {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+}(
+		(typeof sinon == "object" && sinon || null),
+		(typeof formatio == "object" && formatio)
+));
+
+/**
+	* @depend util/core.js
+	* @depend match.js
+	* @depend format.js
+	*/
+/**
+	* Spy calls
+	*
+	* @author Christian Johansen (christian@cjohansen.no)
+	* @author Maximilian Antoni (mail@maxantoni.de)
+	* @license BSD
+	*
+	* Copyright (c) 2010-2013 Christian Johansen
+	* Copyright (c) 2013 Maximilian Antoni
+	*/
+
+(function (sinon) {
+		function makeApi(sinon) {
+				function throwYieldError(proxy, text, args) {
+						var msg = sinon.functionName(proxy) + text;
+						if (args.length) {
+								msg += " Received [" + slice.call(args).join(", ") + "]";
+						}
+						throw new Error(msg);
+				}
+
+				var slice = Array.prototype.slice;
+
+				var callProto = {
+						calledOn: function calledOn(thisValue) {
+								if (sinon.match && sinon.match.isMatcher(thisValue)) {
+										return thisValue.test(this.thisValue);
+								}
+								return this.thisValue === thisValue;
+						},
+
+						calledWith: function calledWith() {
+								var l = arguments.length;
+								if (l > this.args.length) {
+										return false;
+								}
+								for (var i = 0; i < l; i += 1) {
+										if (!sinon.deepEqual(arguments[i], this.args[i])) {
+												return false;
+										}
+								}
+
+								return true;
+						},
+
+						calledWithMatch: function calledWithMatch() {
+								var l = arguments.length;
+								if (l > this.args.length) {
+										return false;
+								}
+								for (var i = 0; i < l; i += 1) {
+										var actual = this.args[i];
+										var expectation = arguments[i];
+										if (!sinon.match || !sinon.match(expectation).test(actual)) {
+												return false;
+										}
+								}
+								return true;
+						},
+
+						calledWithExactly: function calledWithExactly() {
+								return arguments.length == this.args.length &&
+										this.calledWith.apply(this, arguments);
+						},
+
+						notCalledWith: function notCalledWith() {
+								return !this.calledWith.apply(this, arguments);
+						},
+
+						notCalledWithMatch: function notCalledWithMatch() {
+								return !this.calledWithMatch.apply(this, arguments);
+						},
+
+						returned: function returned(value) {
+								return sinon.deepEqual(value, this.returnValue);
+						},
+
+						threw: function threw(error) {
+								if (typeof error === "undefined" || !this.exception) {
+										return !!this.exception;
+								}
+
+								return this.exception === error || this.exception.name === error;
+						},
+
+						calledWithNew: function calledWithNew() {
+								return this.proxy.prototype && this.thisValue instanceof this.proxy;
+						},
+
+						calledBefore: function (other) {
+								return this.callId < other.callId;
+						},
+
+						calledAfter: function (other) {
+								return this.callId > other.callId;
+						},
+
+						callArg: function (pos) {
+								this.args[pos]();
+						},
+
+						callArgOn: function (pos, thisValue) {
+								this.args[pos].apply(thisValue);
+						},
+
+						callArgWith: function (pos) {
+								this.callArgOnWith.apply(this, [pos, null].concat(slice.call(arguments, 1)));
+						},
+
+						callArgOnWith: function (pos, thisValue) {
+								var args = slice.call(arguments, 2);
+								this.args[pos].apply(thisValue, args);
+						},
+
+						yield: function () {
+								this.yieldOn.apply(this, [null].concat(slice.call(arguments, 0)));
+						},
+
+						yieldOn: function (thisValue) {
+								var args = this.args;
+								for (var i = 0, l = args.length; i < l; ++i) {
+										if (typeof args[i] === "function") {
+												args[i].apply(thisValue, slice.call(arguments, 1));
+												return;
+										}
+								}
+								throwYieldError(this.proxy, " cannot yield since no callback was passed.", args);
+						},
+
+						yieldTo: function (prop) {
+								this.yieldToOn.apply(this, [prop, null].concat(slice.call(arguments, 1)));
+						},
+
+						yieldToOn: function (prop, thisValue) {
+								var args = this.args;
+								for (var i = 0, l = args.length; i < l; ++i) {
+										if (args[i] && typeof args[i][prop] === "function") {
+												args[i][prop].apply(thisValue, slice.call(arguments, 2));
+												return;
+										}
+								}
+								throwYieldError(this.proxy, " cannot yield to '" + prop +
+										"' since no callback was passed.", args);
+						},
+
+						toString: function () {
+								var callStr = this.proxy.toString() + "(";
+								var args = [];
+
+								for (var i = 0, l = this.args.length; i < l; ++i) {
+										args.push(sinon.format(this.args[i]));
+								}
+
+								callStr = callStr + args.join(", ") + ")";
+
+								if (typeof this.returnValue != "undefined") {
+										callStr += " => " + sinon.format(this.returnValue);
+								}
+
+								if (this.exception) {
+										callStr += " !" + this.exception.name;
+
+										if (this.exception.message) {
+												callStr += "(" + this.exception.message + ")";
+										}
+								}
+
+								return callStr;
+						}
+				};
+
+				callProto.invokeCallback = callProto.yield;
+
+				function createSpyCall(spy, thisValue, args, returnValue, exception, id) {
+						if (typeof id !== "number") {
+								throw new TypeError("Call id is not a number");
+						}
+						var proxyCall = sinon.create(callProto);
+						proxyCall.proxy = spy;
+						proxyCall.thisValue = thisValue;
+						proxyCall.args = args;
+						proxyCall.returnValue = returnValue;
+						proxyCall.exception = exception;
+						proxyCall.callId = id;
+
+						return proxyCall;
+				}
+				createSpyCall.toString = callProto.toString; // used by mocks
+
+				sinon.spyCall = createSpyCall;
+				return createSpyCall;
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./util/core");
+				require("./match");
+				require("./format");
+				module.exports = makeApi(sinon);
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (!sinon) {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+}(typeof sinon == "object" && sinon || null));
+
+/**
+	* @depend times_in_words.js
+	* @depend util/core.js
+	* @depend extend.js
+	* @depend call.js
+	* @depend format.js
+	*/
+/**
+	* Spy functions
+	*
+	* @author Christian Johansen (christian@cjohansen.no)
+	* @license BSD
+	*
+	* Copyright (c) 2010-2013 Christian Johansen
+	*/
+
+(function (sinon) {
+
+		function makeApi(sinon) {
+				var push = Array.prototype.push;
+				var slice = Array.prototype.slice;
+				var callId = 0;
+
+				function spy(object, property, types) {
+						if (!property && typeof object == "function") {
+								return spy.create(object);
+						}
+
+						if (!object && !property) {
+								return spy.create(function () { });
+						}
+
+						if (types) {
+								var methodDesc = sinon.getPropertyDescriptor(object, property);
+								for (var i = 0; i < types.length; i++) {
+										methodDesc[types[i]] = spy.create(methodDesc[types[i]]);
+								}
+								return sinon.wrapMethod(object, property, methodDesc);
+						} else {
+								var method = object[property];
+								return sinon.wrapMethod(object, property, spy.create(method));
+						}
+				}
+
+				function matchingFake(fakes, args, strict) {
+						if (!fakes) {
+								return;
+						}
+
+						for (var i = 0, l = fakes.length; i < l; i++) {
+								if (fakes[i].matches(args, strict)) {
+										return fakes[i];
+								}
+						}
+				}
+
+				function incrementCallCount() {
+						this.called = true;
+						this.callCount += 1;
+						this.notCalled = false;
+						this.calledOnce = this.callCount == 1;
+						this.calledTwice = this.callCount == 2;
+						this.calledThrice = this.callCount == 3;
+				}
+
+				function createCallProperties() {
+						this.firstCall = this.getCall(0);
+						this.secondCall = this.getCall(1);
+						this.thirdCall = this.getCall(2);
+						this.lastCall = this.getCall(this.callCount - 1);
+				}
+
+				var vars = "a,b,c,d,e,f,g,h,i,j,k,l";
+				function createProxy(func, proxyLength) {
+						// Retain the function length:
+						var p;
+						if (proxyLength) {
+								eval("p = (function proxy(" + vars.substring(0, proxyLength * 2 - 1) +
+										") { return p.invoke(func, this, slice.call(arguments)); });");
+						} else {
+								p = function proxy() {
+										return p.invoke(func, this, slice.call(arguments));
+								};
+						}
+						return p;
+				}
+
+				var uuid = 0;
+
+				// Public API
+				var spyApi = {
+						reset: function () {
+								if (this.invoking) {
+										var err = new Error("Cannot reset Sinon function while invoking it. " +
+																				"Move the call to .reset outside of the callback.");
+										err.name = "InvalidResetException";
+										throw err;
+								}
+
+								this.called = false;
+								this.notCalled = true;
+								this.calledOnce = false;
+								this.calledTwice = false;
+								this.calledThrice = false;
+								this.callCount = 0;
+								this.firstCall = null;
+								this.secondCall = null;
+								this.thirdCall = null;
+								this.lastCall = null;
+								this.args = [];
+								this.returnValues = [];
+								this.thisValues = [];
+								this.exceptions = [];
+								this.callIds = [];
+								if (this.fakes) {
+										for (var i = 0; i < this.fakes.length; i++) {
+												this.fakes[i].reset();
+										}
+								}
+
+								return this;
+						},
+
+						create: function create(func, spyLength) {
+								var name;
+
+								if (typeof func != "function") {
+										func = function () { };
+								} else {
+										name = sinon.functionName(func);
+								}
+
+								if (!spyLength) {
+										spyLength = func.length;
+								}
+
+								var proxy = createProxy(func, spyLength);
+
+								sinon.extend(proxy, spy);
+								delete proxy.create;
+								sinon.extend(proxy, func);
+
+								proxy.reset();
+								proxy.prototype = func.prototype;
+								proxy.displayName = name || "spy";
+								proxy.toString = sinon.functionToString;
+								proxy.instantiateFake = sinon.spy.create;
+								proxy.id = "spy#" + uuid++;
+
+								return proxy;
+						},
+
+						invoke: function invoke(func, thisValue, args) {
+								var matching = matchingFake(this.fakes, args);
+								var exception, returnValue;
+
+								incrementCallCount.call(this);
+								push.call(this.thisValues, thisValue);
+								push.call(this.args, args);
+								push.call(this.callIds, callId++);
+
+								// Make call properties available from within the spied function:
+								createCallProperties.call(this);
+
+								try {
+										this.invoking = true;
+
+										if (matching) {
+												returnValue = matching.invoke(func, thisValue, args);
+										} else {
+												returnValue = (this.func || func).apply(thisValue, args);
+										}
+
+										var thisCall = this.getCall(this.callCount - 1);
+										if (thisCall.calledWithNew() && typeof returnValue !== "object") {
+												returnValue = thisValue;
+										}
+								} catch (e) {
+										exception = e;
+								} finally {
+										delete this.invoking;
+								}
+
+								push.call(this.exceptions, exception);
+								push.call(this.returnValues, returnValue);
+
+								// Make return value and exception available in the calls:
+								createCallProperties.call(this);
+
+								if (exception !== undefined) {
+										throw exception;
+								}
+
+								return returnValue;
+						},
+
+						named: function named(name) {
+								this.displayName = name;
+								return this;
+						},
+
+						getCall: function getCall(i) {
+								if (i < 0 || i >= this.callCount) {
+										return null;
+								}
+
+								return sinon.spyCall(this, this.thisValues[i], this.args[i],
+																				this.returnValues[i], this.exceptions[i],
+																				this.callIds[i]);
+						},
+
+						getCalls: function () {
+								var calls = [];
+								var i;
+
+								for (i = 0; i < this.callCount; i++) {
+										calls.push(this.getCall(i));
+								}
+
+								return calls;
+						},
+
+						calledBefore: function calledBefore(spyFn) {
+								if (!this.called) {
+										return false;
+								}
+
+								if (!spyFn.called) {
+										return true;
+								}
+
+								return this.callIds[0] < spyFn.callIds[spyFn.callIds.length - 1];
+						},
+
+						calledAfter: function calledAfter(spyFn) {
+								if (!this.called || !spyFn.called) {
+										return false;
+								}
+
+								return this.callIds[this.callCount - 1] > spyFn.callIds[spyFn.callCount - 1];
+						},
+
+						withArgs: function () {
+								var args = slice.call(arguments);
+
+								if (this.fakes) {
+										var match = matchingFake(this.fakes, args, true);
+
+										if (match) {
+												return match;
+										}
+								} else {
+										this.fakes = [];
+								}
+
+								var original = this;
+								var fake = this.instantiateFake();
+								fake.matchingAguments = args;
+								fake.parent = this;
+								push.call(this.fakes, fake);
+
+								fake.withArgs = function () {
+										return original.withArgs.apply(original, arguments);
+								};
+
+								for (var i = 0; i < this.args.length; i++) {
+										if (fake.matches(this.args[i])) {
+												incrementCallCount.call(fake);
+												push.call(fake.thisValues, this.thisValues[i]);
+												push.call(fake.args, this.args[i]);
+												push.call(fake.returnValues, this.returnValues[i]);
+												push.call(fake.exceptions, this.exceptions[i]);
+												push.call(fake.callIds, this.callIds[i]);
+										}
+								}
+								createCallProperties.call(fake);
+
+								return fake;
+						},
+
+						matches: function (args, strict) {
+								var margs = this.matchingAguments;
+
+								if (margs.length <= args.length &&
+										sinon.deepEqual(margs, args.slice(0, margs.length))) {
+										return !strict || margs.length == args.length;
+								}
+						},
+
+						printf: function (format) {
+								var spy = this;
+								var args = slice.call(arguments, 1);
+								var formatter;
+
+								return (format || "").replace(/%(.)/g, function (match, specifyer) {
+										formatter = spyApi.formatters[specifyer];
+
+										if (typeof formatter == "function") {
+												return formatter.call(null, spy, args);
+										} else if (!isNaN(parseInt(specifyer, 10))) {
+												return sinon.format(args[specifyer - 1]);
+										}
+
+										return "%" + specifyer;
+								});
+						}
+				};
+
+				function delegateToCalls(method, matchAny, actual, notCalled) {
+						spyApi[method] = function () {
+								if (!this.called) {
+										if (notCalled) {
+												return notCalled.apply(this, arguments);
+										}
+										return false;
+								}
+
+								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;
+						};
+				}
+
+				delegateToCalls("calledOn", true);
+				delegateToCalls("alwaysCalledOn", false, "calledOn");
+				delegateToCalls("calledWith", true);
+				delegateToCalls("calledWithMatch", true);
+				delegateToCalls("alwaysCalledWith", false, "calledWith");
+				delegateToCalls("alwaysCalledWithMatch", false, "calledWithMatch");
+				delegateToCalls("calledWithExactly", true);
+				delegateToCalls("alwaysCalledWithExactly", false, "calledWithExactly");
+				delegateToCalls("neverCalledWith", false, "notCalledWith",
+						function () { return true; });
+				delegateToCalls("neverCalledWithMatch", false, "notCalledWithMatch",
+						function () { return true; });
+				delegateToCalls("threw", true);
+				delegateToCalls("alwaysThrew", false, "threw");
+				delegateToCalls("returned", true);
+				delegateToCalls("alwaysReturned", false, "returned");
+				delegateToCalls("calledWithNew", true);
+				delegateToCalls("alwaysCalledWithNew", false, "calledWithNew");
+				delegateToCalls("callArg", false, "callArgWith", function () {
+						throw new Error(this.toString() + " cannot call arg since it was not yet invoked.");
+				});
+				spyApi.callArgWith = spyApi.callArg;
+				delegateToCalls("callArgOn", false, "callArgOnWith", function () {
+						throw new Error(this.toString() + " cannot call arg since it was not yet invoked.");
+				});
+				spyApi.callArgOnWith = spyApi.callArgOn;
+				delegateToCalls("yield", false, "yield", function () {
+						throw new Error(this.toString() + " cannot yield since it was not yet invoked.");
+				});
+				// "invokeCallback" is an alias for "yield" since "yield" is invalid in strict mode.
+				spyApi.invokeCallback = spyApi.yield;
+				delegateToCalls("yieldOn", false, "yieldOn", function () {
+						throw new Error(this.toString() + " cannot yield since it was not yet invoked.");
+				});
+				delegateToCalls("yieldTo", false, "yieldTo", function (property) {
+						throw new Error(this.toString() + " cannot yield to '" + property +
+								"' since it was not yet invoked.");
+				});
+				delegateToCalls("yieldToOn", false, "yieldToOn", function (property) {
+						throw new Error(this.toString() + " cannot yield to '" + property +
+								"' since it was not yet invoked.");
+				});
+
+				spyApi.formatters = {
+						c: function (spy) {
+								return sinon.timesInWords(spy.callCount);
+						},
+
+						n: function (spy) {
+								return spy.toString();
+						},
+
+						C: function (spy) {
+								var calls = [];
+
+								for (var i = 0, l = spy.callCount; i < l; ++i) {
+										var stringifiedCall = "    " + spy.getCall(i).toString();
+										if (/\n/.test(calls[i - 1])) {
+												stringifiedCall = "\n" + stringifiedCall;
+										}
+										push.call(calls, stringifiedCall);
+								}
+
+								return calls.length > 0 ? "\n" + calls.join("\n") : "";
+						},
+
+						t: function (spy) {
+								var objects = [];
+
+								for (var i = 0, l = spy.callCount; i < l; ++i) {
+										push.call(objects, sinon.format(spy.thisValues[i]));
+								}
+
+								return objects.join(", ");
+						},
+
+						"*": function (spy, args) {
+								var formatted = [];
+
+								for (var i = 0, l = args.length; i < l; ++i) {
+										push.call(formatted, sinon.format(args[i]));
+								}
+
+								return formatted.join(", ");
+						}
+				};
+
+				sinon.extend(spy, spyApi);
+
+				spy.spyCall = sinon.spyCall;
+				sinon.spy = spy;
+
+				return spy;
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./util/core");
+				require("./call");
+				require("./extend");
+				require("./times_in_words");
+				require("./format");
+				module.exports = makeApi(sinon);
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (!sinon) {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend util/core.js
+ * @depend extend.js
+ */
+/**
+ * Stub behavior
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @author Tim Fischbach (mail@timfischbach.de)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+
+(function (sinon) {
+		var slice = Array.prototype.slice;
+		var join = Array.prototype.join;
+		var useLeftMostCallback = -1;
+		var useRightMostCallback = -2;
+
+		var nextTick = (function () {
+				if (typeof process === "object" && typeof process.nextTick === "function") {
+						return process.nextTick;
+				} else if (typeof setImmediate === "function") {
+						return setImmediate;
+				} else {
+						return function (callback) {
+								setTimeout(callback, 0);
+						};
+				}
+		})();
+
+		function throwsException(error, message) {
+				if (typeof error == "string") {
+						this.exception = new Error(message || "");
+						this.exception.name = error;
+				} else if (!error) {
+						this.exception = new Error("Error");
+				} else {
+						this.exception = error;
+				}
+
+				return this;
+		}
+
+		function getCallback(behavior, args) {
+				var callArgAt = behavior.callArgAt;
+
+				if (callArgAt >= 0) {
+						return args[callArgAt];
+				}
+
+				var argumentList;
+
+				if (callArgAt === useLeftMostCallback) {
+						argumentList = args;
+				}
+
+				if (callArgAt === useRightMostCallback) {
+						argumentList = slice.call(args).reverse();
+				}
+
+				var callArgProp = behavior.callArgProp;
+
+				for (var i = 0, l = argumentList.length; i < l; ++i) {
+						if (!callArgProp && typeof argumentList[i] == "function") {
+								return argumentList[i];
+						}
+
+						if (callArgProp && argumentList[i] &&
+								typeof argumentList[i][callArgProp] == "function") {
+								return argumentList[i][callArgProp];
+						}
+				}
+
+				return null;
+		}
+
+		function makeApi(sinon) {
+				function getCallbackError(behavior, func, args) {
+						if (behavior.callArgAt < 0) {
+								var msg;
+
+								if (behavior.callArgProp) {
+										msg = sinon.functionName(behavior.stub) +
+												" expected to yield to '" + behavior.callArgProp +
+												"', but no object with such a property was passed.";
+								} else {
+										msg = sinon.functionName(behavior.stub) +
+												" expected to yield, but no callback was passed.";
+								}
+
+								if (args.length > 0) {
+										msg += " Received [" + join.call(args, ", ") + "]";
+								}
+
+								return msg;
+						}
+
+						return "argument at index " + behavior.callArgAt + " is not a function: " + func;
+				}
+
+				function callCallback(behavior, args) {
+						if (typeof behavior.callArgAt == "number") {
+								var func = getCallback(behavior, args);
+
+								if (typeof func != "function") {
+										throw new TypeError(getCallbackError(behavior, func, args));
+								}
+
+								if (behavior.callbackAsync) {
+										nextTick(function () {
+												func.apply(behavior.callbackContext, behavior.callbackArguments);
+										});
+								} else {
+										func.apply(behavior.callbackContext, behavior.callbackArguments);
+								}
+						}
+				}
+
+				var proto = {
+						create: function create(stub) {
+								var behavior = sinon.extend({}, sinon.behavior);
+								delete behavior.create;
+								behavior.stub = stub;
+
+								return behavior;
+						},
+
+						isPresent: function isPresent() {
+								return (typeof this.callArgAt == "number" ||
+												this.exception ||
+												typeof this.returnArgAt == "number" ||
+												this.returnThis ||
+												this.returnValueDefined);
+						},
+
+						invoke: function invoke(context, args) {
+								callCallback(this, args);
+
+								if (this.exception) {
+										throw this.exception;
+								} else if (typeof this.returnArgAt == "number") {
+										return args[this.returnArgAt];
+								} else if (this.returnThis) {
+										return context;
+								}
+
+								return this.returnValue;
+						},
+
+						onCall: function onCall(index) {
+								return this.stub.onCall(index);
+						},
+
+						onFirstCall: function onFirstCall() {
+								return this.stub.onFirstCall();
+						},
+
+						onSecondCall: function onSecondCall() {
+								return this.stub.onSecondCall();
+						},
+
+						onThirdCall: function onThirdCall() {
+								return this.stub.onThirdCall();
+						},
+
+						withArgs: function withArgs(/* arguments */) {
+								throw new Error("Defining a stub by invoking \"stub.onCall(...).withArgs(...)\" is not supported. " +
+																"Use \"stub.withArgs(...).onCall(...)\" to define sequential behavior for calls with certain arguments.");
+						},
+
+						callsArg: function callsArg(pos) {
+								if (typeof pos != "number") {
+										throw new TypeError("argument index is not number");
+								}
+
+								this.callArgAt = pos;
+								this.callbackArguments = [];
+								this.callbackContext = undefined;
+								this.callArgProp = undefined;
+								this.callbackAsync = false;
+
+								return this;
+						},
+
+						callsArgOn: function callsArgOn(pos, context) {
+								if (typeof pos != "number") {
+										throw new TypeError("argument index is not number");
+								}
+								if (typeof context != "object") {
+										throw new TypeError("argument context is not an object");
+								}
+
+								this.callArgAt = pos;
+								this.callbackArguments = [];
+								this.callbackContext = context;
+								this.callArgProp = undefined;
+								this.callbackAsync = false;
+
+								return this;
+						},
+
+						callsArgWith: function callsArgWith(pos) {
+								if (typeof pos != "number") {
+										throw new TypeError("argument index is not number");
+								}
+
+								this.callArgAt = pos;
+								this.callbackArguments = slice.call(arguments, 1);
+								this.callbackContext = undefined;
+								this.callArgProp = undefined;
+								this.callbackAsync = false;
+
+								return this;
+						},
+
+						callsArgOnWith: function callsArgWith(pos, context) {
+								if (typeof pos != "number") {
+										throw new TypeError("argument index is not number");
+								}
+								if (typeof context != "object") {
+										throw new TypeError("argument context is not an object");
+								}
+
+								this.callArgAt = pos;
+								this.callbackArguments = slice.call(arguments, 2);
+								this.callbackContext = context;
+								this.callArgProp = undefined;
+								this.callbackAsync = false;
+
+								return this;
+						},
+
+						yields: function () {
+								this.callArgAt = useLeftMostCallback;
+								this.callbackArguments = slice.call(arguments, 0);
+								this.callbackContext = undefined;
+								this.callArgProp = undefined;
+								this.callbackAsync = false;
+
+								return this;
+						},
+
+						yieldsRight: function () {
+								this.callArgAt = useRightMostCallback;
+								this.callbackArguments = slice.call(arguments, 0);
+								this.callbackContext = undefined;
+								this.callArgProp = undefined;
+								this.callbackAsync = false;
+
+								return this;
+						},
+
+						yieldsOn: function (context) {
+								if (typeof context != "object") {
+										throw new TypeError("argument context is not an object");
+								}
+
+								this.callArgAt = useLeftMostCallback;
+								this.callbackArguments = slice.call(arguments, 1);
+								this.callbackContext = context;
+								this.callArgProp = undefined;
+								this.callbackAsync = false;
+
+								return this;
+						},
+
+						yieldsTo: function (prop) {
+								this.callArgAt = useLeftMostCallback;
+								this.callbackArguments = slice.call(arguments, 1);
+								this.callbackContext = undefined;
+								this.callArgProp = prop;
+								this.callbackAsync = false;
+
+								return this;
+						},
+
+						yieldsToOn: function (prop, context) {
+								if (typeof context != "object") {
+										throw new TypeError("argument context is not an object");
+								}
+
+								this.callArgAt = useLeftMostCallback;
+								this.callbackArguments = slice.call(arguments, 2);
+								this.callbackContext = context;
+								this.callArgProp = prop;
+								this.callbackAsync = false;
+
+								return this;
+						},
+
+						throws: throwsException,
+						throwsException: throwsException,
+
+						returns: function returns(value) {
+								this.returnValue = value;
+								this.returnValueDefined = true;
+
+								return this;
+						},
+
+						returnsArg: function returnsArg(pos) {
+								if (typeof pos != "number") {
+										throw new TypeError("argument index is not number");
+								}
+
+								this.returnArgAt = pos;
+
+								return this;
+						},
+
+						returnsThis: function returnsThis() {
+								this.returnThis = true;
+
+								return this;
+						}
+				};
+
+				// create asynchronous versions of callsArg* and yields* methods
+				for (var method in proto) {
+						// need to avoid creating anotherasync versions of the newly added async methods
+						if (proto.hasOwnProperty(method) &&
+								method.match(/^(callsArg|yields)/) &&
+								!method.match(/Async/)) {
+								proto[method + "Async"] = (function (syncFnName) {
+										return function () {
+												var result = this[syncFnName].apply(this, arguments);
+												this.callbackAsync = true;
+												return result;
+										};
+								})(method);
+						}
+				}
+
+				sinon.behavior = proto;
+				return proto;
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./util/core");
+				require("./extend");
+				module.exports = makeApi(sinon);
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (!sinon) {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend util/core.js
+ * @depend extend.js
+ * @depend spy.js
+ * @depend behavior.js
+ */
+/**
+ * Stub functions
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+
+(function (sinon) {
+		function makeApi(sinon) {
+				function stub(object, property, func) {
+						if (!!func && typeof func != "function" && typeof func != "object") {
+								throw new TypeError("Custom stub should be a function or a property descriptor");
+						}
+
+						var wrapper;
+
+						if (func) {
+								if (typeof func == "function") {
+										wrapper = sinon.spy && sinon.spy.create ? sinon.spy.create(func) : func;
+								} else {
+										wrapper = func;
+										if (sinon.spy && sinon.spy.create) {
+												var types = sinon.objectKeys(wrapper);
+												for (var i = 0; i < types.length; i++) {
+														wrapper[types[i]] = sinon.spy.create(wrapper[types[i]]);
+												}
+										}
+								}
+						} else {
+								var stubLength = 0;
+								if (typeof object == "object" && typeof object[property] == "function") {
+										stubLength = object[property].length;
+								}
+								wrapper = stub.create(stubLength);
+						}
+
+						if (!object && typeof property === "undefined") {
+								return sinon.stub.create();
+						}
+
+						if (typeof property === "undefined" && typeof object == "object") {
+								for (var prop in object) {
+										if (typeof object[prop] === "function") {
+												stub(object, prop);
+										}
+								}
+
+								return object;
+						}
+
+						return sinon.wrapMethod(object, property, wrapper);
+				}
+
+				function getDefaultBehavior(stub) {
+						return stub.defaultBehavior || getParentBehaviour(stub) || sinon.behavior.create(stub);
+				}
+
+				function getParentBehaviour(stub) {
+						return (stub.parent && getCurrentBehavior(stub.parent));
+				}
+
+				function getCurrentBehavior(stub) {
+						var behavior = stub.behaviors[stub.callCount - 1];
+						return behavior && behavior.isPresent() ? behavior : getDefaultBehavior(stub);
+				}
+
+				var uuid = 0;
+
+				var proto = {
+						create: function create(stubLength) {
+								var functionStub = function () {
+										return getCurrentBehavior(functionStub).invoke(this, arguments);
+								};
+
+								functionStub.id = "stub#" + uuid++;
+								var orig = functionStub;
+								functionStub = sinon.spy.create(functionStub, stubLength);
+								functionStub.func = orig;
+
+								sinon.extend(functionStub, stub);
+								functionStub.instantiateFake = sinon.stub.create;
+								functionStub.displayName = "stub";
+								functionStub.toString = sinon.functionToString;
+
+								functionStub.defaultBehavior = null;
+								functionStub.behaviors = [];
+
+								return functionStub;
+						},
+
+						resetBehavior: function () {
+								var i;
+
+								this.defaultBehavior = null;
+								this.behaviors = [];
+
+								delete this.returnValue;
+								delete this.returnArgAt;
+								this.returnThis = false;
+
+								if (this.fakes) {
+										for (i = 0; i < this.fakes.length; i++) {
+												this.fakes[i].resetBehavior();
+										}
+								}
+						},
+
+						onCall: function onCall(index) {
+								if (!this.behaviors[index]) {
+										this.behaviors[index] = sinon.behavior.create(this);
+								}
+
+								return this.behaviors[index];
+						},
+
+						onFirstCall: function onFirstCall() {
+								return this.onCall(0);
+						},
+
+						onSecondCall: function onSecondCall() {
+								return this.onCall(1);
+						},
+
+						onThirdCall: function onThirdCall() {
+								return this.onCall(2);
+						}
+				};
+
+				for (var method in sinon.behavior) {
+						if (sinon.behavior.hasOwnProperty(method) &&
+								!proto.hasOwnProperty(method) &&
+								method != "create" &&
+								method != "withArgs" &&
+								method != "invoke") {
+								proto[method] = (function (behaviorMethod) {
+										return function () {
+												this.defaultBehavior = this.defaultBehavior || sinon.behavior.create(this);
+												this.defaultBehavior[behaviorMethod].apply(this.defaultBehavior, arguments);
+												return this;
+										};
+								}(method));
+						}
+				}
+
+				sinon.extend(stub, proto);
+				sinon.stub = stub;
+
+				return stub;
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./util/core");
+				require("./behavior");
+				require("./spy");
+				require("./extend");
+				module.exports = makeApi(sinon);
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (!sinon) {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend times_in_words.js
+ * @depend util/core.js
+ * @depend call.js
+ * @depend extend.js
+ * @depend match.js
+ * @depend spy.js
+ * @depend stub.js
+ * @depend format.js
+ */
+/**
+ * Mock functions.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+
+(function (sinon) {
+		function makeApi(sinon) {
+				var push = [].push;
+				var match = sinon.match;
+
+				function mock(object) {
+						if (!object) {
+								return sinon.expectation.create("Anonymous mock");
+						}
+
+						return mock.create(object);
+				}
+
+				function each(collection, callback) {
+						if (!collection) {
+								return;
+						}
+
+						for (var i = 0, l = collection.length; i < l; i += 1) {
+								callback(collection[i]);
+						}
+				}
+
+				sinon.extend(mock, {
+						create: function create(object) {
+								if (!object) {
+										throw new TypeError("object is null");
+								}
+
+								var mockObject = sinon.extend({}, mock);
+								mockObject.object = object;
+								delete mockObject.create;
+
+								return mockObject;
+						},
+
+						expects: function expects(method) {
+								if (!method) {
+										throw new TypeError("method is falsy");
+								}
+
+								if (!this.expectations) {
+										this.expectations = {};
+										this.proxies = [];
+								}
+
+								if (!this.expectations[method]) {
+										this.expectations[method] = [];
+										var mockObject = this;
+
+										sinon.wrapMethod(this.object, method, function () {
+												return mockObject.invokeMethod(method, this, arguments);
+										});
+
+										push.call(this.proxies, method);
+								}
+
+								var expectation = sinon.expectation.create(method);
+								push.call(this.expectations[method], expectation);
+
+								return expectation;
+						},
+
+						restore: function restore() {
+								var object = this.object;
+
+								each(this.proxies, function (proxy) {
+										if (typeof object[proxy].restore == "function") {
+												object[proxy].restore();
+										}
+								});
+						},
+
+						verify: function verify() {
+								var expectations = this.expectations || {};
+								var messages = [], met = [];
+
+								each(this.proxies, function (proxy) {
+										each(expectations[proxy], function (expectation) {
+												if (!expectation.met()) {
+														push.call(messages, expectation.toString());
+												} else {
+														push.call(met, expectation.toString());
+												}
+										});
+								});
+
+								this.restore();
+
+								if (messages.length > 0) {
+										sinon.expectation.fail(messages.concat(met).join("\n"));
+								} else if (met.length > 0) {
+										sinon.expectation.pass(messages.concat(met).join("\n"));
+								}
+
+								return true;
+						},
+
+						invokeMethod: function invokeMethod(method, thisValue, args) {
+								var expectations = this.expectations && this.expectations[method];
+								var length = expectations && expectations.length || 0, i;
+
+								for (i = 0; i < length; i += 1) {
+										if (!expectations[i].met() &&
+												expectations[i].allowsCall(thisValue, args)) {
+												return expectations[i].apply(thisValue, args);
+										}
+								}
+
+								var messages = [], available, exhausted = 0;
+
+								for (i = 0; i < length; i += 1) {
+										if (expectations[i].allowsCall(thisValue, args)) {
+												available = available || expectations[i];
+										} else {
+												exhausted += 1;
+										}
+										push.call(messages, "    " + expectations[i].toString());
+								}
+
+								if (exhausted === 0) {
+										return available.apply(thisValue, args);
+								}
+
+								messages.unshift("Unexpected call: " + sinon.spyCall.toString.call({
+										proxy: method,
+										args: args
+								}));
+
+								sinon.expectation.fail(messages.join("\n"));
+						}
+				});
+
+				var times = sinon.timesInWords;
+				var slice = Array.prototype.slice;
+
+				function callCountInWords(callCount) {
+						if (callCount == 0) {
+								return "never called";
+						} else {
+								return "called " + times(callCount);
+						}
+				}
+
+				function expectedCallCountInWords(expectation) {
+						var min = expectation.minCalls;
+						var max = expectation.maxCalls;
+
+						if (typeof min == "number" && typeof max == "number") {
+								var str = times(min);
+
+								if (min != max) {
+										str = "at least " + str + " and at most " + times(max);
+								}
+
+								return str;
+						}
+
+						if (typeof min == "number") {
+								return "at least " + times(min);
+						}
+
+						return "at most " + times(max);
+				}
+
+				function receivedMinCalls(expectation) {
+						var hasMinLimit = typeof expectation.minCalls == "number";
+						return !hasMinLimit || expectation.callCount >= expectation.minCalls;
+				}
+
+				function receivedMaxCalls(expectation) {
+						if (typeof expectation.maxCalls != "number") {
+								return false;
+						}
+
+						return expectation.callCount == expectation.maxCalls;
+				}
+
+				function verifyMatcher(possibleMatcher, arg) {
+						if (match && match.isMatcher(possibleMatcher)) {
+								return possibleMatcher.test(arg);
+						} else {
+								return true;
+						}
+				}
+
+				sinon.expectation = {
+						minCalls: 1,
+						maxCalls: 1,
+
+						create: function create(methodName) {
+								var expectation = sinon.extend(sinon.stub.create(), sinon.expectation);
+								delete expectation.create;
+								expectation.method = methodName;
+
+								return expectation;
+						},
+
+						invoke: function invoke(func, thisValue, args) {
+								this.verifyCallAllowed(thisValue, args);
+
+								return sinon.spy.invoke.apply(this, arguments);
+						},
+
+						atLeast: function atLeast(num) {
+								if (typeof num != "number") {
+										throw new TypeError("'" + num + "' is not number");
+								}
+
+								if (!this.limitsSet) {
+										this.maxCalls = null;
+										this.limitsSet = true;
+								}
+
+								this.minCalls = num;
+
+								return this;
+						},
+
+						atMost: function atMost(num) {
+								if (typeof num != "number") {
+										throw new TypeError("'" + num + "' is not number");
+								}
+
+								if (!this.limitsSet) {
+										this.minCalls = null;
+										this.limitsSet = true;
+								}
+
+								this.maxCalls = num;
+
+								return this;
+						},
+
+						never: function never() {
+								return this.exactly(0);
+						},
+
+						once: function once() {
+								return this.exactly(1);
+						},
+
+						twice: function twice() {
+								return this.exactly(2);
+						},
+
+						thrice: function thrice() {
+								return this.exactly(3);
+						},
+
+						exactly: function exactly(num) {
+								if (typeof num != "number") {
+										throw new TypeError("'" + num + "' is not a number");
+								}
+
+								this.atLeast(num);
+								return this.atMost(num);
+						},
+
+						met: function met() {
+								return !this.failed && receivedMinCalls(this);
+						},
+
+						verifyCallAllowed: function verifyCallAllowed(thisValue, args) {
+								if (receivedMaxCalls(this)) {
+										this.failed = true;
+										sinon.expectation.fail(this.method + " already called " + times(this.maxCalls));
+								}
+
+								if ("expectedThis" in this && this.expectedThis !== thisValue) {
+										sinon.expectation.fail(this.method + " called with " + thisValue + " as thisValue, expected " +
+												this.expectedThis);
+								}
+
+								if (!("expectedArguments" in this)) {
+										return;
+								}
+
+								if (!args) {
+										sinon.expectation.fail(this.method + " received no arguments, expected " +
+												sinon.format(this.expectedArguments));
+								}
+
+								if (args.length < this.expectedArguments.length) {
+										sinon.expectation.fail(this.method + " received too few arguments (" + sinon.format(args) +
+												"), expected " + sinon.format(this.expectedArguments));
+								}
+
+								if (this.expectsExactArgCount &&
+										args.length != this.expectedArguments.length) {
+										sinon.expectation.fail(this.method + " received too many arguments (" + sinon.format(args) +
+												"), expected " + sinon.format(this.expectedArguments));
+								}
+
+								for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {
+
+										if (!verifyMatcher(this.expectedArguments[i], args[i])) {
+												sinon.expectation.fail(this.method + " received wrong arguments " + sinon.format(args) +
+														", didn't match " + this.expectedArguments.toString());
+										}
+
+										if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {
+												sinon.expectation.fail(this.method + " received wrong arguments " + sinon.format(args) +
+														", expected " + sinon.format(this.expectedArguments));
+										}
+								}
+						},
+
+						allowsCall: function allowsCall(thisValue, args) {
+								if (this.met() && receivedMaxCalls(this)) {
+										return false;
+								}
+
+								if ("expectedThis" in this && this.expectedThis !== thisValue) {
+										return false;
+								}
+
+								if (!("expectedArguments" in this)) {
+										return true;
+								}
+
+								args = args || [];
+
+								if (args.length < this.expectedArguments.length) {
+										return false;
+								}
+
+								if (this.expectsExactArgCount &&
+										args.length != this.expectedArguments.length) {
+										return false;
+								}
+
+								for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {
+										if (!verifyMatcher(this.expectedArguments[i], args[i])) {
+												return false;
+										}
+
+										if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {
+												return false;
+										}
+								}
+
+								return true;
+						},
+
+						withArgs: function withArgs() {
+								this.expectedArguments = slice.call(arguments);
+								return this;
+						},
+
+						withExactArgs: function withExactArgs() {
+								this.withArgs.apply(this, arguments);
+								this.expectsExactArgCount = true;
+								return this;
+						},
+
+						on: function on(thisValue) {
+								this.expectedThis = thisValue;
+								return this;
+						},
+
+						toString: function () {
+								var args = (this.expectedArguments || []).slice();
+
+								if (!this.expectsExactArgCount) {
+										push.call(args, "[...]");
+								}
+
+								var callStr = sinon.spyCall.toString.call({
+										proxy: this.method || "anonymous mock expectation",
+										args: args
+								});
+
+								var message = callStr.replace(", [...", "[, ...") + " " +
+										expectedCallCountInWords(this);
+
+								if (this.met()) {
+										return "Expectation met: " + message;
+								}
+
+								return "Expected " + message + " (" +
+										callCountInWords(this.callCount) + ")";
+						},
+
+						verify: function verify() {
+								if (!this.met()) {
+										sinon.expectation.fail(this.toString());
+								} else {
+										sinon.expectation.pass(this.toString());
+								}
+
+								return true;
+						},
+
+						pass: function pass(message) {
+								sinon.assert.pass(message);
+						},
+
+						fail: function fail(message) {
+								var exception = new Error(message);
+								exception.name = "ExpectationError";
+
+								throw exception;
+						}
+				};
+
+				sinon.mock = mock;
+				return mock;
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./util/core");
+				require("./times_in_words");
+				require("./call");
+				require("./extend");
+				require("./match");
+				require("./spy");
+				require("./stub");
+				require("./format");
+
+				module.exports = makeApi(sinon);
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (!sinon) {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend util/core.js
+ * @depend spy.js
+ * @depend stub.js
+ * @depend mock.js
+ */
+/**
+ * Collections of stubs, spies and mocks.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+
+(function (sinon) {
+		var push = [].push;
+		var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+		function getFakes(fakeCollection) {
+				if (!fakeCollection.fakes) {
+						fakeCollection.fakes = [];
+				}
+
+				return fakeCollection.fakes;
+		}
+
+		function each(fakeCollection, method) {
+				var fakes = getFakes(fakeCollection);
+
+				for (var i = 0, l = fakes.length; i < l; i += 1) {
+						if (typeof fakes[i][method] == "function") {
+								fakes[i][method]();
+						}
+				}
+		}
+
+		function compact(fakeCollection) {
+				var fakes = getFakes(fakeCollection);
+				var i = 0;
+				while (i < fakes.length) {
+						fakes.splice(i, 1);
+				}
+		}
+
+		function makeApi(sinon) {
+				var collection = {
+						verify: function resolve() {
+								each(this, "verify");
+						},
+
+						restore: function restore() {
+								each(this, "restore");
+								compact(this);
+						},
+
+						reset: function restore() {
+								each(this, "reset");
+						},
+
+						verifyAndRestore: function verifyAndRestore() {
+								var exception;
+
+								try {
+										this.verify();
+								} catch (e) {
+										exception = e;
+								}
+
+								this.restore();
+
+								if (exception) {
+										throw exception;
+								}
+						},
+
+						add: function add(fake) {
+								push.call(getFakes(this), fake);
+								return fake;
+						},
+
+						spy: function spy() {
+								return this.add(sinon.spy.apply(sinon, arguments));
+						},
+
+						stub: function stub(object, property, value) {
+								if (property) {
+										var original = object[property];
+
+										if (typeof original != "function") {
+												if (!hasOwnProperty.call(object, property)) {
+														throw new TypeError("Cannot stub non-existent own property " + property);
+												}
+
+												object[property] = value;
+
+												return this.add({
+														restore: function () {
+																object[property] = original;
+														}
+												});
+										}
+								}
+								if (!property && !!object && typeof object == "object") {
+										var stubbedObj = sinon.stub.apply(sinon, arguments);
+
+										for (var prop in stubbedObj) {
+												if (typeof stubbedObj[prop] === "function") {
+														this.add(stubbedObj[prop]);
+												}
+										}
+
+										return stubbedObj;
+								}
+
+								return this.add(sinon.stub.apply(sinon, arguments));
+						},
+
+						mock: function mock() {
+								return this.add(sinon.mock.apply(sinon, arguments));
+						},
+
+						inject: function inject(obj) {
+								var col = this;
+
+								obj.spy = function () {
+										return col.spy.apply(col, arguments);
+								};
+
+								obj.stub = function () {
+										return col.stub.apply(col, arguments);
+								};
+
+								obj.mock = function () {
+										return col.mock.apply(col, arguments);
+								};
+
+								return obj;
+						}
+				};
+
+				sinon.collection = collection;
+				return collection;
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./util/core");
+				require("./mock");
+				require("./spy");
+				require("./stub");
+				module.exports = makeApi(sinon);
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (!sinon) {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+}(typeof sinon == "object" && sinon || null));
+
+/*global lolex */
+
+/**
+ * Fake timer API
+ * setTimeout
+ * setInterval
+ * clearTimeout
+ * clearInterval
+ * tick
+ * reset
+ * Date
+ *
+ * Inspired by jsUnitMockTimeOut from JsUnit
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+
+if (typeof sinon == "undefined") {
+		var sinon = {};
+}
+
+(function (global) {
+		function makeApi(sinon, lol) {
+				var llx = typeof lolex !== "undefined" ? lolex : lol;
+
+				sinon.useFakeTimers = function () {
+						var now, methods = Array.prototype.slice.call(arguments);
+
+						if (typeof methods[0] === "string") {
+								now = 0;
+						} else {
+								now = methods.shift();
+						}
+
+						var clock = llx.install(now || 0, methods);
+						clock.restore = clock.uninstall;
+						return clock;
+				};
+
+				sinon.clock = {
+						create: function (now) {
+								return llx.createClock(now);
+						}
+				};
+
+				sinon.timers = {
+						setTimeout: setTimeout,
+						clearTimeout: clearTimeout,
+						setImmediate: (typeof setImmediate !== "undefined" ? setImmediate : undefined),
+						clearImmediate: (typeof clearImmediate !== "undefined" ? clearImmediate : undefined),
+						setInterval: setInterval,
+						clearInterval: clearInterval,
+						Date: Date
+				};
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, epxorts, module, lolex) {
+				var sinon = require("./core");
+				makeApi(sinon, lolex);
+				module.exports = sinon;
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module, require("lolex"));
+		} else {
+				makeApi(sinon);
+		}
+}(typeof global != "undefined" && typeof global !== "function" ? global : this));
+
+/**
+ * Minimal Event interface implementation
+ *
+ * Original implementation by Sven Fuchs: https://gist.github.com/995028
+ * Modifications and tests by Christian Johansen.
+ *
+ * @author Sven Fuchs (svenfuchs@artweb-design.de)
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2011 Sven Fuchs, Christian Johansen
+ */
+
+if (typeof sinon == "undefined") {
+		this.sinon = {};
+}
+
+(function () {
+		var push = [].push;
+
+		function makeApi(sinon) {
+				sinon.Event = function Event(type, bubbles, cancelable, target) {
+						this.initEvent(type, bubbles, cancelable, target);
+				};
+
+				sinon.Event.prototype = {
+						initEvent: function (type, bubbles, cancelable, target) {
+								this.type = type;
+								this.bubbles = bubbles;
+								this.cancelable = cancelable;
+								this.target = target;
+						},
+
+						stopPropagation: function () {},
+
+						preventDefault: function () {
+								this.defaultPrevented = true;
+						}
+				};
+
+				sinon.ProgressEvent = function ProgressEvent(type, progressEventRaw, target) {
+						this.initEvent(type, false, false, target);
+						this.loaded = progressEventRaw.loaded || null;
+						this.total = progressEventRaw.total || null;
+						this.lengthComputable = !!progressEventRaw.total;
+				};
+
+				sinon.ProgressEvent.prototype = new sinon.Event();
+
+				sinon.ProgressEvent.prototype.constructor =  sinon.ProgressEvent;
+
+				sinon.CustomEvent = function CustomEvent(type, customData, target) {
+						this.initEvent(type, false, false, target);
+						this.detail = customData.detail || null;
+				};
+
+				sinon.CustomEvent.prototype = new sinon.Event();
+
+				sinon.CustomEvent.prototype.constructor =  sinon.CustomEvent;
+
+				sinon.EventTarget = {
+						addEventListener: function addEventListener(event, listener) {
+								this.eventListeners = this.eventListeners || {};
+								this.eventListeners[event] = this.eventListeners[event] || [];
+								push.call(this.eventListeners[event], listener);
+						},
+
+						removeEventListener: function removeEventListener(event, listener) {
+								var listeners = this.eventListeners && this.eventListeners[event] || [];
+
+								for (var i = 0, l = listeners.length; i < l; ++i) {
+										if (listeners[i] == listener) {
+												return listeners.splice(i, 1);
+										}
+								}
+						},
+
+						dispatchEvent: function dispatchEvent(event) {
+								var type = event.type;
+								var listeners = this.eventListeners && this.eventListeners[type] || [];
+
+								for (var i = 0; i < listeners.length; i++) {
+										if (typeof listeners[i] == "function") {
+												listeners[i].call(this, event);
+										} else {
+												listeners[i].handleEvent(event);
+										}
+								}
+
+								return !!event.defaultPrevented;
+						}
+				};
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require) {
+				var sinon = require("./core");
+				makeApi(sinon);
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require);
+		} else {
+				makeApi(sinon);
+		}
+}());
+
+/**
+ * @depend util/core.js
+ */
+/**
+ * Logs errors
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2014 Christian Johansen
+ */
+
+(function (sinon) {
+		// cache a reference to setTimeout, so that our reference won't be stubbed out
+		// when using fake timers and errors will still get logged
+		// https://github.com/cjohansen/Sinon.JS/issues/381
+		var realSetTimeout = setTimeout;
+
+		function makeApi(sinon) {
+
+				function log() {}
+
+				function logError(label, err) {
+						var msg = label + " threw exception: ";
+
+						sinon.log(msg + "[" + err.name + "] " + err.message);
+
+						if (err.stack) {
+								sinon.log(err.stack);
+						}
+
+						logError.setTimeout(function () {
+								err.message = msg + err.message;
+								throw err;
+						}, 0);
+				};
+
+				// wrap realSetTimeout with something we can stub in tests
+				logError.setTimeout = function (func, timeout) {
+						realSetTimeout(func, timeout);
+				}
+
+				var exports = {};
+				exports.log = sinon.log = log;
+				exports.logError = sinon.logError = logError;
+
+				return exports;
+		}
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./util/core");
+				module.exports = makeApi(sinon);
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (!sinon) {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend core.js
+ * @depend ../extend.js
+ * @depend event.js
+ * @depend ../log_error.js
+ */
+/**
+ * Fake XDomainRequest object
+ */
+
+if (typeof sinon == "undefined") {
+		this.sinon = {};
+}
+
+// wrapper for global
+(function (global) {
+		var xdr = { XDomainRequest: global.XDomainRequest };
+		xdr.GlobalXDomainRequest = global.XDomainRequest;
+		xdr.supportsXDR = typeof xdr.GlobalXDomainRequest != "undefined";
+		xdr.workingXDR = xdr.supportsXDR ? xdr.GlobalXDomainRequest :  false;
+
+		function makeApi(sinon) {
+				sinon.xdr = xdr;
+
+				function FakeXDomainRequest() {
+						this.readyState = FakeXDomainRequest.UNSENT;
+						this.requestBody = null;
+						this.requestHeaders = {};
+						this.status = 0;
+						this.timeout = null;
+
+						if (typeof FakeXDomainRequest.onCreate == "function") {
+								FakeXDomainRequest.onCreate(this);
+						}
+				}
+
+				function verifyState(xdr) {
+						if (xdr.readyState !== FakeXDomainRequest.OPENED) {
+								throw new Error("INVALID_STATE_ERR");
+						}
+
+						if (xdr.sendFlag) {
+								throw new Error("INVALID_STATE_ERR");
+						}
+				}
+
+				function verifyRequestSent(xdr) {
+						if (xdr.readyState == FakeXDomainRequest.UNSENT) {
+								throw new Error("Request not sent");
+						}
+						if (xdr.readyState == FakeXDomainRequest.DONE) {
+								throw new Error("Request done");
+						}
+				}
+
+				function verifyResponseBodyType(body) {
+						if (typeof body != "string") {
+								var error = new Error("Attempted to respond to fake XDomainRequest with " +
+																		body + ", which is not a string.");
+								error.name = "InvalidBodyException";
+								throw error;
+						}
+				}
+
+				sinon.extend(FakeXDomainRequest.prototype, sinon.EventTarget, {
+						open: function open(method, url) {
+								this.method = method;
+								this.url = url;
+
+								this.responseText = null;
+								this.sendFlag = false;
+
+								this.readyStateChange(FakeXDomainRequest.OPENED);
+						},
+
+						readyStateChange: function readyStateChange(state) {
+								this.readyState = state;
+								var eventName = "";
+								switch (this.readyState) {
+								case FakeXDomainRequest.UNSENT:
+										break;
+								case FakeXDomainRequest.OPENED:
+										break;
+								case FakeXDomainRequest.LOADING:
+										if (this.sendFlag) {
+												//raise the progress event
+												eventName = "onprogress";
+										}
+										break;
+								case FakeXDomainRequest.DONE:
+										if (this.isTimeout) {
+												eventName = "ontimeout"
+										} else if (this.errorFlag || (this.status < 200 || this.status > 299)) {
+												eventName = "onerror";
+										} else {
+												eventName = "onload"
+										}
+										break;
+								}
+
+								// raising event (if defined)
+								if (eventName) {
+										if (typeof this[eventName] == "function") {
+												try {
+														this[eventName]();
+												} catch (e) {
+														sinon.logError("Fake XHR " + eventName + " handler", e);
+												}
+										}
+								}
+						},
+
+						send: function send(data) {
+								verifyState(this);
+
+								if (!/^(get|head)$/i.test(this.method)) {
+										this.requestBody = data;
+								}
+								this.requestHeaders["Content-Type"] = "text/plain;charset=utf-8";
+
+								this.errorFlag = false;
+								this.sendFlag = true;
+								this.readyStateChange(FakeXDomainRequest.OPENED);
+
+								if (typeof this.onSend == "function") {
+										this.onSend(this);
+								}
+						},
+
+						abort: function abort() {
+								this.aborted = true;
+								this.responseText = null;
+								this.errorFlag = true;
+
+								if (this.readyState > sinon.FakeXDomainRequest.UNSENT && this.sendFlag) {
+										this.readyStateChange(sinon.FakeXDomainRequest.DONE);
+										this.sendFlag = false;
+								}
+						},
+
+						setResponseBody: function setResponseBody(body) {
+								verifyRequestSent(this);
+								verifyResponseBodyType(body);
+
+								var chunkSize = this.chunkSize || 10;
+								var index = 0;
+								this.responseText = "";
+
+								do {
+										this.readyStateChange(FakeXDomainRequest.LOADING);
+										this.responseText += body.substring(index, index + chunkSize);
+										index += chunkSize;
+								} while (index < body.length);
+
+								this.readyStateChange(FakeXDomainRequest.DONE);
+						},
+
+						respond: function respond(status, contentType, body) {
+								// content-type ignored, since XDomainRequest does not carry this
+								// we keep the same syntax for respond(...) as for FakeXMLHttpRequest to ease
+								// test integration across browsers
+								this.status = typeof status == "number" ? status : 200;
+								this.setResponseBody(body || "");
+						},
+
+						simulatetimeout: function simulatetimeout() {
+								this.status = 0;
+								this.isTimeout = true;
+								// Access to this should actually throw an error
+								this.responseText = undefined;
+								this.readyStateChange(FakeXDomainRequest.DONE);
+						}
+				});
+
+				sinon.extend(FakeXDomainRequest, {
+						UNSENT: 0,
+						OPENED: 1,
+						LOADING: 3,
+						DONE: 4
+				});
+
+				sinon.useFakeXDomainRequest = function useFakeXDomainRequest() {
+						sinon.FakeXDomainRequest.restore = function restore(keepOnCreate) {
+								if (xdr.supportsXDR) {
+										global.XDomainRequest = xdr.GlobalXDomainRequest;
+								}
+
+								delete sinon.FakeXDomainRequest.restore;
+
+								if (keepOnCreate !== true) {
+										delete sinon.FakeXDomainRequest.onCreate;
+								}
+						};
+						if (xdr.supportsXDR) {
+								global.XDomainRequest = sinon.FakeXDomainRequest;
+						}
+						return sinon.FakeXDomainRequest;
+				};
+
+				sinon.FakeXDomainRequest = FakeXDomainRequest;
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./core");
+				require("../extend");
+				require("./event");
+				require("../log_error");
+				makeApi(sinon);
+				module.exports = sinon;
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else {
+				makeApi(sinon);
+		}
+})(this);
+
+/**
+ * @depend core.js
+ * @depend ../extend.js
+ * @depend event.js
+ * @depend ../log_error.js
+ */
+/**
+ * Fake XMLHttpRequest object
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+
+(function (global) {
+
+		var supportsProgress = typeof ProgressEvent !== "undefined";
+		var supportsCustomEvent = typeof CustomEvent !== "undefined";
+		var sinonXhr = { XMLHttpRequest: global.XMLHttpRequest };
+		sinonXhr.GlobalXMLHttpRequest = global.XMLHttpRequest;
+		sinonXhr.GlobalActiveXObject = global.ActiveXObject;
+		sinonXhr.supportsActiveX = typeof sinonXhr.GlobalActiveXObject != "undefined";
+		sinonXhr.supportsXHR = typeof sinonXhr.GlobalXMLHttpRequest != "undefined";
+		sinonXhr.workingXHR = sinonXhr.supportsXHR ? sinonXhr.GlobalXMLHttpRequest : sinonXhr.supportsActiveX
+																		 ? function () { return new sinonXhr.GlobalActiveXObject("MSXML2.XMLHTTP.3.0") } : false;
+		sinonXhr.supportsCORS = sinonXhr.supportsXHR && "withCredentials" in (new sinonXhr.GlobalXMLHttpRequest());
+
+		/*jsl:ignore*/
+		var unsafeHeaders = {
+				"Accept-Charset": true,
+				"Accept-Encoding": true,
+				Connection: true,
+				"Content-Length": true,
+				Cookie: true,
+				Cookie2: true,
+				"Content-Transfer-Encoding": true,
+				Date: true,
+				Expect: true,
+				Host: true,
+				"Keep-Alive": true,
+				Referer: true,
+				TE: true,
+				Trailer: true,
+				"Transfer-Encoding": true,
+				Upgrade: true,
+				"User-Agent": true,
+				Via: true
+		};
+		/*jsl:end*/
+
+		function FakeXMLHttpRequest() {
+				this.readyState = FakeXMLHttpRequest.UNSENT;
+				this.requestHeaders = {};
+				this.requestBody = null;
+				this.status = 0;
+				this.statusText = "";
+				this.upload = new UploadProgress();
+				if (sinonXhr.supportsCORS) {
+						this.withCredentials = false;
+				}
+
+				var xhr = this;
+				var events = ["loadstart", "load", "abort", "loadend"];
+
+				function addEventListener(eventName) {
+						xhr.addEventListener(eventName, function (event) {
+								var listener = xhr["on" + eventName];
+
+								if (listener && typeof listener == "function") {
+										listener.call(this, event);
+								}
+						});
+				}
+
+				for (var i = events.length - 1; i >= 0; i--) {
+						addEventListener(events[i]);
+				}
+
+				if (typeof FakeXMLHttpRequest.onCreate == "function") {
+						FakeXMLHttpRequest.onCreate(this);
+				}
+		}
+
+		// An upload object is created for each
+		// FakeXMLHttpRequest and allows upload
+		// events to be simulated using uploadProgress
+		// and uploadError.
+		function UploadProgress() {
+				this.eventListeners = {
+						progress: [],
+						load: [],
+						abort: [],
+						error: []
+				}
+		}
+
+		UploadProgress.prototype.addEventListener = function addEventListener(event, listener) {
+				this.eventListeners[event].push(listener);
+		};
+
+		UploadProgress.prototype.removeEventListener = function removeEventListener(event, listener) {
+				var listeners = this.eventListeners[event] || [];
+
+				for (var i = 0, l = listeners.length; i < l; ++i) {
+						if (listeners[i] == listener) {
+								return listeners.splice(i, 1);
+						}
+				}
+		};
+
+		UploadProgress.prototype.dispatchEvent = function dispatchEvent(event) {
+				var listeners = this.eventListeners[event.type] || [];
+
+				for (var i = 0, listener; (listener = listeners[i]) != null; i++) {
+						listener(event);
+				}
+		};
+
+		function verifyState(xhr) {
+				if (xhr.readyState !== FakeXMLHttpRequest.OPENED) {
+						throw new Error("INVALID_STATE_ERR");
+				}
+
+				if (xhr.sendFlag) {
+						throw new Error("INVALID_STATE_ERR");
+				}
+		}
+
+		function getHeader(headers, header) {
+				header = header.toLowerCase();
+
+				for (var h in headers) {
+						if (h.toLowerCase() == header) {
+								return h;
+						}
+				}
+
+				return null;
+		}
+
+		// filtering to enable a white-list version of Sinon FakeXhr,
+		// where whitelisted requests are passed through to real XHR
+		function each(collection, callback) {
+				if (!collection) {
+						return;
+				}
+
+				for (var i = 0, l = collection.length; i < l; i += 1) {
+						callback(collection[i]);
+				}
+		}
+		function some(collection, callback) {
+				for (var index = 0; index < collection.length; index++) {
+						if (callback(collection[index]) === true) {
+								return true;
+						}
+				}
+				return false;
+		}
+		// largest arity in XHR is 5 - XHR#open
+		var apply = function (obj, method, args) {
+				switch (args.length) {
+				case 0: return obj[method]();
+				case 1: return obj[method](args[0]);
+				case 2: return obj[method](args[0], args[1]);
+				case 3: return obj[method](args[0], args[1], args[2]);
+				case 4: return obj[method](args[0], args[1], args[2], args[3]);
+				case 5: return obj[method](args[0], args[1], args[2], args[3], args[4]);
+				}
+		};
+
+		FakeXMLHttpRequest.filters = [];
+		FakeXMLHttpRequest.addFilter = function addFilter(fn) {
+				this.filters.push(fn)
+		};
+		var IE6Re = /MSIE 6/;
+		FakeXMLHttpRequest.defake = function defake(fakeXhr, xhrArgs) {
+				var xhr = new sinonXhr.workingXHR();
+				each([
+						"open",
+						"setRequestHeader",
+						"send",
+						"abort",
+						"getResponseHeader",
+						"getAllResponseHeaders",
+						"addEventListener",
+						"overrideMimeType",
+						"removeEventListener"
+				], function (method) {
+						fakeXhr[method] = function () {
+								return apply(xhr, method, arguments);
+						};
+				});
+
+				var copyAttrs = function (args) {
+						each(args, function (attr) {
+								try {
+										fakeXhr[attr] = xhr[attr]
+								} catch (e) {
+										if (!IE6Re.test(navigator.userAgent)) {
+												throw e;
+										}
+								}
+						});
+				};
+
+				var stateChange = function stateChange() {
+						fakeXhr.readyState = xhr.readyState;
+						if (xhr.readyState >= FakeXMLHttpRequest.HEADERS_RECEIVED) {
+								copyAttrs(["status", "statusText"]);
+						}
+						if (xhr.readyState >= FakeXMLHttpRequest.LOADING) {
+								copyAttrs(["responseText", "response"]);
+						}
+						if (xhr.readyState === FakeXMLHttpRequest.DONE) {
+								copyAttrs(["responseXML"]);
+						}
+						if (fakeXhr.onreadystatechange) {
+								fakeXhr.onreadystatechange.call(fakeXhr, { target: fakeXhr });
+						}
+				};
+
+				if (xhr.addEventListener) {
+						for (var event in fakeXhr.eventListeners) {
+								if (fakeXhr.eventListeners.hasOwnProperty(event)) {
+										each(fakeXhr.eventListeners[event], function (handler) {
+												xhr.addEventListener(event, handler);
+										});
+								}
+						}
+						xhr.addEventListener("readystatechange", stateChange);
+				} else {
+						xhr.onreadystatechange = stateChange;
+				}
+				apply(xhr, "open", xhrArgs);
+		};
+		FakeXMLHttpRequest.useFilters = false;
+
+		function verifyRequestOpened(xhr) {
+				if (xhr.readyState != FakeXMLHttpRequest.OPENED) {
+						throw new Error("INVALID_STATE_ERR - " + xhr.readyState);
+				}
+		}
+
+		function verifyRequestSent(xhr) {
+				if (xhr.readyState == FakeXMLHttpRequest.DONE) {
+						throw new Error("Request done");
+				}
+		}
+
+		function verifyHeadersReceived(xhr) {
+				if (xhr.async && xhr.readyState != FakeXMLHttpRequest.HEADERS_RECEIVED) {
+						throw new Error("No headers received");
+				}
+		}
+
+		function verifyResponseBodyType(body) {
+				if (typeof body != "string") {
+						var error = new Error("Attempted to respond to fake XMLHttpRequest with " +
+																 body + ", which is not a string.");
+						error.name = "InvalidBodyException";
+						throw error;
+				}
+		}
+
+		FakeXMLHttpRequest.parseXML = function parseXML(text) {
+				var xmlDoc;
+
+				if (typeof DOMParser != "undefined") {
+						var parser = new DOMParser();
+						xmlDoc = parser.parseFromString(text, "text/xml");
+				} else {
+						xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
+						xmlDoc.async = "false";
+						xmlDoc.loadXML(text);
+				}
+
+				return xmlDoc;
+		};
+
+		FakeXMLHttpRequest.statusCodes = {
+				100: "Continue",
+				101: "Switching Protocols",
+				200: "OK",
+				201: "Created",
+				202: "Accepted",
+				203: "Non-Authoritative Information",
+				204: "No Content",
+				205: "Reset Content",
+				206: "Partial Content",
+				207: "Multi-Status",
+				300: "Multiple Choice",
+				301: "Moved Permanently",
+				302: "Found",
+				303: "See Other",
+				304: "Not Modified",
+				305: "Use Proxy",
+				307: "Temporary Redirect",
+				400: "Bad Request",
+				401: "Unauthorized",
+				402: "Payment Required",
+				403: "Forbidden",
+				404: "Not Found",
+				405: "Method Not Allowed",
+				406: "Not Acceptable",
+				407: "Proxy Authentication Required",
+				408: "Request Timeout",
+				409: "Conflict",
+				410: "Gone",
+				411: "Length Required",
+				412: "Precondition Failed",
+				413: "Request Entity Too Large",
+				414: "Request-URI Too Long",
+				415: "Unsupported Media Type",
+				416: "Requested Range Not Satisfiable",
+				417: "Expectation Failed",
+				422: "Unprocessable Entity",
+				500: "Internal Server Error",
+				501: "Not Implemented",
+				502: "Bad Gateway",
+				503: "Service Unavailable",
+				504: "Gateway Timeout",
+				505: "HTTP Version Not Supported"
+		};
+
+		function makeApi(sinon) {
+				sinon.xhr = sinonXhr;
+
+				sinon.extend(FakeXMLHttpRequest.prototype, sinon.EventTarget, {
+						async: true,
+
+						open: function open(method, url, async, username, password) {
+								this.method = method;
+								this.url = url;
+								this.async = typeof async == "boolean" ? async : true;
+								this.username = username;
+								this.password = password;
+								this.responseText = null;
+								this.responseXML = null;
+								this.requestHeaders = {};
+								this.sendFlag = false;
+
+								if (FakeXMLHttpRequest.useFilters === true) {
+										var xhrArgs = arguments;
+										var defake = some(FakeXMLHttpRequest.filters, function (filter) {
+												return filter.apply(this, xhrArgs)
+										});
+										if (defake) {
+												return FakeXMLHttpRequest.defake(this, arguments);
+										}
+								}
+								this.readyStateChange(FakeXMLHttpRequest.OPENED);
+						},
+
+						readyStateChange: function readyStateChange(state) {
+								this.readyState = state;
+
+								if (typeof this.onreadystatechange == "function") {
+										try {
+												this.onreadystatechange();
+										} catch (e) {
+												sinon.logError("Fake XHR onreadystatechange handler", e);
+										}
+								}
+
+								this.dispatchEvent(new sinon.Event("readystatechange"));
+
+								switch (this.readyState) {
+										case FakeXMLHttpRequest.DONE:
+												this.dispatchEvent(new sinon.Event("load", false, false, this));
+												this.dispatchEvent(new sinon.Event("loadend", false, false, this));
+												this.upload.dispatchEvent(new sinon.Event("load", false, false, this));
+												if (supportsProgress) {
+														this.upload.dispatchEvent(new sinon.ProgressEvent("progress", {loaded: 100, total: 100}));
+														this.dispatchEvent(new sinon.ProgressEvent("progress", {loaded: 100, total: 100}));
+												}
+												break;
+								}
+						},
+
+						setRequestHeader: function setRequestHeader(header, value) {
+								verifyState(this);
+
+								if (unsafeHeaders[header] || /^(Sec-|Proxy-)/.test(header)) {
+										throw new Error("Refused to set unsafe header \"" + header + "\"");
+								}
+
+								if (this.requestHeaders[header]) {
+										this.requestHeaders[header] += "," + value;
+								} else {
+										this.requestHeaders[header] = value;
+								}
+						},
+
+						// Helps testing
+						setResponseHeaders: function setResponseHeaders(headers) {
+								verifyRequestOpened(this);
+								this.responseHeaders = {};
+
+								for (var header in headers) {
+										if (headers.hasOwnProperty(header)) {
+												this.responseHeaders[header] = headers[header];
+										}
+								}
+
+								if (this.async) {
+										this.readyStateChange(FakeXMLHttpRequest.HEADERS_RECEIVED);
+								} else {
+										this.readyState = FakeXMLHttpRequest.HEADERS_RECEIVED;
+								}
+						},
+
+						// Currently treats ALL data as a DOMString (i.e. no Document)
+						send: function send(data) {
+								verifyState(this);
+
+								if (!/^(get|head)$/i.test(this.method)) {
+										var contentType = getHeader(this.requestHeaders, "Content-Type");
+										if (this.requestHeaders[contentType]) {
+												var value = this.requestHeaders[contentType].split(";");
+												this.requestHeaders[contentType] = value[0] + ";charset=utf-8";
+										} else if (!(data instanceof FormData)) {
+												this.requestHeaders["Content-Type"] = "text/plain;charset=utf-8";
+										}
+
+										this.requestBody = data;
+								}
+
+								this.errorFlag = false;
+								this.sendFlag = this.async;
+								this.readyStateChange(FakeXMLHttpRequest.OPENED);
+
+								if (typeof this.onSend == "function") {
+										this.onSend(this);
+								}
+
+								this.dispatchEvent(new sinon.Event("loadstart", false, false, this));
+						},
+
+						abort: function abort() {
+								this.aborted = true;
+								this.responseText = null;
+								this.errorFlag = true;
+								this.requestHeaders = {};
+
+								if (this.readyState > FakeXMLHttpRequest.UNSENT && this.sendFlag) {
+										this.readyStateChange(FakeXMLHttpRequest.DONE);
+										this.sendFlag = false;
+								}
+
+								this.readyState = FakeXMLHttpRequest.UNSENT;
+
+								this.dispatchEvent(new sinon.Event("abort", false, false, this));
+
+								this.upload.dispatchEvent(new sinon.Event("abort", false, false, this));
+
+								if (typeof this.onerror === "function") {
+										this.onerror();
+								}
+						},
+
+						getResponseHeader: function getResponseHeader(header) {
+								if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {
+										return null;
+								}
+
+								if (/^Set-Cookie2?$/i.test(header)) {
+										return null;
+								}
+
+								header = getHeader(this.responseHeaders, header);
+
+								return this.responseHeaders[header] || null;
+						},
+
+						getAllResponseHeaders: function getAllResponseHeaders() {
+								if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {
+										return "";
+								}
+
+								var headers = "";
+
+								for (var header in this.responseHeaders) {
+										if (this.responseHeaders.hasOwnProperty(header) &&
+												!/^Set-Cookie2?$/i.test(header)) {
+												headers += header + ": " + this.responseHeaders[header] + "\r\n";
+										}
+								}
+
+								return headers;
+						},
+
+						setResponseBody: function setResponseBody(body) {
+								verifyRequestSent(this);
+								verifyHeadersReceived(this);
+								verifyResponseBodyType(body);
+
+								var chunkSize = this.chunkSize || 10;
+								var index = 0;
+								this.responseText = "";
+
+								do {
+										if (this.async) {
+												this.readyStateChange(FakeXMLHttpRequest.LOADING);
+										}
+
+										this.responseText += body.substring(index, index + chunkSize);
+										index += chunkSize;
+								} while (index < body.length);
+
+								var type = this.getResponseHeader("Content-Type");
+
+								if (this.responseText &&
+										(!type || /(text\/xml)|(application\/xml)|(\+xml)/.test(type))) {
+										try {
+												this.responseXML = FakeXMLHttpRequest.parseXML(this.responseText);
+										} catch (e) {
+												// Unable to parse XML - no biggie
+										}
+								}
+
+								this.readyStateChange(FakeXMLHttpRequest.DONE);
+						},
+
+						respond: function respond(status, headers, body) {
+								this.status = typeof status == "number" ? status : 200;
+								this.statusText = FakeXMLHttpRequest.statusCodes[this.status];
+								this.setResponseHeaders(headers || {});
+								this.setResponseBody(body || "");
+						},
+
+						uploadProgress: function uploadProgress(progressEventRaw) {
+								if (supportsProgress) {
+										this.upload.dispatchEvent(new sinon.ProgressEvent("progress", progressEventRaw));
+								}
+						},
+
+						downloadProgress: function downloadProgress(progressEventRaw) {
+								if (supportsProgress) {
+										this.dispatchEvent(new sinon.ProgressEvent("progress", progressEventRaw));
+								}
+						},
+
+						uploadError: function uploadError(error) {
+								if (supportsCustomEvent) {
+										this.upload.dispatchEvent(new sinon.CustomEvent("error", {detail: error}));
+								}
+						}
+				});
+
+				sinon.extend(FakeXMLHttpRequest, {
+						UNSENT: 0,
+						OPENED: 1,
+						HEADERS_RECEIVED: 2,
+						LOADING: 3,
+						DONE: 4
+				});
+
+				sinon.useFakeXMLHttpRequest = function () {
+						FakeXMLHttpRequest.restore = function restore(keepOnCreate) {
+								if (sinonXhr.supportsXHR) {
+										global.XMLHttpRequest = sinonXhr.GlobalXMLHttpRequest;
+								}
+
+								if (sinonXhr.supportsActiveX) {
+										global.ActiveXObject = sinonXhr.GlobalActiveXObject;
+								}
+
+								delete FakeXMLHttpRequest.restore;
+
+								if (keepOnCreate !== true) {
+										delete FakeXMLHttpRequest.onCreate;
+								}
+						};
+						if (sinonXhr.supportsXHR) {
+								global.XMLHttpRequest = FakeXMLHttpRequest;
+						}
+
+						if (sinonXhr.supportsActiveX) {
+								global.ActiveXObject = function ActiveXObject(objId) {
+										if (objId == "Microsoft.XMLHTTP" || /^Msxml2\.XMLHTTP/i.test(objId)) {
+
+												return new FakeXMLHttpRequest();
+										}
+
+										return new sinonXhr.GlobalActiveXObject(objId);
+								};
+						}
+
+						return FakeXMLHttpRequest;
+				};
+
+				sinon.FakeXMLHttpRequest = FakeXMLHttpRequest;
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./core");
+				require("../extend");
+				require("./event");
+				require("../log_error");
+				makeApi(sinon);
+				module.exports = sinon;
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (typeof sinon === "undefined") {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+
+})(typeof global !== "undefined" ? global : this);
+
+/**
+ * @depend fake_xdomain_request.js
+ * @depend fake_xml_http_request.js
+ * @depend ../format.js
+ * @depend ../log_error.js
+ */
+/**
+ * The Sinon "server" mimics a web server that receives requests from
+ * sinon.FakeXMLHttpRequest and provides an API to respond to those requests,
+ * both synchronously and asynchronously. To respond synchronuously, canned
+ * answers have to be provided upfront.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+
+if (typeof sinon == "undefined") {
+		var sinon = {};
+}
+
+(function () {
+		var push = [].push;
+		function F() {}
+
+		function create(proto) {
+				F.prototype = proto;
+				return new F();
+		}
+
+		function responseArray(handler) {
+				var response = handler;
+
+				if (Object.prototype.toString.call(handler) != "[object Array]") {
+						response = [200, {}, handler];
+				}
+
+				if (typeof response[2] != "string") {
+						throw new TypeError("Fake server response body should be string, but was " +
+																typeof response[2]);
+				}
+
+				return response;
+		}
+
+		var wloc = typeof window !== "undefined" ? window.location : {};
+		var rCurrLoc = new RegExp("^" + wloc.protocol + "//" + wloc.host);
+
+		function matchOne(response, reqMethod, reqUrl) {
+				var rmeth = response.method;
+				var matchMethod = !rmeth || rmeth.toLowerCase() == reqMethod.toLowerCase();
+				var url = response.url;
+				var matchUrl = !url || url == reqUrl || (typeof url.test == "function" && url.test(reqUrl));
+
+				return matchMethod && matchUrl;
+		}
+
+		function match(response, request) {
+				var requestUrl = request.url;
+
+				if (!/^https?:\/\//.test(requestUrl) || rCurrLoc.test(requestUrl)) {
+						requestUrl = requestUrl.replace(rCurrLoc, "");
+				}
+
+				if (matchOne(response, this.getHTTPMethod(request), requestUrl)) {
+						if (typeof response.response == "function") {
+								var ru = response.url;
+								var args = [request].concat(ru && typeof ru.exec == "function" ? ru.exec(requestUrl).slice(1) : []);
+								return response.response.apply(response, args);
+						}
+
+						return true;
+				}
+
+				return false;
+		}
+
+		function makeApi(sinon) {
+				sinon.fakeServer = {
+						create: function () {
+								var server = create(this);
+								if (!sinon.xhr.supportsCORS) {
+										this.xhr = sinon.useFakeXDomainRequest();
+								} else {
+										this.xhr = sinon.useFakeXMLHttpRequest();
+								}
+								server.requests = [];
+
+								this.xhr.onCreate = function (xhrObj) {
+										server.addRequest(xhrObj);
+								};
+
+								return server;
+						},
+
+						addRequest: function addRequest(xhrObj) {
+								var server = this;
+								push.call(this.requests, xhrObj);
+
+								xhrObj.onSend = function () {
+										server.handleRequest(this);
+
+										if (server.respondImmediately) {
+												server.respond();
+										} else if (server.autoRespond && !server.responding) {
+												setTimeout(function () {
+														server.responding = false;
+														server.respond();
+												}, server.autoRespondAfter || 10);
+
+												server.responding = true;
+										}
+								};
+						},
+
+						getHTTPMethod: function getHTTPMethod(request) {
+								if (this.fakeHTTPMethods && /post/i.test(request.method)) {
+										var matches = (request.requestBody || "").match(/_method=([^\b;]+)/);
+										return !!matches ? matches[1] : request.method;
+								}
+
+								return request.method;
+						},
+
+						handleRequest: function handleRequest(xhr) {
+								if (xhr.async) {
+										if (!this.queue) {
+												this.queue = [];
+										}
+
+										push.call(this.queue, xhr);
+								} else {
+										this.processRequest(xhr);
+								}
+						},
+
+						log: function log(response, request) {
+								var str;
+
+								str =  "Request:\n"  + sinon.format(request)  + "\n\n";
+								str += "Response:\n" + sinon.format(response) + "\n\n";
+
+								sinon.log(str);
+						},
+
+						respondWith: function respondWith(method, url, body) {
+								if (arguments.length == 1 && typeof method != "function") {
+										this.response = responseArray(method);
+										return;
+								}
+
+								if (!this.responses) { this.responses = []; }
+
+								if (arguments.length == 1) {
+										body = method;
+										url = method = null;
+								}
+
+								if (arguments.length == 2) {
+										body = url;
+										url = method;
+										method = null;
+								}
+
+								push.call(this.responses, {
+										method: method,
+										url: url,
+										response: typeof body == "function" ? body : responseArray(body)
+								});
+						},
+
+						respond: function respond() {
+								if (arguments.length > 0) {
+										this.respondWith.apply(this, arguments);
+								}
+
+								var queue = this.queue || [];
+								var requests = queue.splice(0, queue.length);
+								var request;
+
+								while (request = requests.shift()) {
+										this.processRequest(request);
+								}
+						},
+
+						processRequest: function processRequest(request) {
+								try {
+										if (request.aborted) {
+												return;
+										}
+
+										var response = this.response || [404, {}, ""];
+
+										if (this.responses) {
+												for (var l = this.responses.length, i = l - 1; i >= 0; i--) {
+														if (match.call(this, this.responses[i], request)) {
+																response = this.responses[i].response;
+																break;
+														}
+												}
+										}
+
+										if (request.readyState != 4) {
+												this.log(response, request);
+
+												request.respond(response[0], response[1], response[2]);
+										}
+								} catch (e) {
+										sinon.logError("Fake server request processing", e);
+								}
+						},
+
+						restore: function restore() {
+								return this.xhr.restore && this.xhr.restore.apply(this.xhr, arguments);
+						}
+				};
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./core");
+				require("./fake_xdomain_request");
+				require("./fake_xml_http_request");
+				require("../format");
+				makeApi(sinon);
+				module.exports = sinon;
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else {
+				makeApi(sinon);
+		}
+}());
+
+/**
+ * @depend fake_server.js
+ * @depend fake_timers.js
+ */
+/**
+ * Add-on for sinon.fakeServer that automatically handles a fake timer along with
+ * the FakeXMLHttpRequest. The direct inspiration for this add-on is jQuery
+ * 1.3.x, which does not use xhr object's onreadystatehandler at all - instead,
+ * it polls the object for completion with setInterval. Dispite the direct
+ * motivation, there is nothing jQuery-specific in this file, so it can be used
+ * in any environment where the ajax implementation depends on setInterval or
+ * setTimeout.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+
+(function () {
+		function makeApi(sinon) {
+				function Server() {}
+				Server.prototype = sinon.fakeServer;
+
+				sinon.fakeServerWithClock = new Server();
+
+				sinon.fakeServerWithClock.addRequest = function addRequest(xhr) {
+						if (xhr.async) {
+								if (typeof setTimeout.clock == "object") {
+										this.clock = setTimeout.clock;
+								} else {
+										this.clock = sinon.useFakeTimers();
+										this.resetClock = true;
+								}
+
+								if (!this.longestTimeout) {
+										var clockSetTimeout = this.clock.setTimeout;
+										var clockSetInterval = this.clock.setInterval;
+										var server = this;
+
+										this.clock.setTimeout = function (fn, timeout) {
+												server.longestTimeout = Math.max(timeout, server.longestTimeout || 0);
+
+												return clockSetTimeout.apply(this, arguments);
+										};
+
+										this.clock.setInterval = function (fn, timeout) {
+												server.longestTimeout = Math.max(timeout, server.longestTimeout || 0);
+
+												return clockSetInterval.apply(this, arguments);
+										};
+								}
+						}
+
+						return sinon.fakeServer.addRequest.call(this, xhr);
+				};
+
+				sinon.fakeServerWithClock.respond = function respond() {
+						var returnVal = sinon.fakeServer.respond.apply(this, arguments);
+
+						if (this.clock) {
+								this.clock.tick(this.longestTimeout || 0);
+								this.longestTimeout = 0;
+
+								if (this.resetClock) {
+										this.clock.restore();
+										this.resetClock = false;
+								}
+						}
+
+						return returnVal;
+				};
+
+				sinon.fakeServerWithClock.restore = function restore() {
+						if (this.clock) {
+								this.clock.restore();
+						}
+
+						return sinon.fakeServer.restore.apply(this, arguments);
+				};
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require) {
+				var sinon = require("./core");
+				require("./fake_server");
+				require("./fake_timers");
+				makeApi(sinon);
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require);
+		} else {
+				makeApi(sinon);
+		}
+}());
+
+/**
+ * @depend util/core.js
+ * @depend extend.js
+ * @depend collection.js
+ * @depend util/fake_timers.js
+ * @depend util/fake_server_with_clock.js
+ */
+/**
+ * Manages fake collections as well as fake utilities such as Sinon's
+ * timers and fake XHR implementation in one convenient object.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+
+(function () {
+		function makeApi(sinon) {
+				var push = [].push;
+
+				function exposeValue(sandbox, config, key, value) {
+						if (!value) {
+								return;
+						}
+
+						if (config.injectInto && !(key in config.injectInto)) {
+								config.injectInto[key] = value;
+								sandbox.injectedKeys.push(key);
+						} else {
+								push.call(sandbox.args, value);
+						}
+				}
+
+				function prepareSandboxFromConfig(config) {
+						var sandbox = sinon.create(sinon.sandbox);
+
+						if (config.useFakeServer) {
+								if (typeof config.useFakeServer == "object") {
+										sandbox.serverPrototype = config.useFakeServer;
+								}
+
+								sandbox.useFakeServer();
+						}
+
+						if (config.useFakeTimers) {
+								if (typeof config.useFakeTimers == "object") {
+										sandbox.useFakeTimers.apply(sandbox, config.useFakeTimers);
+								} else {
+										sandbox.useFakeTimers();
+								}
+						}
+
+						return sandbox;
+				}
+
+				sinon.sandbox = sinon.extend(sinon.create(sinon.collection), {
+						useFakeTimers: function useFakeTimers() {
+								this.clock = sinon.useFakeTimers.apply(sinon, arguments);
+
+								return this.add(this.clock);
+						},
+
+						serverPrototype: sinon.fakeServer,
+
+						useFakeServer: function useFakeServer() {
+								var proto = this.serverPrototype || sinon.fakeServer;
+
+								if (!proto || !proto.create) {
+										return null;
+								}
+
+								this.server = proto.create();
+								return this.add(this.server);
+						},
+
+						inject: function (obj) {
+								sinon.collection.inject.call(this, obj);
+
+								if (this.clock) {
+										obj.clock = this.clock;
+								}
+
+								if (this.server) {
+										obj.server = this.server;
+										obj.requests = this.server.requests;
+								}
+
+								obj.match = sinon.match;
+
+								return obj;
+						},
+
+						restore: function () {
+								sinon.collection.restore.apply(this, arguments);
+								this.restoreContext();
+						},
+
+						restoreContext: function () {
+								if (this.injectedKeys) {
+										for (var i = 0, j = this.injectedKeys.length; i < j; i++) {
+												delete this.injectInto[this.injectedKeys[i]];
+										}
+										this.injectedKeys = [];
+								}
+						},
+
+						create: function (config) {
+								if (!config) {
+										return sinon.create(sinon.sandbox);
+								}
+
+								var sandbox = prepareSandboxFromConfig(config);
+								sandbox.args = sandbox.args || [];
+								sandbox.injectedKeys = [];
+								sandbox.injectInto = config.injectInto;
+								var prop, value, exposed = sandbox.inject({});
+
+								if (config.properties) {
+										for (var i = 0, l = config.properties.length; i < l; i++) {
+												prop = config.properties[i];
+												value = exposed[prop] || prop == "sandbox" && sandbox;
+												exposeValue(sandbox, config, prop, value);
+										}
+								} else {
+										exposeValue(sandbox, config, "sandbox", value);
+								}
+
+								return sandbox;
+						},
+
+						match: sinon.match
+				});
+
+				sinon.sandbox.useFakeXMLHttpRequest = sinon.sandbox.useFakeServer;
+
+				return sinon.sandbox;
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./util/core");
+				require("./extend");
+				require("./util/fake_server_with_clock");
+				require("./util/fake_timers");
+				require("./collection");
+				module.exports = makeApi(sinon);
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (!sinon) {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+}());
+
+/**
+ * @depend util/core.js
+ * @depend sandbox.js
+ */
+/**
+ * Test function, sandboxes fakes
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+
+(function (sinon) {
+		function makeApi(sinon) {
+				var slice = Array.prototype.slice;
+
+				function test(callback) {
+						var type = typeof callback;
+
+						if (type != "function") {
+								throw new TypeError("sinon.test needs to wrap a test function, got " + type);
+						}
+
+						function sinonSandboxedTest() {
+								var config = sinon.getConfig(sinon.config);
+								config.injectInto = config.injectIntoThis && this || config.injectInto;
+								var sandbox = sinon.sandbox.create(config);
+								var args = slice.call(arguments);
+								var oldDone = args.length && args[args.length - 1];
+								var exception, result;
+
+								if (typeof oldDone == "function") {
+										args[args.length - 1] = function sinonDone(result) {
+												if (result) {
+														sandbox.restore();
+														throw exception;
+												} else {
+														sandbox.verifyAndRestore();
+												}
+												oldDone(result);
+										};
+								}
+
+								try {
+										result = callback.apply(this, args.concat(sandbox.args));
+								} catch (e) {
+										exception = e;
+								}
+
+								if (typeof oldDone != "function") {
+										if (typeof exception !== "undefined") {
+												sandbox.restore();
+												throw exception;
+										} else {
+												sandbox.verifyAndRestore();
+										}
+								}
+
+								return result;
+						}
+
+						if (callback.length) {
+								return function sinonAsyncSandboxedTest(callback) {
+										return sinonSandboxedTest.apply(this, arguments);
+								};
+						}
+
+						return sinonSandboxedTest;
+				}
+
+				test.config = {
+						injectIntoThis: true,
+						injectInto: null,
+						properties: ["spy", "stub", "mock", "clock", "server", "requests"],
+						useFakeTimers: true,
+						useFakeServer: true
+				};
+
+				sinon.test = test;
+				return test;
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./util/core");
+				require("./sandbox");
+				module.exports = makeApi(sinon);
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (sinon) {
+				makeApi(sinon);
+		}
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend util/core.js
+ * @depend test.js
+ */
+/**
+ * Test case, sandboxes all test functions
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+
+(function (sinon) {
+		function createTest(property, setUp, tearDown) {
+				return function () {
+						if (setUp) {
+								setUp.apply(this, arguments);
+						}
+
+						var exception, result;
+
+						try {
+								result = property.apply(this, arguments);
+						} catch (e) {
+								exception = e;
+						}
+
+						if (tearDown) {
+								tearDown.apply(this, arguments);
+						}
+
+						if (exception) {
+								throw exception;
+						}
+
+						return result;
+				};
+		}
+
+		function makeApi(sinon) {
+				function testCase(tests, prefix) {
+						/*jsl:ignore*/
+						if (!tests || typeof tests != "object") {
+								throw new TypeError("sinon.testCase needs an object with test functions");
+						}
+						/*jsl:end*/
+
+						prefix = prefix || "test";
+						var rPrefix = new RegExp("^" + prefix);
+						var methods = {}, testName, property, method;
+						var setUp = tests.setUp;
+						var tearDown = tests.tearDown;
+
+						for (testName in tests) {
+								if (tests.hasOwnProperty(testName)) {
+										property = tests[testName];
+
+										if (/^(setUp|tearDown)$/.test(testName)) {
+												continue;
+										}
+
+										if (typeof property == "function" && rPrefix.test(testName)) {
+												method = property;
+
+												if (setUp || tearDown) {
+														method = createTest(property, setUp, tearDown);
+												}
+
+												methods[testName] = sinon.test(method);
+										} else {
+												methods[testName] = tests[testName];
+										}
+								}
+						}
+
+						return methods;
+				}
+
+				sinon.testCase = testCase;
+				return testCase;
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./util/core");
+				require("./test");
+				module.exports = makeApi(sinon);
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (!sinon) {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+}(typeof sinon == "object" && sinon || null));
+
+/**
+ * @depend times_in_words.js
+ * @depend util/core.js
+ * @depend match.js
+ * @depend format.js
+ */
+/**
+ * Assertions matching the test spy retrieval interface.
+ *
+ * @author Christian Johansen (christian@cjohansen.no)
+ * @license BSD
+ *
+ * Copyright (c) 2010-2013 Christian Johansen
+ */
+
+(function (sinon, global) {
+		var slice = Array.prototype.slice;
+
+		function makeApi(sinon) {
+				var assert;
+
+				function verifyIsStub() {
+						var method;
+
+						for (var i = 0, l = arguments.length; i < l; ++i) {
+								method = arguments[i];
+
+								if (!method) {
+										assert.fail("fake is not a spy");
+								}
+
+								if (method.proxy) {
+										verifyIsStub(method.proxy);
+								} else {
+										if (typeof method != "function") {
+												assert.fail(method + " is not a function");
+										}
+
+										if (typeof method.getCall != "function") {
+												assert.fail(method + " is not stubbed");
+										}
+								}
+
+						}
+				}
+
+				function failAssertion(object, msg) {
+						object = object || global;
+						var failMethod = object.fail || assert.fail;
+						failMethod.call(object, msg);
+				}
+
+				function mirrorPropAsAssertion(name, method, message) {
+						if (arguments.length == 2) {
+								message = method;
+								method = name;
+						}
+
+						assert[name] = function (fake) {
+								verifyIsStub(fake);
+
+								var args = slice.call(arguments, 1);
+								var failed = false;
+
+								if (typeof method == "function") {
+										failed = !method(fake);
+								} else {
+										failed = typeof fake[method] == "function" ?
+												!fake[method].apply(fake, args) : !fake[method];
+								}
+
+								if (failed) {
+										failAssertion(this, (fake.printf || fake.proxy.printf).apply(fake, [message].concat(args)));
+								} else {
+										assert.pass(name);
+								}
+						};
+				}
+
+				function exposedName(prefix, prop) {
+						return !prefix || /^fail/.test(prop) ? prop :
+								prefix + prop.slice(0, 1).toUpperCase() + prop.slice(1);
+				}
+
+				assert = {
+						failException: "AssertError",
+
+						fail: function fail(message) {
+								var error = new Error(message);
+								error.name = this.failException || assert.failException;
+
+								throw error;
+						},
+
+						pass: function pass(assertion) {},
+
+						callOrder: function assertCallOrder() {
+								verifyIsStub.apply(null, arguments);
+								var expected = "", actual = "";
+
+								if (!sinon.calledInOrder(arguments)) {
+										try {
+												expected = [].join.call(arguments, ", ");
+												var calls = slice.call(arguments);
+												var i = calls.length;
+												while (i) {
+														if (!calls[--i].called) {
+																calls.splice(i, 1);
+														}
+												}
+												actual = sinon.orderByFirstCall(calls).join(", ");
+										} catch (e) {
+												// If this fails, we'll just fall back to the blank string
+										}
+
+										failAssertion(this, "expected " + expected + " to be " +
+																"called in order but were called as " + actual);
+								} else {
+										assert.pass("callOrder");
+								}
+						},
+
+						callCount: function assertCallCount(method, count) {
+								verifyIsStub(method);
+
+								if (method.callCount != count) {
+										var msg = "expected %n to be called " + sinon.timesInWords(count) +
+												" but was called %c%C";
+										failAssertion(this, method.printf(msg));
+								} else {
+										assert.pass("callCount");
+								}
+						},
+
+						expose: function expose(target, options) {
+								if (!target) {
+										throw new TypeError("target is null or undefined");
+								}
+
+								var o = options || {};
+								var prefix = typeof o.prefix == "undefined" && "assert" || o.prefix;
+								var includeFail = typeof o.includeFail == "undefined" || !!o.includeFail;
+
+								for (var method in this) {
+										if (method != "expose" && (includeFail || !/^(fail)/.test(method))) {
+												target[exposedName(prefix, method)] = this[method];
+										}
+								}
+
+								return target;
+						},
+
+						match: function match(actual, expectation) {
+								var matcher = sinon.match(expectation);
+								if (matcher.test(actual)) {
+										assert.pass("match");
+								} else {
+										var formatted = [
+												"expected value to match",
+												"    expected = " + sinon.format(expectation),
+												"    actual = " + sinon.format(actual)
+										]
+										failAssertion(this, formatted.join("\n"));
+								}
+						}
+				};
+
+				mirrorPropAsAssertion("called", "expected %n to have been called at least once but was never called");
+				mirrorPropAsAssertion("notCalled", function (spy) { return !spy.called; },
+														"expected %n to not have been called but was called %c%C");
+				mirrorPropAsAssertion("calledOnce", "expected %n to be called once but was called %c%C");
+				mirrorPropAsAssertion("calledTwice", "expected %n to be called twice but was called %c%C");
+				mirrorPropAsAssertion("calledThrice", "expected %n to be called thrice but was called %c%C");
+				mirrorPropAsAssertion("calledOn", "expected %n to be called with %1 as this but was called with %t");
+				mirrorPropAsAssertion("alwaysCalledOn", "expected %n to always be called with %1 as this but was called with %t");
+				mirrorPropAsAssertion("calledWithNew", "expected %n to be called with new");
+				mirrorPropAsAssertion("alwaysCalledWithNew", "expected %n to always be called with new");
+				mirrorPropAsAssertion("calledWith", "expected %n to be called with arguments %*%C");
+				mirrorPropAsAssertion("calledWithMatch", "expected %n to be called with match %*%C");
+				mirrorPropAsAssertion("alwaysCalledWith", "expected %n to always be called with arguments %*%C");
+				mirrorPropAsAssertion("alwaysCalledWithMatch", "expected %n to always be called with match %*%C");
+				mirrorPropAsAssertion("calledWithExactly", "expected %n to be called with exact arguments %*%C");
+				mirrorPropAsAssertion("alwaysCalledWithExactly", "expected %n to always be called with exact arguments %*%C");
+				mirrorPropAsAssertion("neverCalledWith", "expected %n to never be called with arguments %*%C");
+				mirrorPropAsAssertion("neverCalledWithMatch", "expected %n to never be called with match %*%C");
+				mirrorPropAsAssertion("threw", "%n did not throw exception%C");
+				mirrorPropAsAssertion("alwaysThrew", "%n did not always throw exception%C");
+
+				sinon.assert = assert;
+				return assert;
+		}
+
+		var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
+		var isAMD = typeof define === "function" && typeof define.amd === "object" && define.amd;
+
+		function loadDependencies(require, exports, module) {
+				var sinon = require("./util/core");
+				require("./match");
+				require("./format");
+				module.exports = makeApi(sinon);
+		}
+
+		if (isAMD) {
+				define(loadDependencies);
+		} else if (isNode) {
+				loadDependencies(require, module.exports, module);
+		} else if (!sinon) {
+				return;
+		} else {
+				makeApi(sinon);
+		}
+
+}(typeof sinon == "object" && sinon || null, typeof window != "undefined" ? window : (typeof self != "undefined") ? self : global));
+
+	return sinon;
+}));