[Summary view] [Print] [Text view]

   1  /**
   2   * Sinon.JS 1.10.3, 2014/07/11
   3   *
   4   * @author Christian Johansen ([email protected])
   5   * @author Contributors: https://github.com/cjohansen/Sinon.JS/blob/master/AUTHORS
   6   *
   7   * (The BSD License)
   8   * 
   9   * Copyright (c) 2010-2014, Christian Johansen, [email protected]
  10   * All rights reserved.
  11   * 
  12   * Redistribution and use in source and binary forms, with or without modification,
  13   * are permitted provided that the following conditions are met:
  14   * 
  15   *     * Redistributions of source code must retain the above copyright notice,
  16   *       this list of conditions and the following disclaimer.
  17   *     * Redistributions in binary form must reproduce the above copyright notice,
  18   *       this list of conditions and the following disclaimer in the documentation
  19   *       and/or other materials provided with the distribution.
  20   *     * Neither the name of Christian Johansen nor the names of his contributors
  21   *       may be used to endorse or promote products derived from this software
  22   *       without specific prior written permission.
  23   * 
  24   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  25   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  26   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  27   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
  28   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  30   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  31   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  32   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  33   * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34   */
  35  
  36  this.sinon = (function () {
  37  var samsam, formatio;
  38  function define(mod, deps, fn) { if (mod == "samsam") { samsam = deps(); } else if (typeof fn === "function") { formatio = fn(samsam); } }
  39  define.amd = {};
  40  ((typeof define === "function" && define.amd && function (m) { define("samsam", m); }) ||
  41   (typeof module === "object" &&
  42        function (m) { module.exports = m(); }) || // Node
  43   function (m) { this.samsam = m(); } // Browser globals
  44  )(function () {
  45      var o = Object.prototype;
  46      var div = typeof document !== "undefined" && document.createElement("div");
  47  
  48      function isNaN(value) {
  49          // Unlike global isNaN, this avoids type coercion
  50          // typeof check avoids IE host object issues, hat tip to
  51          // lodash
  52          var val = value; // JsLint thinks value !== value is "weird"
  53          return typeof value === "number" && value !== val;
  54      }
  55  
  56      function getClass(value) {
  57          // Returns the internal [[Class]] by calling Object.prototype.toString
  58          // with the provided value as this. Return value is a string, naming the
  59          // internal class, e.g. "Array"
  60          return o.toString.call(value).split(/[ \]]/)[1];
  61      }
  62  
  63      /**
  64       * @name samsam.isArguments
  65       * @param Object object
  66       *
  67       * Returns ``true`` if ``object`` is an ``arguments`` object,
  68       * ``false`` otherwise.
  69       */
  70      function isArguments(object) {
  71          if (typeof object !== "object" || typeof object.length !== "number" ||
  72                  getClass(object) === "Array") {
  73              return false;
  74          }
  75          if (typeof object.callee == "function") { return true; }
  76          try {
  77              object[object.length] = 6;
  78              delete object[object.length];
  79          } catch (e) {
  80              return true;
  81          }
  82          return false;
  83      }
  84  
  85      /**
  86       * @name samsam.isElement
  87       * @param Object object
  88       *
  89       * Returns ``true`` if ``object`` is a DOM element node. Unlike
  90       * Underscore.js/lodash, this function will return ``false`` if ``object``
  91       * is an *element-like* object, i.e. a regular object with a ``nodeType``
  92       * property that holds the value ``1``.
  93       */
  94      function isElement(object) {
  95          if (!object || object.nodeType !== 1 || !div) { return false; }
  96          try {
  97              object.appendChild(div);
  98              object.removeChild(div);
  99          } catch (e) {
 100              return false;
 101          }
 102          return true;
 103      }
 104  
 105      /**
 106       * @name samsam.keys
 107       * @param Object object
 108       *
 109       * Return an array of own property names.
 110       */
 111      function keys(object) {
 112          var ks = [], prop;
 113          for (prop in object) {
 114              if (o.hasOwnProperty.call(object, prop)) { ks.push(prop); }
 115          }
 116          return ks;
 117      }
 118  
 119      /**
 120       * @name samsam.isDate
 121       * @param Object value
 122       *
 123       * Returns true if the object is a ``Date``, or *date-like*. Duck typing
 124       * of date objects work by checking that the object has a ``getTime``
 125       * function whose return value equals the return value from the object's
 126       * ``valueOf``.
 127       */
 128      function isDate(value) {
 129          return typeof value.getTime == "function" &&
 130              value.getTime() == value.valueOf();
 131      }
 132  
 133      /**
 134       * @name samsam.isNegZero
 135       * @param Object value
 136       *
 137       * Returns ``true`` if ``value`` is ``-0``.
 138       */
 139      function isNegZero(value) {
 140          return value === 0 && 1 / value === -Infinity;
 141      }
 142  
 143      /**
 144       * @name samsam.equal
 145       * @param Object obj1
 146       * @param Object obj2
 147       *
 148       * Returns ``true`` if two objects are strictly equal. Compared to
 149       * ``===`` there are two exceptions:
 150       *
 151       *   - NaN is considered equal to NaN
 152       *   - -0 and +0 are not considered equal
 153       */
 154      function identical(obj1, obj2) {
 155          if (obj1 === obj2 || (isNaN(obj1) && isNaN(obj2))) {
 156              return obj1 !== 0 || isNegZero(obj1) === isNegZero(obj2);
 157          }
 158      }
 159  
 160  
 161      /**
 162       * @name samsam.deepEqual
 163       * @param Object obj1
 164       * @param Object obj2
 165       *
 166       * Deep equal comparison. Two values are "deep equal" if:
 167       *
 168       *   - They are equal, according to samsam.identical
 169       *   - They are both date objects representing the same time
 170       *   - They are both arrays containing elements that are all deepEqual
 171       *   - They are objects with the same set of properties, and each property
 172       *     in ``obj1`` is deepEqual to the corresponding property in ``obj2``
 173       *
 174       * Supports cyclic objects.
 175       */
 176      function deepEqualCyclic(obj1, obj2) {
 177  
 178          // used for cyclic comparison
 179          // contain already visited objects
 180          var objects1 = [],
 181              objects2 = [],
 182          // contain pathes (position in the object structure)
 183          // of the already visited objects
 184          // indexes same as in objects arrays
 185              paths1 = [],
 186              paths2 = [],
 187          // contains combinations of already compared objects
 188          // in the manner: { "$1['ref']$2['ref']": true }
 189              compared = {};
 190  
 191          /**
 192           * used to check, if the value of a property is an object
 193           * (cyclic logic is only needed for objects)
 194           * only needed for cyclic logic
 195           */
 196          function isObject(value) {
 197  
 198              if (typeof value === 'object' && value !== null &&
 199                      !(value instanceof Boolean) &&
 200                      !(value instanceof Date)    &&
 201                      !(value instanceof Number)  &&
 202                      !(value instanceof RegExp)  &&
 203                      !(value instanceof String)) {
 204  
 205                  return true;
 206              }
 207  
 208              return false;
 209          }
 210  
 211          /**
 212           * returns the index of the given object in the
 213           * given objects array, -1 if not contained
 214           * only needed for cyclic logic
 215           */
 216          function getIndex(objects, obj) {
 217  
 218              var i;
 219              for (i = 0; i < objects.length; i++) {
 220                  if (objects[i] === obj) {
 221                      return i;
 222                  }
 223              }
 224  
 225              return -1;
 226          }
 227  
 228          // does the recursion for the deep equal check
 229          return (function deepEqual(obj1, obj2, path1, path2) {
 230              var type1 = typeof obj1;
 231              var type2 = typeof obj2;
 232  
 233              // == null also matches undefined
 234              if (obj1 === obj2 ||
 235                      isNaN(obj1) || isNaN(obj2) ||
 236                      obj1 == null || obj2 == null ||
 237                      type1 !== "object" || type2 !== "object") {
 238  
 239                  return identical(obj1, obj2);
 240              }
 241  
 242              // Elements are only equal if identical(expected, actual)
 243              if (isElement(obj1) || isElement(obj2)) { return false; }
 244  
 245              var isDate1 = isDate(obj1), isDate2 = isDate(obj2);
 246              if (isDate1 || isDate2) {
 247                  if (!isDate1 || !isDate2 || obj1.getTime() !== obj2.getTime()) {
 248                      return false;
 249                  }
 250              }
 251  
 252              if (obj1 instanceof RegExp && obj2 instanceof RegExp) {
 253                  if (obj1.toString() !== obj2.toString()) { return false; }
 254              }
 255  
 256              var class1 = getClass(obj1);
 257              var class2 = getClass(obj2);
 258              var keys1 = keys(obj1);
 259              var keys2 = keys(obj2);
 260  
 261              if (isArguments(obj1) || isArguments(obj2)) {
 262                  if (obj1.length !== obj2.length) { return false; }
 263              } else {
 264                  if (type1 !== type2 || class1 !== class2 ||
 265                          keys1.length !== keys2.length) {
 266                      return false;
 267                  }
 268              }
 269  
 270              var key, i, l,
 271                  // following vars are used for the cyclic logic
 272                  value1, value2,
 273                  isObject1, isObject2,
 274                  index1, index2,
 275                  newPath1, newPath2;
 276  
 277              for (i = 0, l = keys1.length; i < l; i++) {
 278                  key = keys1[i];
 279                  if (!o.hasOwnProperty.call(obj2, key)) {
 280                      return false;
 281                  }
 282  
 283                  // Start of the cyclic logic
 284  
 285                  value1 = obj1[key];
 286                  value2 = obj2[key];
 287  
 288                  isObject1 = isObject(value1);
 289                  isObject2 = isObject(value2);
 290  
 291                  // determine, if the objects were already visited
 292                  // (it's faster to check for isObject first, than to
 293                  // get -1 from getIndex for non objects)
 294                  index1 = isObject1 ? getIndex(objects1, value1) : -1;
 295                  index2 = isObject2 ? getIndex(objects2, value2) : -1;
 296  
 297                  // determine the new pathes of the objects
 298                  // - for non cyclic objects the current path will be extended
 299                  //   by current property name
 300                  // - for cyclic objects the stored path is taken
 301                  newPath1 = index1 !== -1
 302                      ? paths1[index1]
 303                      : path1 + '[' + JSON.stringify(key) + ']';
 304                  newPath2 = index2 !== -1
 305                      ? paths2[index2]
 306                      : path2 + '[' + JSON.stringify(key) + ']';
 307  
 308                  // stop recursion if current objects are already compared
 309                  if (compared[newPath1 + newPath2]) {
 310                      return true;
 311                  }
 312  
 313                  // remember the current objects and their pathes
 314                  if (index1 === -1 && isObject1) {
 315                      objects1.push(value1);
 316                      paths1.push(newPath1);
 317                  }
 318                  if (index2 === -1 && isObject2) {
 319                      objects2.push(value2);
 320                      paths2.push(newPath2);
 321                  }
 322  
 323                  // remember that the current objects are already compared
 324                  if (isObject1 && isObject2) {
 325                      compared[newPath1 + newPath2] = true;
 326                  }
 327  
 328                  // End of cyclic logic
 329  
 330                  // neither value1 nor value2 is a cycle
 331                  // continue with next level
 332                  if (!deepEqual(value1, value2, newPath1, newPath2)) {
 333                      return false;
 334                  }
 335              }
 336  
 337              return true;
 338  
 339          }(obj1, obj2, '$1', '$2'));
 340      }
 341  
 342      var match;
 343  
 344      function arrayContains(array, subset) {
 345          if (subset.length === 0) { return true; }
 346          var i, l, j, k;
 347          for (i = 0, l = array.length; i < l; ++i) {
 348              if (match(array[i], subset[0])) {
 349                  for (j = 0, k = subset.length; j < k; ++j) {
 350                      if (!match(array[i + j], subset[j])) { return false; }
 351                  }
 352                  return true;
 353              }
 354          }
 355          return false;
 356      }
 357  
 358      /**
 359       * @name samsam.match
 360       * @param Object object
 361       * @param Object matcher
 362       *
 363       * Compare arbitrary value ``object`` with matcher.
 364       */
 365      match = function match(object, matcher) {
 366          if (matcher && typeof matcher.test === "function") {
 367              return matcher.test(object);
 368          }
 369  
 370          if (typeof matcher === "function") {
 371              return matcher(object) === true;
 372          }
 373  
 374          if (typeof matcher === "string") {
 375              matcher = matcher.toLowerCase();
 376              var notNull = typeof object === "string" || !!object;
 377              return notNull &&
 378                  (String(object)).toLowerCase().indexOf(matcher) >= 0;
 379          }
 380  
 381          if (typeof matcher === "number") {
 382              return matcher === object;
 383          }
 384  
 385          if (typeof matcher === "boolean") {
 386              return matcher === object;
 387          }
 388  
 389          if (getClass(object) === "Array" && getClass(matcher) === "Array") {
 390              return arrayContains(object, matcher);
 391          }
 392  
 393          if (matcher && typeof matcher === "object") {
 394              var prop;
 395              for (prop in matcher) {
 396                  if (!match(object[prop], matcher[prop])) {
 397                      return false;
 398                  }
 399              }
 400              return true;
 401          }
 402  
 403          throw new Error("Matcher was not a string, a number, a " +
 404                          "function, a boolean or an object");
 405      };
 406  
 407      return {
 408          isArguments: isArguments,
 409          isElement: isElement,
 410          isDate: isDate,
 411          isNegZero: isNegZero,
 412          identical: identical,
 413          deepEqual: deepEqualCyclic,
 414          match: match,
 415          keys: keys
 416      };
 417  });
 418  ((typeof define === "function" && define.amd && function (m) {
 419      define("formatio", ["samsam"], m);
 420  }) || (typeof module === "object" && function (m) {
 421      module.exports = m(require("samsam"));
 422  }) || function (m) { this.formatio = m(this.samsam); }
 423  )(function (samsam) {
 424      
 425      var formatio = {
 426          excludeConstructors: ["Object", /^.$/],
 427          quoteStrings: true
 428      };
 429  
 430      var hasOwn = Object.prototype.hasOwnProperty;
 431  
 432      var specialObjects = [];
 433      if (typeof global !== "undefined") {
 434          specialObjects.push({ object: global, value: "[object global]" });
 435      }
 436      if (typeof document !== "undefined") {
 437          specialObjects.push({
 438              object: document,
 439              value: "[object HTMLDocument]"
 440          });
 441      }
 442      if (typeof window !== "undefined") {
 443          specialObjects.push({ object: window, value: "[object Window]" });
 444      }
 445  
 446      function functionName(func) {
 447          if (!func) { return ""; }
 448          if (func.displayName) { return func.displayName; }
 449          if (func.name) { return func.name; }
 450          var matches = func.toString().match(/function\s+([^\(]+)/m);
 451          return (matches && matches[1]) || "";
 452      }
 453  
 454      function constructorName(f, object) {
 455          var name = functionName(object && object.constructor);
 456          var excludes = f.excludeConstructors ||
 457                  formatio.excludeConstructors || [];
 458  
 459          var i, l;
 460          for (i = 0, l = excludes.length; i < l; ++i) {
 461              if (typeof excludes[i] === "string" && excludes[i] === name) {
 462                  return "";
 463              } else if (excludes[i].test && excludes[i].test(name)) {
 464                  return "";
 465              }
 466          }
 467  
 468          return name;
 469      }
 470  
 471      function isCircular(object, objects) {
 472          if (typeof object !== "object") { return false; }
 473          var i, l;
 474          for (i = 0, l = objects.length; i < l; ++i) {
 475              if (objects[i] === object) { return true; }
 476          }
 477          return false;
 478      }
 479  
 480      function ascii(f, object, processed, indent) {
 481          if (typeof object === "string") {
 482              var qs = f.quoteStrings;
 483              var quote = typeof qs !== "boolean" || qs;
 484              return processed || quote ? '"' + object + '"' : object;
 485          }
 486  
 487          if (typeof object === "function" && !(object instanceof RegExp)) {
 488              return ascii.func(object);
 489          }
 490  
 491          processed = processed || [];
 492  
 493          if (isCircular(object, processed)) { return "[Circular]"; }
 494  
 495          if (Object.prototype.toString.call(object) === "[object Array]") {
 496              return ascii.array.call(f, object, processed);
 497          }
 498  
 499          if (!object) { return String((1/object) === -Infinity ? "-0" : object); }
 500          if (samsam.isElement(object)) { return ascii.element(object); }
 501  
 502          if (typeof object.toString === "function" &&
 503                  object.toString !== Object.prototype.toString) {
 504              return object.toString();
 505          }
 506  
 507          var i, l;
 508          for (i = 0, l = specialObjects.length; i < l; i++) {
 509              if (object === specialObjects[i].object) {
 510                  return specialObjects[i].value;
 511              }
 512          }
 513  
 514          return ascii.object.call(f, object, processed, indent);
 515      }
 516  
 517      ascii.func = function (func) {
 518          return "function " + functionName(func) + "() {}";
 519      };
 520  
 521      ascii.array = function (array, processed) {
 522          processed = processed || [];
 523          processed.push(array);
 524          var i, l, pieces = [];
 525          for (i = 0, l = array.length; i < l; ++i) {
 526              pieces.push(ascii(this, array[i], processed));
 527          }
 528          return "[" + pieces.join(", ") + "]";
 529      };
 530  
 531      ascii.object = function (object, processed, indent) {
 532          processed = processed || [];
 533          processed.push(object);
 534          indent = indent || 0;
 535          var pieces = [], properties = samsam.keys(object).sort();
 536          var length = 3;
 537          var prop, str, obj, i, l;
 538  
 539          for (i = 0, l = properties.length; i < l; ++i) {
 540              prop = properties[i];
 541              obj = object[prop];
 542  
 543              if (isCircular(obj, processed)) {
 544                  str = "[Circular]";
 545              } else {
 546                  str = ascii(this, obj, processed, indent + 2);
 547              }
 548  
 549              str = (/\s/.test(prop) ? '"' + prop + '"' : prop) + ": " + str;
 550              length += str.length;
 551              pieces.push(str);
 552          }
 553  
 554          var cons = constructorName(this, object);
 555          var prefix = cons ? "[" + cons + "] " : "";
 556          var is = "";
 557          for (i = 0, l = indent; i < l; ++i) { is += " "; }
 558  
 559          if (length + indent > 80) {
 560              return prefix + "{\n  " + is + pieces.join(",\n  " + is) + "\n" +
 561                  is + "}";
 562          }
 563          return prefix + "{ " + pieces.join(", ") + " }";
 564      };
 565  
 566      ascii.element = function (element) {
 567          var tagName = element.tagName.toLowerCase();
 568          var attrs = element.attributes, attr, pairs = [], attrName, i, l, val;
 569  
 570          for (i = 0, l = attrs.length; i < l; ++i) {
 571              attr = attrs.item(i);
 572              attrName = attr.nodeName.toLowerCase().replace("html:", "");
 573              val = attr.nodeValue;
 574              if (attrName !== "contenteditable" || val !== "inherit") {
 575                  if (!!val) { pairs.push(attrName + "=\"" + val + "\""); }
 576              }
 577          }
 578  
 579          var formatted = "<" + tagName + (pairs.length > 0 ? " " : "");
 580          var content = element.innerHTML;
 581  
 582          if (content.length > 20) {
 583              content = content.substr(0, 20) + "[...]";
 584          }
 585  
 586          var res = formatted + pairs.join(" ") + ">" + content +
 587                  "</" + tagName + ">";
 588  
 589          return res.replace(/ contentEditable="inherit"/, "");
 590      };
 591  
 592      function Formatio(options) {
 593          for (var opt in options) {
 594              this[opt] = options[opt];
 595          }
 596      }
 597  
 598      Formatio.prototype = {
 599          functionName: functionName,
 600  
 601          configure: function (options) {
 602              return new Formatio(options);
 603          },
 604  
 605          constructorName: function (object) {
 606              return constructorName(this, object);
 607          },
 608  
 609          ascii: function (object, processed, indent) {
 610              return ascii(this, object, processed, indent);
 611          }
 612      };
 613  
 614      return Formatio.prototype;
 615  });
 616  /*jslint eqeqeq: false, onevar: false, forin: true, nomen: false, regexp: false, plusplus: false*/
 617  /*global module, require, __dirname, document*/
 618  /**
 619   * Sinon core utilities. For internal use only.
 620   *
 621   * @author Christian Johansen ([email protected])
 622   * @license BSD
 623   *
 624   * Copyright (c) 2010-2013 Christian Johansen
 625   */
 626  
 627  var sinon = (function (formatio) {
 628      var div = typeof document != "undefined" && document.createElement("div");
 629      var hasOwn = Object.prototype.hasOwnProperty;
 630  
 631      function isDOMNode(obj) {
 632          var success = false;
 633  
 634          try {
 635              obj.appendChild(div);
 636              success = div.parentNode == obj;
 637          } catch (e) {
 638              return false;
 639          } finally {
 640              try {
 641                  obj.removeChild(div);
 642              } catch (e) {
 643                  // Remove failed, not much we can do about that
 644              }
 645          }
 646  
 647          return success;
 648      }
 649  
 650      function isElement(obj) {
 651          return div && obj && obj.nodeType === 1 && isDOMNode(obj);
 652      }
 653  
 654      function isFunction(obj) {
 655          return typeof obj === "function" || !!(obj && obj.constructor && obj.call && obj.apply);
 656      }
 657  
 658      function isReallyNaN(val) {
 659          return typeof val === 'number' && isNaN(val);
 660      }
 661  
 662      function mirrorProperties(target, source) {
 663          for (var prop in source) {
 664              if (!hasOwn.call(target, prop)) {
 665                  target[prop] = source[prop];
 666              }
 667          }
 668      }
 669  
 670      function isRestorable (obj) {
 671          return typeof obj === "function" && typeof obj.restore === "function" && obj.restore.sinon;
 672      }
 673  
 674      var sinon = {
 675          wrapMethod: function wrapMethod(object, property, method) {
 676              if (!object) {
 677                  throw new TypeError("Should wrap property of object");
 678              }
 679  
 680              if (typeof method != "function") {
 681                  throw new TypeError("Method wrapper should be function");
 682              }
 683  
 684              var wrappedMethod = object[property],
 685                  error;
 686  
 687              if (!isFunction(wrappedMethod)) {
 688                  error = new TypeError("Attempted to wrap " + (typeof wrappedMethod) + " property " +
 689                                      property + " as function");
 690              } else if (wrappedMethod.restore && wrappedMethod.restore.sinon) {
 691                  error = new TypeError("Attempted to wrap " + property + " which is already wrapped");
 692              } else if (wrappedMethod.calledBefore) {
 693                  var verb = !!wrappedMethod.returns ? "stubbed" : "spied on";
 694                  error = new TypeError("Attempted to wrap " + property + " which is already " + verb);
 695              }
 696  
 697              if (error) {
 698                  if (wrappedMethod && wrappedMethod._stack) {
 699                      error.stack += '\n--------------\n' + wrappedMethod._stack;
 700                  }
 701                  throw error;
 702              }
 703  
 704              // IE 8 does not support hasOwnProperty on the window object and Firefox has a problem
 705              // when using hasOwn.call on objects from other frames.
 706              var owned = object.hasOwnProperty ? object.hasOwnProperty(property) : hasOwn.call(object, property);
 707              object[property] = method;
 708              method.displayName = property;
 709              // Set up a stack trace which can be used later to find what line of
 710              // code the original method was created on.
 711              method._stack = (new Error('Stack Trace for original')).stack;
 712  
 713              method.restore = function () {
 714                  // For prototype properties try to reset by delete first.
 715                  // If this fails (ex: localStorage on mobile safari) then force a reset
 716                  // via direct assignment.
 717                  if (!owned) {
 718                      delete object[property];
 719                  }
 720                  if (object[property] === method) {
 721                      object[property] = wrappedMethod;
 722                  }
 723              };
 724  
 725              method.restore.sinon = true;
 726              mirrorProperties(method, wrappedMethod);
 727  
 728              return method;
 729          },
 730  
 731          extend: function extend(target) {
 732              for (var i = 1, l = arguments.length; i < l; i += 1) {
 733                  for (var prop in arguments[i]) {
 734                      if (arguments[i].hasOwnProperty(prop)) {
 735                          target[prop] = arguments[i][prop];
 736                      }
 737  
 738                      // DONT ENUM bug, only care about toString
 739                      if (arguments[i].hasOwnProperty("toString") &&
 740                          arguments[i].toString != target.toString) {
 741                          target.toString = arguments[i].toString;
 742                      }
 743                  }
 744              }
 745  
 746              return target;
 747          },
 748  
 749          create: function create(proto) {
 750              var F = function () {};
 751              F.prototype = proto;
 752              return new F();
 753          },
 754  
 755          deepEqual: function deepEqual(a, b) {
 756              if (sinon.match && sinon.match.isMatcher(a)) {
 757                  return a.test(b);
 758              }
 759  
 760              if (typeof a != 'object' || typeof b != 'object') {
 761                  if (isReallyNaN(a) && isReallyNaN(b)) {
 762                      return true;
 763                  } else {
 764                      return a === b;
 765                  }
 766              }
 767  
 768              if (isElement(a) || isElement(b)) {
 769                  return a === b;
 770              }
 771  
 772              if (a === b) {
 773                  return true;
 774              }
 775  
 776              if ((a === null && b !== null) || (a !== null && b === null)) {
 777                  return false;
 778              }
 779  
 780              if (a instanceof RegExp && b instanceof RegExp) {
 781                return (a.source === b.source) && (a.global === b.global) &&
 782                  (a.ignoreCase === b.ignoreCase) && (a.multiline === b.multiline);
 783              }
 784  
 785              var aString = Object.prototype.toString.call(a);
 786              if (aString != Object.prototype.toString.call(b)) {
 787                  return false;
 788              }
 789  
 790              if (aString == "[object Date]") {
 791                  return a.valueOf() === b.valueOf();
 792              }
 793  
 794              var prop, aLength = 0, bLength = 0;
 795  
 796              if (aString == "[object Array]" && a.length !== b.length) {
 797                  return false;
 798              }
 799  
 800              for (prop in a) {
 801                  aLength += 1;
 802  
 803                  if (!(prop in b)) {
 804                      return false;
 805                  }
 806  
 807                  if (!deepEqual(a[prop], b[prop])) {
 808                      return false;
 809                  }
 810              }
 811  
 812              for (prop in b) {
 813                  bLength += 1;
 814              }
 815  
 816              return aLength == bLength;
 817          },
 818  
 819          functionName: function functionName(func) {
 820              var name = func.displayName || func.name;
 821  
 822              // Use function decomposition as a last resort to get function
 823              // name. Does not rely on function decomposition to work - if it
 824              // doesn't debugging will be slightly less informative
 825              // (i.e. toString will say 'spy' rather than 'myFunc').
 826              if (!name) {
 827                  var matches = func.toString().match(/function ([^\s\(]+)/);
 828                  name = matches && matches[1];
 829              }
 830  
 831              return name;
 832          },
 833  
 834          functionToString: function toString() {
 835              if (this.getCall && this.callCount) {
 836                  var thisValue, prop, i = this.callCount;
 837  
 838                  while (i--) {
 839                      thisValue = this.getCall(i).thisValue;
 840  
 841                      for (prop in thisValue) {
 842                          if (thisValue[prop] === this) {
 843                              return prop;
 844                          }
 845                      }
 846                  }
 847              }
 848  
 849              return this.displayName || "sinon fake";
 850          },
 851  
 852          getConfig: function (custom) {
 853              var config = {};
 854              custom = custom || {};
 855              var defaults = sinon.defaultConfig;
 856  
 857              for (var prop in defaults) {
 858                  if (defaults.hasOwnProperty(prop)) {
 859                      config[prop] = custom.hasOwnProperty(prop) ? custom[prop] : defaults[prop];
 860                  }
 861              }
 862  
 863              return config;
 864          },
 865  
 866          format: function (val) {
 867              return "" + val;
 868          },
 869  
 870          defaultConfig: {
 871              injectIntoThis: true,
 872              injectInto: null,
 873              properties: ["spy", "stub", "mock", "clock", "server", "requests"],
 874              useFakeTimers: true,
 875              useFakeServer: true
 876          },
 877  
 878          timesInWords: function timesInWords(count) {
 879              return count == 1 && "once" ||
 880                  count == 2 && "twice" ||
 881                  count == 3 && "thrice" ||
 882                  (count || 0) + " times";
 883          },
 884  
 885          calledInOrder: function (spies) {
 886              for (var i = 1, l = spies.length; i < l; i++) {
 887                  if (!spies[i - 1].calledBefore(spies[i]) || !spies[i].called) {
 888                      return false;
 889                  }
 890              }
 891  
 892              return true;
 893          },
 894  
 895          orderByFirstCall: function (spies) {
 896              return spies.sort(function (a, b) {
 897                  // uuid, won't ever be equal
 898                  var aCall = a.getCall(0);
 899                  var bCall = b.getCall(0);
 900                  var aId = aCall && aCall.callId || -1;
 901                  var bId = bCall && bCall.callId || -1;
 902  
 903                  return aId < bId ? -1 : 1;
 904              });
 905          },
 906  
 907          log: function () {},
 908  
 909          logError: function (label, err) {
 910              var msg = label + " threw exception: ";
 911              sinon.log(msg + "[" + err.name + "] " + err.message);
 912              if (err.stack) { sinon.log(err.stack); }
 913  
 914              setTimeout(function () {
 915                  err.message = msg + err.message;
 916                  throw err;
 917              }, 0);
 918          },
 919  
 920          typeOf: function (value) {
 921              if (value === null) {
 922                  return "null";
 923              }
 924              else if (value === undefined) {
 925                  return "undefined";
 926              }
 927              var string = Object.prototype.toString.call(value);
 928              return string.substring(8, string.length - 1).toLowerCase();
 929          },
 930  
 931          createStubInstance: function (constructor) {
 932              if (typeof constructor !== "function") {
 933                  throw new TypeError("The constructor should be a function.");
 934              }
 935              return sinon.stub(sinon.create(constructor.prototype));
 936          },
 937  
 938          restore: function (object) {
 939              if (object !== null && typeof object === "object") {
 940                  for (var prop in object) {
 941                      if (isRestorable(object[prop])) {
 942                          object[prop].restore();
 943                      }
 944                  }
 945              }
 946              else if (isRestorable(object)) {
 947                  object.restore();
 948              }
 949          }
 950      };
 951  
 952      var isNode = typeof module !== "undefined" && module.exports && typeof require == "function";
 953      var isAMD = typeof define === 'function' && typeof define.amd === 'object' && define.amd;
 954  
 955      function makePublicAPI(require, exports, module) {
 956          module.exports = sinon;
 957          sinon.spy = require("./sinon/spy");
 958          sinon.spyCall = require("./sinon/call");
 959          sinon.behavior = require("./sinon/behavior");
 960          sinon.stub = require("./sinon/stub");
 961          sinon.mock = require("./sinon/mock");
 962          sinon.collection = require("./sinon/collection");
 963          sinon.assert = require("./sinon/assert");
 964          sinon.sandbox = require("./sinon/sandbox");
 965          sinon.test = require("./sinon/test");
 966          sinon.testCase = require("./sinon/test_case");
 967          sinon.match = require("./sinon/match");
 968      }
 969  
 970      if (isAMD) {
 971          define(makePublicAPI);
 972      } else if (isNode) {
 973          try {
 974              formatio = require("formatio");
 975          } catch (e) {}
 976          makePublicAPI(require, exports, module);
 977      }
 978  
 979      if (formatio) {
 980          var formatter = formatio.configure({ quoteStrings: false });
 981          sinon.format = function () {
 982              return formatter.ascii.apply(formatter, arguments);
 983          };
 984      } else if (isNode) {
 985          try {
 986              var util = require("util");
 987              sinon.format = function (value) {
 988                  return typeof value == "object" && value.toString === Object.prototype.toString ? util.inspect(value) : value;
 989              };
 990          } catch (e) {
 991              /* Node, but no util module - would be very old, but better safe than
 992               sorry */
 993          }
 994      }
 995  
 996      return sinon;
 997  }(typeof formatio == "object" && formatio));
 998  
 999  /* @depend ../sinon.js */
1000  /*jslint eqeqeq: false, onevar: false, plusplus: false*/
1001  /*global module, require, sinon*/
1002  /**
1003   * Match functions
1004   *
1005   * @author Maximilian Antoni ([email protected])
1006   * @license BSD
1007   *
1008   * Copyright (c) 2012 Maximilian Antoni
1009   */
1010  
1011  (function (sinon) {
1012      var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function";
1013  
1014      if (!sinon && commonJSModule) {
1015          sinon = require("../sinon");
1016      }
1017  
1018      if (!sinon) {
1019          return;
1020      }
1021  
1022      function assertType(value, type, name) {
1023          var actual = sinon.typeOf(value);
1024          if (actual !== type) {
1025              throw new TypeError("Expected type of " + name + " to be " +
1026                  type + ", but was " + actual);
1027          }
1028      }
1029  
1030      var matcher = {
1031          toString: function () {
1032              return this.message;
1033          }
1034      };
1035  
1036      function isMatcher(object) {
1037          return matcher.isPrototypeOf(object);
1038      }
1039  
1040      function matchObject(expectation, actual) {
1041          if (actual === null || actual === undefined) {
1042              return false;
1043          }
1044          for (var key in expectation) {
1045              if (expectation.hasOwnProperty(key)) {
1046                  var exp = expectation[key];
1047                  var act = actual[key];
1048                  if (match.isMatcher(exp)) {
1049                      if (!exp.test(act)) {
1050                          return false;
1051                      }
1052                  } else if (sinon.typeOf(exp) === "object") {
1053                      if (!matchObject(exp, act)) {
1054                          return false;
1055                      }
1056                  } else if (!sinon.deepEqual(exp, act)) {
1057                      return false;
1058                  }
1059              }
1060          }
1061          return true;
1062      }
1063  
1064      matcher.or = function (m2) {
1065          if (!arguments.length) {
1066              throw new TypeError("Matcher expected");
1067          } else if (!isMatcher(m2)) {
1068              m2 = match(m2);
1069          }
1070          var m1 = this;
1071          var or = sinon.create(matcher);
1072          or.test = function (actual) {
1073              return m1.test(actual) || m2.test(actual);
1074          };
1075          or.message = m1.message + ".or(" + m2.message + ")";
1076          return or;
1077      };
1078  
1079      matcher.and = function (m2) {
1080          if (!arguments.length) {
1081              throw new TypeError("Matcher expected");
1082          } else if (!isMatcher(m2)) {
1083              m2 = match(m2);
1084          }
1085          var m1 = this;
1086          var and = sinon.create(matcher);
1087          and.test = function (actual) {
1088              return m1.test(actual) && m2.test(actual);
1089          };
1090          and.message = m1.message + ".and(" + m2.message + ")";
1091          return and;
1092      };
1093  
1094      var match = function (expectation, message) {
1095          var m = sinon.create(matcher);
1096          var type = sinon.typeOf(expectation);
1097          switch (type) {
1098          case "object":
1099              if (typeof expectation.test === "function") {
1100                  m.test = function (actual) {
1101                      return expectation.test(actual) === true;
1102                  };
1103                  m.message = "match(" + sinon.functionName(expectation.test) + ")";
1104                  return m;
1105              }
1106              var str = [];
1107              for (var key in expectation) {
1108                  if (expectation.hasOwnProperty(key)) {
1109                      str.push(key + ": " + expectation[key]);
1110                  }
1111              }
1112              m.test = function (actual) {
1113                  return matchObject(expectation, actual);
1114              };
1115              m.message = "match(" + str.join(", ") + ")";
1116              break;
1117          case "number":
1118              m.test = function (actual) {
1119                  return expectation == actual;
1120              };
1121              break;
1122          case "string":
1123              m.test = function (actual) {
1124                  if (typeof actual !== "string") {
1125                      return false;
1126                  }
1127                  return actual.indexOf(expectation) !== -1;
1128              };
1129              m.message = "match(\"" + expectation + "\")";
1130              break;
1131          case "regexp":
1132              m.test = function (actual) {
1133                  if (typeof actual !== "string") {
1134                      return false;
1135                  }
1136                  return expectation.test(actual);
1137              };
1138              break;
1139          case "function":
1140              m.test = expectation;
1141              if (message) {
1142                  m.message = message;
1143              } else {
1144                  m.message = "match(" + sinon.functionName(expectation) + ")";
1145              }
1146              break;
1147          default:
1148              m.test = function (actual) {
1149                return sinon.deepEqual(expectation, actual);
1150              };
1151          }
1152          if (!m.message) {
1153              m.message = "match(" + expectation + ")";
1154          }
1155          return m;
1156      };
1157  
1158      match.isMatcher = isMatcher;
1159  
1160      match.any = match(function () {
1161          return true;
1162      }, "any");
1163  
1164      match.defined = match(function (actual) {
1165          return actual !== null && actual !== undefined;
1166      }, "defined");
1167  
1168      match.truthy = match(function (actual) {
1169          return !!actual;
1170      }, "truthy");
1171  
1172      match.falsy = match(function (actual) {
1173          return !actual;
1174      }, "falsy");
1175  
1176      match.same = function (expectation) {
1177          return match(function (actual) {
1178              return expectation === actual;
1179          }, "same(" + expectation + ")");
1180      };
1181  
1182      match.typeOf = function (type) {
1183          assertType(type, "string", "type");
1184          return match(function (actual) {
1185              return sinon.typeOf(actual) === type;
1186          }, "typeOf(\"" + type + "\")");
1187      };
1188  
1189      match.instanceOf = function (type) {
1190          assertType(type, "function", "type");
1191          return match(function (actual) {
1192              return actual instanceof type;
1193          }, "instanceOf(" + sinon.functionName(type) + ")");
1194      };
1195  
1196      function createPropertyMatcher(propertyTest, messagePrefix) {
1197          return function (property, value) {
1198              assertType(property, "string", "property");
1199              var onlyProperty = arguments.length === 1;
1200              var message = messagePrefix + "(\"" + property + "\"";
1201              if (!onlyProperty) {
1202                  message += ", " + value;
1203              }
1204              message += ")";
1205              return match(function (actual) {
1206                  if (actual === undefined || actual === null ||
1207                          !propertyTest(actual, property)) {
1208                      return false;
1209                  }
1210                  return onlyProperty || sinon.deepEqual(value, actual[property]);
1211              }, message);
1212          };
1213      }
1214  
1215      match.has = createPropertyMatcher(function (actual, property) {
1216          if (typeof actual === "object") {
1217              return property in actual;
1218          }
1219          return actual[property] !== undefined;
1220      }, "has");
1221  
1222      match.hasOwn = createPropertyMatcher(function (actual, property) {
1223          return actual.hasOwnProperty(property);
1224      }, "hasOwn");
1225  
1226      match.bool = match.typeOf("boolean");
1227      match.number = match.typeOf("number");
1228      match.string = match.typeOf("string");
1229      match.object = match.typeOf("object");
1230      match.func = match.typeOf("function");
1231      match.array = match.typeOf("array");
1232      match.regexp = match.typeOf("regexp");
1233      match.date = match.typeOf("date");
1234  
1235      sinon.match = match;
1236  
1237      if (typeof define === "function" && define.amd) {
1238          define(["module"], function(module) { module.exports = match; });
1239      } else if (commonJSModule) {
1240          module.exports = match;
1241      }
1242  }(typeof sinon == "object" && sinon || null));
1243  
1244  /**
1245    * @depend ../sinon.js
1246    * @depend match.js
1247    */
1248  /*jslint eqeqeq: false, onevar: false, plusplus: false*/
1249  /*global module, require, sinon*/
1250  /**
1251    * Spy calls
1252    *
1253    * @author Christian Johansen ([email protected])
1254    * @author Maximilian Antoni ([email protected])
1255    * @license BSD
1256    *
1257    * Copyright (c) 2010-2013 Christian Johansen
1258    * Copyright (c) 2013 Maximilian Antoni
1259    */
1260  
1261  (function (sinon) {
1262      var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function";
1263      if (!sinon && commonJSModule) {
1264          sinon = require("../sinon");
1265      }
1266  
1267      if (!sinon) {
1268          return;
1269      }
1270  
1271      function throwYieldError(proxy, text, args) {
1272          var msg = sinon.functionName(proxy) + text;
1273          if (args.length) {
1274              msg += " Received [" + slice.call(args).join(", ") + "]";
1275          }
1276          throw new Error(msg);
1277      }
1278  
1279      var slice = Array.prototype.slice;
1280  
1281      var callProto = {
1282          calledOn: function calledOn(thisValue) {
1283              if (sinon.match && sinon.match.isMatcher(thisValue)) {
1284                  return thisValue.test(this.thisValue);
1285              }
1286              return this.thisValue === thisValue;
1287          },
1288  
1289          calledWith: function calledWith() {
1290              for (var i = 0, l = arguments.length; i < l; i += 1) {
1291                  if (!sinon.deepEqual(arguments[i], this.args[i])) {
1292                      return false;
1293                  }
1294              }
1295  
1296              return true;
1297          },
1298  
1299          calledWithMatch: function calledWithMatch() {
1300              for (var i = 0, l = arguments.length; i < l; i += 1) {
1301                  var actual = this.args[i];
1302                  var expectation = arguments[i];
1303                  if (!sinon.match || !sinon.match(expectation).test(actual)) {
1304                      return false;
1305                  }
1306              }
1307              return true;
1308          },
1309  
1310          calledWithExactly: function calledWithExactly() {
1311              return arguments.length == this.args.length &&
1312                  this.calledWith.apply(this, arguments);
1313          },
1314  
1315          notCalledWith: function notCalledWith() {
1316              return !this.calledWith.apply(this, arguments);
1317          },
1318  
1319          notCalledWithMatch: function notCalledWithMatch() {
1320              return !this.calledWithMatch.apply(this, arguments);
1321          },
1322  
1323          returned: function returned(value) {
1324              return sinon.deepEqual(value, this.returnValue);
1325          },
1326  
1327          threw: function threw(error) {
1328              if (typeof error === "undefined" || !this.exception) {
1329                  return !!this.exception;
1330              }
1331  
1332              return this.exception === error || this.exception.name === error;
1333          },
1334  
1335          calledWithNew: function calledWithNew() {
1336              return this.proxy.prototype && this.thisValue instanceof this.proxy;
1337          },
1338  
1339          calledBefore: function (other) {
1340              return this.callId < other.callId;
1341          },
1342  
1343          calledAfter: function (other) {
1344              return this.callId > other.callId;
1345          },
1346  
1347          callArg: function (pos) {
1348              this.args[pos]();
1349          },
1350  
1351          callArgOn: function (pos, thisValue) {
1352              this.args[pos].apply(thisValue);
1353          },
1354  
1355          callArgWith: function (pos) {
1356              this.callArgOnWith.apply(this, [pos, null].concat(slice.call(arguments, 1)));
1357          },
1358  
1359          callArgOnWith: function (pos, thisValue) {
1360              var args = slice.call(arguments, 2);
1361              this.args[pos].apply(thisValue, args);
1362          },
1363  
1364          "yield": function () {
1365              this.yieldOn.apply(this, [null].concat(slice.call(arguments, 0)));
1366          },
1367  
1368          yieldOn: function (thisValue) {
1369              var args = this.args;
1370              for (var i = 0, l = args.length; i < l; ++i) {
1371                  if (typeof args[i] === "function") {
1372                      args[i].apply(thisValue, slice.call(arguments, 1));
1373                      return;
1374                  }
1375              }
1376              throwYieldError(this.proxy, " cannot yield since no callback was passed.", args);
1377          },
1378  
1379          yieldTo: function (prop) {
1380              this.yieldToOn.apply(this, [prop, null].concat(slice.call(arguments, 1)));
1381          },
1382  
1383          yieldToOn: function (prop, thisValue) {
1384              var args = this.args;
1385              for (var i = 0, l = args.length; i < l; ++i) {
1386                  if (args[i] && typeof args[i][prop] === "function") {
1387                      args[i][prop].apply(thisValue, slice.call(arguments, 2));
1388                      return;
1389                  }
1390              }
1391              throwYieldError(this.proxy, " cannot yield to '" + prop +
1392                  "' since no callback was passed.", args);
1393          },
1394  
1395          toString: function () {
1396              var callStr = this.proxy.toString() + "(";
1397              var args = [];
1398  
1399              for (var i = 0, l = this.args.length; i < l; ++i) {
1400                  args.push(sinon.format(this.args[i]));
1401              }
1402  
1403              callStr = callStr + args.join(", ") + ")";
1404  
1405              if (typeof this.returnValue != "undefined") {
1406                  callStr += " => " + sinon.format(this.returnValue);
1407              }
1408  
1409              if (this.exception) {
1410                  callStr += " !" + this.exception.name;
1411  
1412                  if (this.exception.message) {
1413                      callStr += "(" + this.exception.message + ")";
1414                  }
1415              }
1416  
1417              return callStr;
1418          }
1419      };
1420  
1421      callProto.invokeCallback = callProto.yield;
1422  
1423      function createSpyCall(spy, thisValue, args, returnValue, exception, id) {
1424          if (typeof id !== "number") {
1425              throw new TypeError("Call id is not a number");
1426          }
1427          var proxyCall = sinon.create(callProto);
1428          proxyCall.proxy = spy;
1429          proxyCall.thisValue = thisValue;
1430          proxyCall.args = args;
1431          proxyCall.returnValue = returnValue;
1432          proxyCall.exception = exception;
1433          proxyCall.callId = id;
1434  
1435          return proxyCall;
1436      }
1437      createSpyCall.toString = callProto.toString; // used by mocks
1438  
1439      sinon.spyCall = createSpyCall;
1440  
1441      if (typeof define === "function" && define.amd) {
1442          define(["module"], function(module) { module.exports = createSpyCall; });
1443      } else if (commonJSModule) {
1444          module.exports = createSpyCall;
1445      }
1446  }(typeof sinon == "object" && sinon || null));
1447  
1448  
1449  /**
1450    * @depend ../sinon.js
1451    * @depend call.js
1452    */
1453  /*jslint eqeqeq: false, onevar: false, plusplus: false*/
1454  /*global module, require, sinon*/
1455  /**
1456    * Spy functions
1457    *
1458    * @author Christian Johansen ([email protected])
1459    * @license BSD
1460    *
1461    * Copyright (c) 2010-2013 Christian Johansen
1462    */
1463  
1464  (function (sinon) {
1465      var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function";
1466      var push = Array.prototype.push;
1467      var slice = Array.prototype.slice;
1468      var callId = 0;
1469  
1470      if (!sinon && commonJSModule) {
1471          sinon = require("../sinon");
1472      }
1473  
1474      if (!sinon) {
1475          return;
1476      }
1477  
1478      function spy(object, property) {
1479          if (!property && typeof object == "function") {
1480              return spy.create(object);
1481          }
1482  
1483          if (!object && !property) {
1484              return spy.create(function () { });
1485          }
1486  
1487          var method = object[property];
1488          return sinon.wrapMethod(object, property, spy.create(method));
1489      }
1490  
1491      function matchingFake(fakes, args, strict) {
1492          if (!fakes) {
1493              return;
1494          }
1495  
1496          for (var i = 0, l = fakes.length; i < l; i++) {
1497              if (fakes[i].matches(args, strict)) {
1498                  return fakes[i];
1499              }
1500          }
1501      }
1502  
1503      function incrementCallCount() {
1504          this.called = true;
1505          this.callCount += 1;
1506          this.notCalled = false;
1507          this.calledOnce = this.callCount == 1;
1508          this.calledTwice = this.callCount == 2;
1509          this.calledThrice = this.callCount == 3;
1510      }
1511  
1512      function createCallProperties() {
1513          this.firstCall = this.getCall(0);
1514          this.secondCall = this.getCall(1);
1515          this.thirdCall = this.getCall(2);
1516          this.lastCall = this.getCall(this.callCount - 1);
1517      }
1518  
1519      var vars = "a,b,c,d,e,f,g,h,i,j,k,l";
1520      function createProxy(func) {
1521          // Retain the function length:
1522          var p;
1523          if (func.length) {
1524              eval("p = (function proxy(" + vars.substring(0, func.length * 2 - 1) +
1525                  ") { return p.invoke(func, this, slice.call(arguments)); });");
1526          }
1527          else {
1528              p = function proxy() {
1529                  return p.invoke(func, this, slice.call(arguments));
1530              };
1531          }
1532          return p;
1533      }
1534  
1535      var uuid = 0;
1536  
1537      // Public API
1538      var spyApi = {
1539          reset: function () {
1540              this.called = false;
1541              this.notCalled = true;
1542              this.calledOnce = false;
1543              this.calledTwice = false;
1544              this.calledThrice = false;
1545              this.callCount = 0;
1546              this.firstCall = null;
1547              this.secondCall = null;
1548              this.thirdCall = null;
1549              this.lastCall = null;
1550              this.args = [];
1551              this.returnValues = [];
1552              this.thisValues = [];
1553              this.exceptions = [];
1554              this.callIds = [];
1555              if (this.fakes) {
1556                  for (var i = 0; i < this.fakes.length; i++) {
1557                      this.fakes[i].reset();
1558                  }
1559              }
1560          },
1561  
1562          create: function create(func) {
1563              var name;
1564  
1565              if (typeof func != "function") {
1566                  func = function () { };
1567              } else {
1568                  name = sinon.functionName(func);
1569              }
1570  
1571              var proxy = createProxy(func);
1572  
1573              sinon.extend(proxy, spy);
1574              delete proxy.create;
1575              sinon.extend(proxy, func);
1576  
1577              proxy.reset();
1578              proxy.prototype = func.prototype;
1579              proxy.displayName = name || "spy";
1580              proxy.toString = sinon.functionToString;
1581              proxy._create = sinon.spy.create;
1582              proxy.id = "spy#" + uuid++;
1583  
1584              return proxy;
1585          },
1586  
1587          invoke: function invoke(func, thisValue, args) {
1588              var matching = matchingFake(this.fakes, args);
1589              var exception, returnValue;
1590  
1591              incrementCallCount.call(this);
1592              push.call(this.thisValues, thisValue);
1593              push.call(this.args, args);
1594              push.call(this.callIds, callId++);
1595  
1596              // Make call properties available from within the spied function:
1597              createCallProperties.call(this);
1598  
1599              try {
1600                  if (matching) {
1601                      returnValue = matching.invoke(func, thisValue, args);
1602                  } else {
1603                      returnValue = (this.func || func).apply(thisValue, args);
1604                  }
1605  
1606                  var thisCall = this.getCall(this.callCount - 1);
1607                  if (thisCall.calledWithNew() && typeof returnValue !== 'object') {
1608                      returnValue = thisValue;
1609                  }
1610              } catch (e) {
1611                  exception = e;
1612              }
1613  
1614              push.call(this.exceptions, exception);
1615              push.call(this.returnValues, returnValue);
1616  
1617              // Make return value and exception available in the calls:
1618              createCallProperties.call(this);
1619  
1620              if (exception !== undefined) {
1621                  throw exception;
1622              }
1623  
1624              return returnValue;
1625          },
1626  
1627          named: function named(name) {
1628              this.displayName = name;
1629              return this;
1630          },
1631  
1632          getCall: function getCall(i) {
1633              if (i < 0 || i >= this.callCount) {
1634                  return null;
1635              }
1636  
1637              return sinon.spyCall(this, this.thisValues[i], this.args[i],
1638                                      this.returnValues[i], this.exceptions[i],
1639                                      this.callIds[i]);
1640          },
1641  
1642          getCalls: function () {
1643              var calls = [];
1644              var i;
1645  
1646              for (i = 0; i < this.callCount; i++) {
1647                  calls.push(this.getCall(i));
1648              }
1649  
1650              return calls;
1651          },
1652  
1653          calledBefore: function calledBefore(spyFn) {
1654              if (!this.called) {
1655                  return false;
1656              }
1657  
1658              if (!spyFn.called) {
1659                  return true;
1660              }
1661  
1662              return this.callIds[0] < spyFn.callIds[spyFn.callIds.length - 1];
1663          },
1664  
1665          calledAfter: function calledAfter(spyFn) {
1666              if (!this.called || !spyFn.called) {
1667                  return false;
1668              }
1669  
1670              return this.callIds[this.callCount - 1] > spyFn.callIds[spyFn.callCount - 1];
1671          },
1672  
1673          withArgs: function () {
1674              var args = slice.call(arguments);
1675  
1676              if (this.fakes) {
1677                  var match = matchingFake(this.fakes, args, true);
1678  
1679                  if (match) {
1680                      return match;
1681                  }
1682              } else {
1683                  this.fakes = [];
1684              }
1685  
1686              var original = this;
1687              var fake = this._create();
1688              fake.matchingAguments = args;
1689              fake.parent = this;
1690              push.call(this.fakes, fake);
1691  
1692              fake.withArgs = function () {
1693                  return original.withArgs.apply(original, arguments);
1694              };
1695  
1696              for (var i = 0; i < this.args.length; i++) {
1697                  if (fake.matches(this.args[i])) {
1698                      incrementCallCount.call(fake);
1699                      push.call(fake.thisValues, this.thisValues[i]);
1700                      push.call(fake.args, this.args[i]);
1701                      push.call(fake.returnValues, this.returnValues[i]);
1702                      push.call(fake.exceptions, this.exceptions[i]);
1703                      push.call(fake.callIds, this.callIds[i]);
1704                  }
1705              }
1706              createCallProperties.call(fake);
1707  
1708              return fake;
1709          },
1710  
1711          matches: function (args, strict) {
1712              var margs = this.matchingAguments;
1713  
1714              if (margs.length <= args.length &&
1715                  sinon.deepEqual(margs, args.slice(0, margs.length))) {
1716                  return !strict || margs.length == args.length;
1717              }
1718          },
1719  
1720          printf: function (format) {
1721              var spy = this;
1722              var args = slice.call(arguments, 1);
1723              var formatter;
1724  
1725              return (format || "").replace(/%(.)/g, function (match, specifyer) {
1726                  formatter = spyApi.formatters[specifyer];
1727  
1728                  if (typeof formatter == "function") {
1729                      return formatter.call(null, spy, args);
1730                  } else if (!isNaN(parseInt(specifyer, 10))) {
1731                      return sinon.format(args[specifyer - 1]);
1732                  }
1733  
1734                  return "%" + specifyer;
1735              });
1736          }
1737      };
1738  
1739      function delegateToCalls(method, matchAny, actual, notCalled) {
1740          spyApi[method] = function () {
1741              if (!this.called) {
1742                  if (notCalled) {
1743                      return notCalled.apply(this, arguments);
1744                  }
1745                  return false;
1746              }
1747  
1748              var currentCall;
1749              var matches = 0;
1750  
1751              for (var i = 0, l = this.callCount; i < l; i += 1) {
1752                  currentCall = this.getCall(i);
1753  
1754                  if (currentCall[actual || method].apply(currentCall, arguments)) {
1755                      matches += 1;
1756  
1757                      if (matchAny) {
1758                          return true;
1759                      }
1760                  }
1761              }
1762  
1763              return matches === this.callCount;
1764          };
1765      }
1766  
1767      delegateToCalls("calledOn", true);
1768      delegateToCalls("alwaysCalledOn", false, "calledOn");
1769      delegateToCalls("calledWith", true);
1770      delegateToCalls("calledWithMatch", true);
1771      delegateToCalls("alwaysCalledWith", false, "calledWith");
1772      delegateToCalls("alwaysCalledWithMatch", false, "calledWithMatch");
1773      delegateToCalls("calledWithExactly", true);
1774      delegateToCalls("alwaysCalledWithExactly", false, "calledWithExactly");
1775      delegateToCalls("neverCalledWith", false, "notCalledWith",
1776          function () { return true; });
1777      delegateToCalls("neverCalledWithMatch", false, "notCalledWithMatch",
1778          function () { return true; });
1779      delegateToCalls("threw", true);
1780      delegateToCalls("alwaysThrew", false, "threw");
1781      delegateToCalls("returned", true);
1782      delegateToCalls("alwaysReturned", false, "returned");
1783      delegateToCalls("calledWithNew", true);
1784      delegateToCalls("alwaysCalledWithNew", false, "calledWithNew");
1785      delegateToCalls("callArg", false, "callArgWith", function () {
1786          throw new Error(this.toString() + " cannot call arg since it was not yet invoked.");
1787      });
1788      spyApi.callArgWith = spyApi.callArg;
1789      delegateToCalls("callArgOn", false, "callArgOnWith", function () {
1790          throw new Error(this.toString() + " cannot call arg since it was not yet invoked.");
1791      });
1792      spyApi.callArgOnWith = spyApi.callArgOn;
1793      delegateToCalls("yield", false, "yield", function () {
1794          throw new Error(this.toString() + " cannot yield since it was not yet invoked.");
1795      });
1796      // "invokeCallback" is an alias for "yield" since "yield" is invalid in strict mode.
1797      spyApi.invokeCallback = spyApi.yield;
1798      delegateToCalls("yieldOn", false, "yieldOn", function () {
1799          throw new Error(this.toString() + " cannot yield since it was not yet invoked.");
1800      });
1801      delegateToCalls("yieldTo", false, "yieldTo", function (property) {
1802          throw new Error(this.toString() + " cannot yield to '" + property +
1803              "' since it was not yet invoked.");
1804      });
1805      delegateToCalls("yieldToOn", false, "yieldToOn", function (property) {
1806          throw new Error(this.toString() + " cannot yield to '" + property +
1807              "' since it was not yet invoked.");
1808      });
1809  
1810      spyApi.formatters = {
1811          "c": function (spy) {
1812              return sinon.timesInWords(spy.callCount);
1813          },
1814  
1815          "n": function (spy) {
1816              return spy.toString();
1817          },
1818  
1819          "C": function (spy) {
1820              var calls = [];
1821  
1822              for (var i = 0, l = spy.callCount; i < l; ++i) {
1823                  var stringifiedCall = "    " + spy.getCall(i).toString();
1824                  if (/\n/.test(calls[i - 1])) {
1825                      stringifiedCall = "\n" + stringifiedCall;
1826                  }
1827                  push.call(calls, stringifiedCall);
1828              }
1829  
1830              return calls.length > 0 ? "\n" + calls.join("\n") : "";
1831          },
1832  
1833          "t": function (spy) {
1834              var objects = [];
1835  
1836              for (var i = 0, l = spy.callCount; i < l; ++i) {
1837                  push.call(objects, sinon.format(spy.thisValues[i]));
1838              }
1839  
1840              return objects.join(", ");
1841          },
1842  
1843          "*": function (spy, args) {
1844              var formatted = [];
1845  
1846              for (var i = 0, l = args.length; i < l; ++i) {
1847                  push.call(formatted, sinon.format(args[i]));
1848              }
1849  
1850              return formatted.join(", ");
1851          }
1852      };
1853  
1854      sinon.extend(spy, spyApi);
1855  
1856      spy.spyCall = sinon.spyCall;
1857      sinon.spy = spy;
1858  
1859      if (typeof define === "function" && define.amd) {
1860          define(["module"], function(module) { module.exports = spy; });
1861      } else if (commonJSModule) {
1862          module.exports = spy;
1863      }
1864  }(typeof sinon == "object" && sinon || null));
1865  
1866  /**
1867   * @depend ../sinon.js
1868   */
1869  /*jslint eqeqeq: false, onevar: false*/
1870  /*global module, require, sinon, process, setImmediate, setTimeout*/
1871  /**
1872   * Stub behavior
1873   *
1874   * @author Christian Johansen ([email protected])
1875   * @author Tim Fischbach ([email protected])
1876   * @license BSD
1877   *
1878   * Copyright (c) 2010-2013 Christian Johansen
1879   */
1880  
1881  (function (sinon) {
1882      var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function";
1883  
1884      if (!sinon && commonJSModule) {
1885          sinon = require("../sinon");
1886      }
1887  
1888      if (!sinon) {
1889          return;
1890      }
1891  
1892      var slice = Array.prototype.slice;
1893      var join = Array.prototype.join;
1894      var proto;
1895  
1896      var nextTick = (function () {
1897          if (typeof process === "object" && typeof process.nextTick === "function") {
1898              return process.nextTick;
1899          } else if (typeof setImmediate === "function") {
1900              return setImmediate;
1901          } else {
1902              return function (callback) {
1903                  setTimeout(callback, 0);
1904              };
1905          }
1906      })();
1907  
1908      function throwsException(error, message) {
1909          if (typeof error == "string") {
1910              this.exception = new Error(message || "");
1911              this.exception.name = error;
1912          } else if (!error) {
1913              this.exception = new Error("Error");
1914          } else {
1915              this.exception = error;
1916          }
1917  
1918          return this;
1919      }
1920  
1921      function getCallback(behavior, args) {
1922          var callArgAt = behavior.callArgAt;
1923  
1924          if (callArgAt < 0) {
1925              var callArgProp = behavior.callArgProp;
1926  
1927              for (var i = 0, l = args.length; i < l; ++i) {
1928                  if (!callArgProp && typeof args[i] == "function") {
1929                      return args[i];
1930                  }
1931  
1932                  if (callArgProp && args[i] &&
1933                      typeof args[i][callArgProp] == "function") {
1934                      return args[i][callArgProp];
1935                  }
1936              }
1937  
1938              return null;
1939          }
1940  
1941          return args[callArgAt];
1942      }
1943  
1944      function getCallbackError(behavior, func, args) {
1945          if (behavior.callArgAt < 0) {
1946              var msg;
1947  
1948              if (behavior.callArgProp) {
1949                  msg = sinon.functionName(behavior.stub) +
1950                      " expected to yield to '" + behavior.callArgProp +
1951                      "', but no object with such a property was passed.";
1952              } else {
1953                  msg = sinon.functionName(behavior.stub) +
1954                      " expected to yield, but no callback was passed.";
1955              }
1956  
1957              if (args.length > 0) {
1958                  msg += " Received [" + join.call(args, ", ") + "]";
1959              }
1960  
1961              return msg;
1962          }
1963  
1964          return "argument at index " + behavior.callArgAt + " is not a function: " + func;
1965      }
1966  
1967      function callCallback(behavior, args) {
1968          if (typeof behavior.callArgAt == "number") {
1969              var func = getCallback(behavior, args);
1970  
1971              if (typeof func != "function") {
1972                  throw new TypeError(getCallbackError(behavior, func, args));
1973              }
1974  
1975              if (behavior.callbackAsync) {
1976                  nextTick(function() {
1977                      func.apply(behavior.callbackContext, behavior.callbackArguments);
1978                  });
1979              } else {
1980                  func.apply(behavior.callbackContext, behavior.callbackArguments);
1981              }
1982          }
1983      }
1984  
1985      proto = {
1986          create: function(stub) {
1987              var behavior = sinon.extend({}, sinon.behavior);
1988              delete behavior.create;
1989              behavior.stub = stub;
1990  
1991              return behavior;
1992          },
1993  
1994          isPresent: function() {
1995              return (typeof this.callArgAt == 'number' ||
1996                      this.exception ||
1997                      typeof this.returnArgAt == 'number' ||
1998                      this.returnThis ||
1999                      this.returnValueDefined);
2000          },
2001  
2002          invoke: function(context, args) {
2003              callCallback(this, args);
2004  
2005              if (this.exception) {
2006                  throw this.exception;
2007              } else if (typeof this.returnArgAt == 'number') {
2008                  return args[this.returnArgAt];
2009              } else if (this.returnThis) {
2010                  return context;
2011              }
2012  
2013              return this.returnValue;
2014          },
2015  
2016          onCall: function(index) {
2017              return this.stub.onCall(index);
2018          },
2019  
2020          onFirstCall: function() {
2021              return this.stub.onFirstCall();
2022          },
2023  
2024          onSecondCall: function() {
2025              return this.stub.onSecondCall();
2026          },
2027  
2028          onThirdCall: function() {
2029              return this.stub.onThirdCall();
2030          },
2031  
2032          withArgs: function(/* arguments */) {
2033              throw new Error('Defining a stub by invoking "stub.onCall(...).withArgs(...)" is not supported. ' +
2034                              'Use "stub.withArgs(...).onCall(...)" to define sequential behavior for calls with certain arguments.');
2035          },
2036  
2037          callsArg: function callsArg(pos) {
2038              if (typeof pos != "number") {
2039                  throw new TypeError("argument index is not number");
2040              }
2041  
2042              this.callArgAt = pos;
2043              this.callbackArguments = [];
2044              this.callbackContext = undefined;
2045              this.callArgProp = undefined;
2046              this.callbackAsync = false;
2047  
2048              return this;
2049          },
2050  
2051          callsArgOn: function callsArgOn(pos, context) {
2052              if (typeof pos != "number") {
2053                  throw new TypeError("argument index is not number");
2054              }
2055              if (typeof context != "object") {
2056                  throw new TypeError("argument context is not an object");
2057              }
2058  
2059              this.callArgAt = pos;
2060              this.callbackArguments = [];
2061              this.callbackContext = context;
2062              this.callArgProp = undefined;
2063              this.callbackAsync = false;
2064  
2065              return this;
2066          },
2067  
2068          callsArgWith: function callsArgWith(pos) {
2069              if (typeof pos != "number") {
2070                  throw new TypeError("argument index is not number");
2071              }
2072  
2073              this.callArgAt = pos;
2074              this.callbackArguments = slice.call(arguments, 1);
2075              this.callbackContext = undefined;
2076              this.callArgProp = undefined;
2077              this.callbackAsync = false;
2078  
2079              return this;
2080          },
2081  
2082          callsArgOnWith: function callsArgWith(pos, context) {
2083              if (typeof pos != "number") {
2084                  throw new TypeError("argument index is not number");
2085              }
2086              if (typeof context != "object") {
2087                  throw new TypeError("argument context is not an object");
2088              }
2089  
2090              this.callArgAt = pos;
2091              this.callbackArguments = slice.call(arguments, 2);
2092              this.callbackContext = context;
2093              this.callArgProp = undefined;
2094              this.callbackAsync = false;
2095  
2096              return this;
2097          },
2098  
2099          yields: function () {
2100              this.callArgAt = -1;
2101              this.callbackArguments = slice.call(arguments, 0);
2102              this.callbackContext = undefined;
2103              this.callArgProp = undefined;
2104              this.callbackAsync = false;
2105  
2106              return this;
2107          },
2108  
2109          yieldsOn: function (context) {
2110              if (typeof context != "object") {
2111                  throw new TypeError("argument context is not an object");
2112              }
2113  
2114              this.callArgAt = -1;
2115              this.callbackArguments = slice.call(arguments, 1);
2116              this.callbackContext = context;
2117              this.callArgProp = undefined;
2118              this.callbackAsync = false;
2119  
2120              return this;
2121          },
2122  
2123          yieldsTo: function (prop) {
2124              this.callArgAt = -1;
2125              this.callbackArguments = slice.call(arguments, 1);
2126              this.callbackContext = undefined;
2127              this.callArgProp = prop;
2128              this.callbackAsync = false;
2129  
2130              return this;
2131          },
2132  
2133          yieldsToOn: function (prop, context) {
2134              if (typeof context != "object") {
2135                  throw new TypeError("argument context is not an object");
2136              }
2137  
2138              this.callArgAt = -1;
2139              this.callbackArguments = slice.call(arguments, 2);
2140              this.callbackContext = context;
2141              this.callArgProp = prop;
2142              this.callbackAsync = false;
2143  
2144              return this;
2145          },
2146  
2147  
2148          "throws": throwsException,
2149          throwsException: throwsException,
2150  
2151          returns: function returns(value) {
2152              this.returnValue = value;
2153              this.returnValueDefined = true;
2154  
2155              return this;
2156          },
2157  
2158          returnsArg: function returnsArg(pos) {
2159              if (typeof pos != "number") {
2160                  throw new TypeError("argument index is not number");
2161              }
2162  
2163              this.returnArgAt = pos;
2164  
2165              return this;
2166          },
2167  
2168          returnsThis: function returnsThis() {
2169              this.returnThis = true;
2170  
2171              return this;
2172          }
2173      };
2174  
2175      // create asynchronous versions of callsArg* and yields* methods
2176      for (var method in proto) {
2177          // need to avoid creating anotherasync versions of the newly added async methods
2178          if (proto.hasOwnProperty(method) &&
2179              method.match(/^(callsArg|yields)/) &&
2180              !method.match(/Async/)) {
2181              proto[method + 'Async'] = (function (syncFnName) {
2182                  return function () {
2183                      var result = this[syncFnName].apply(this, arguments);
2184                      this.callbackAsync = true;
2185                      return result;
2186                  };
2187              })(method);
2188          }
2189      }
2190  
2191      sinon.behavior = proto;
2192  
2193      if (typeof define === "function" && define.amd) {
2194          define(["module"], function(module) { module.exports = proto; });
2195      } else if (commonJSModule) {
2196          module.exports = proto;
2197      }
2198  }(typeof sinon == "object" && sinon || null));
2199  
2200  /**
2201   * @depend ../sinon.js
2202   * @depend spy.js
2203   * @depend behavior.js
2204   */
2205  /*jslint eqeqeq: false, onevar: false*/
2206  /*global module, require, sinon*/
2207  /**
2208   * Stub functions
2209   *
2210   * @author Christian Johansen ([email protected])
2211   * @license BSD
2212   *
2213   * Copyright (c) 2010-2013 Christian Johansen
2214   */
2215  
2216  (function (sinon) {
2217      var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function";
2218  
2219      if (!sinon && commonJSModule) {
2220          sinon = require("../sinon");
2221      }
2222  
2223      if (!sinon) {
2224          return;
2225      }
2226  
2227      function stub(object, property, func) {
2228          if (!!func && typeof func != "function") {
2229              throw new TypeError("Custom stub should be function");
2230          }
2231  
2232          var wrapper;
2233  
2234          if (func) {
2235              wrapper = sinon.spy && sinon.spy.create ? sinon.spy.create(func) : func;
2236          } else {
2237              wrapper = stub.create();
2238          }
2239  
2240          if (!object && typeof property === "undefined") {
2241              return sinon.stub.create();
2242          }
2243  
2244          if (typeof property === "undefined" && typeof object == "object") {
2245              for (var prop in object) {
2246                  if (typeof object[prop] === "function") {
2247                      stub(object, prop);
2248                  }
2249              }
2250  
2251              return object;
2252          }
2253  
2254          return sinon.wrapMethod(object, property, wrapper);
2255      }
2256  
2257      function getDefaultBehavior(stub) {
2258          return stub.defaultBehavior || getParentBehaviour(stub) || sinon.behavior.create(stub);
2259      }
2260  
2261      function getParentBehaviour(stub) {
2262          return (stub.parent && getCurrentBehavior(stub.parent));
2263      }
2264  
2265      function getCurrentBehavior(stub) {
2266          var behavior = stub.behaviors[stub.callCount - 1];
2267          return behavior && behavior.isPresent() ? behavior : getDefaultBehavior(stub);
2268      }
2269  
2270      var uuid = 0;
2271  
2272      sinon.extend(stub, (function () {
2273          var proto = {
2274              create: function create() {
2275                  var functionStub = function () {
2276                      return getCurrentBehavior(functionStub).invoke(this, arguments);
2277                  };
2278  
2279                  functionStub.id = "stub#" + uuid++;
2280                  var orig = functionStub;
2281                  functionStub = sinon.spy.create(functionStub);
2282                  functionStub.func = orig;
2283  
2284                  sinon.extend(functionStub, stub);
2285                  functionStub._create = sinon.stub.create;
2286                  functionStub.displayName = "stub";
2287                  functionStub.toString = sinon.functionToString;
2288  
2289                  functionStub.defaultBehavior = null;
2290                  functionStub.behaviors = [];
2291  
2292                  return functionStub;
2293              },
2294  
2295              resetBehavior: function () {
2296                  var i;
2297  
2298                  this.defaultBehavior = null;
2299                  this.behaviors = [];
2300  
2301                  delete this.returnValue;
2302                  delete this.returnArgAt;
2303                  this.returnThis = false;
2304  
2305                  if (this.fakes) {
2306                      for (i = 0; i < this.fakes.length; i++) {
2307                          this.fakes[i].resetBehavior();
2308                      }
2309                  }
2310              },
2311  
2312              onCall: function(index) {
2313                  if (!this.behaviors[index]) {
2314                      this.behaviors[index] = sinon.behavior.create(this);
2315                  }
2316  
2317                  return this.behaviors[index];
2318              },
2319  
2320              onFirstCall: function() {
2321                  return this.onCall(0);
2322              },
2323  
2324              onSecondCall: function() {
2325                  return this.onCall(1);
2326              },
2327  
2328              onThirdCall: function() {
2329                  return this.onCall(2);
2330              }
2331          };
2332  
2333          for (var method in sinon.behavior) {
2334              if (sinon.behavior.hasOwnProperty(method) &&
2335                  !proto.hasOwnProperty(method) &&
2336                  method != 'create' &&
2337                  method != 'withArgs' &&
2338                  method != 'invoke') {
2339                  proto[method] = (function(behaviorMethod) {
2340                      return function() {
2341                          this.defaultBehavior = this.defaultBehavior || sinon.behavior.create(this);
2342                          this.defaultBehavior[behaviorMethod].apply(this.defaultBehavior, arguments);
2343                          return this;
2344                      };
2345                  }(method));
2346              }
2347          }
2348  
2349          return proto;
2350      }()));
2351  
2352      sinon.stub = stub;
2353  
2354      if (typeof define === "function" && define.amd) {
2355          define(["module"], function(module) { module.exports = stub; });
2356      } else if (commonJSModule) {
2357          module.exports = stub;
2358      }
2359  }(typeof sinon == "object" && sinon || null));
2360  
2361  /**
2362   * @depend ../sinon.js
2363   * @depend stub.js
2364   */
2365  /*jslint eqeqeq: false, onevar: false, nomen: false*/
2366  /*global module, require, sinon*/
2367  /**
2368   * Mock functions.
2369   *
2370   * @author Christian Johansen ([email protected])
2371   * @license BSD
2372   *
2373   * Copyright (c) 2010-2013 Christian Johansen
2374   */
2375  
2376  (function (sinon) {
2377      var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function";
2378      var push = [].push;
2379      var match;
2380  
2381      if (!sinon && commonJSModule) {
2382          sinon = require("../sinon");
2383      }
2384  
2385      if (!sinon) {
2386          return;
2387      }
2388  
2389      match = sinon.match;
2390  
2391      if (!match && commonJSModule) {
2392          match = require("./match");
2393      }
2394  
2395      function mock(object) {
2396          if (!object) {
2397              return sinon.expectation.create("Anonymous mock");
2398          }
2399  
2400          return mock.create(object);
2401      }
2402  
2403      sinon.mock = mock;
2404  
2405      sinon.extend(mock, (function () {
2406          function each(collection, callback) {
2407              if (!collection) {
2408                  return;
2409              }
2410  
2411              for (var i = 0, l = collection.length; i < l; i += 1) {
2412                  callback(collection[i]);
2413              }
2414          }
2415  
2416          return {
2417              create: function create(object) {
2418                  if (!object) {
2419                      throw new TypeError("object is null");
2420                  }
2421  
2422                  var mockObject = sinon.extend({}, mock);
2423                  mockObject.object = object;
2424                  delete mockObject.create;
2425  
2426                  return mockObject;
2427              },
2428  
2429              expects: function expects(method) {
2430                  if (!method) {
2431                      throw new TypeError("method is falsy");
2432                  }
2433  
2434                  if (!this.expectations) {
2435                      this.expectations = {};
2436                      this.proxies = [];
2437                  }
2438  
2439                  if (!this.expectations[method]) {
2440                      this.expectations[method] = [];
2441                      var mockObject = this;
2442  
2443                      sinon.wrapMethod(this.object, method, function () {
2444                          return mockObject.invokeMethod(method, this, arguments);
2445                      });
2446  
2447                      push.call(this.proxies, method);
2448                  }
2449  
2450                  var expectation = sinon.expectation.create(method);
2451                  push.call(this.expectations[method], expectation);
2452  
2453                  return expectation;
2454              },
2455  
2456              restore: function restore() {
2457                  var object = this.object;
2458  
2459                  each(this.proxies, function (proxy) {
2460                      if (typeof object[proxy].restore == "function") {
2461                          object[proxy].restore();
2462                      }
2463                  });
2464              },
2465  
2466              verify: function verify() {
2467                  var expectations = this.expectations || {};
2468                  var messages = [], met = [];
2469  
2470                  each(this.proxies, function (proxy) {
2471                      each(expectations[proxy], function (expectation) {
2472                          if (!expectation.met()) {
2473                              push.call(messages, expectation.toString());
2474                          } else {
2475                              push.call(met, expectation.toString());
2476                          }
2477                      });
2478                  });
2479  
2480                  this.restore();
2481  
2482                  if (messages.length > 0) {
2483                      sinon.expectation.fail(messages.concat(met).join("\n"));
2484                  } else {
2485                      sinon.expectation.pass(messages.concat(met).join("\n"));
2486                  }
2487  
2488                  return true;
2489              },
2490  
2491              invokeMethod: function invokeMethod(method, thisValue, args) {
2492                  var expectations = this.expectations && this.expectations[method];
2493                  var length = expectations && expectations.length || 0, i;
2494  
2495                  for (i = 0; i < length; i += 1) {
2496                      if (!expectations[i].met() &&
2497                          expectations[i].allowsCall(thisValue, args)) {
2498                          return expectations[i].apply(thisValue, args);
2499                      }
2500                  }
2501  
2502                  var messages = [], available, exhausted = 0;
2503  
2504                  for (i = 0; i < length; i += 1) {
2505                      if (expectations[i].allowsCall(thisValue, args)) {
2506                          available = available || expectations[i];
2507                      } else {
2508                          exhausted += 1;
2509                      }
2510                      push.call(messages, "    " + expectations[i].toString());
2511                  }
2512  
2513                  if (exhausted === 0) {
2514                      return available.apply(thisValue, args);
2515                  }
2516  
2517                  messages.unshift("Unexpected call: " + sinon.spyCall.toString.call({
2518                      proxy: method,
2519                      args: args
2520                  }));
2521  
2522                  sinon.expectation.fail(messages.join("\n"));
2523              }
2524          };
2525      }()));
2526  
2527      var times = sinon.timesInWords;
2528  
2529      sinon.expectation = (function () {
2530          var slice = Array.prototype.slice;
2531          var _invoke = sinon.spy.invoke;
2532  
2533          function callCountInWords(callCount) {
2534              if (callCount == 0) {
2535                  return "never called";
2536              } else {
2537                  return "called " + times(callCount);
2538              }
2539          }
2540  
2541          function expectedCallCountInWords(expectation) {
2542              var min = expectation.minCalls;
2543              var max = expectation.maxCalls;
2544  
2545              if (typeof min == "number" && typeof max == "number") {
2546                  var str = times(min);
2547  
2548                  if (min != max) {
2549                      str = "at least " + str + " and at most " + times(max);
2550                  }
2551  
2552                  return str;
2553              }
2554  
2555              if (typeof min == "number") {
2556                  return "at least " + times(min);
2557              }
2558  
2559              return "at most " + times(max);
2560          }
2561  
2562          function receivedMinCalls(expectation) {
2563              var hasMinLimit = typeof expectation.minCalls == "number";
2564              return !hasMinLimit || expectation.callCount >= expectation.minCalls;
2565          }
2566  
2567          function receivedMaxCalls(expectation) {
2568              if (typeof expectation.maxCalls != "number") {
2569                  return false;
2570              }
2571  
2572              return expectation.callCount == expectation.maxCalls;
2573          }
2574  
2575          function verifyMatcher(possibleMatcher, arg){
2576              if (match && match.isMatcher(possibleMatcher)) {
2577                  return possibleMatcher.test(arg);
2578              } else {
2579                  return true;
2580              }
2581          }
2582  
2583          return {
2584              minCalls: 1,
2585              maxCalls: 1,
2586  
2587              create: function create(methodName) {
2588                  var expectation = sinon.extend(sinon.stub.create(), sinon.expectation);
2589                  delete expectation.create;
2590                  expectation.method = methodName;
2591  
2592                  return expectation;
2593              },
2594  
2595              invoke: function invoke(func, thisValue, args) {
2596                  this.verifyCallAllowed(thisValue, args);
2597  
2598                  return _invoke.apply(this, arguments);
2599              },
2600  
2601              atLeast: function atLeast(num) {
2602                  if (typeof num != "number") {
2603                      throw new TypeError("'" + num + "' is not number");
2604                  }
2605  
2606                  if (!this.limitsSet) {
2607                      this.maxCalls = null;
2608                      this.limitsSet = true;
2609                  }
2610  
2611                  this.minCalls = num;
2612  
2613                  return this;
2614              },
2615  
2616              atMost: function atMost(num) {
2617                  if (typeof num != "number") {
2618                      throw new TypeError("'" + num + "' is not number");
2619                  }
2620  
2621                  if (!this.limitsSet) {
2622                      this.minCalls = null;
2623                      this.limitsSet = true;
2624                  }
2625  
2626                  this.maxCalls = num;
2627  
2628                  return this;
2629              },
2630  
2631              never: function never() {
2632                  return this.exactly(0);
2633              },
2634  
2635              once: function once() {
2636                  return this.exactly(1);
2637              },
2638  
2639              twice: function twice() {
2640                  return this.exactly(2);
2641              },
2642  
2643              thrice: function thrice() {
2644                  return this.exactly(3);
2645              },
2646  
2647              exactly: function exactly(num) {
2648                  if (typeof num != "number") {
2649                      throw new TypeError("'" + num + "' is not a number");
2650                  }
2651  
2652                  this.atLeast(num);
2653                  return this.atMost(num);
2654              },
2655  
2656              met: function met() {
2657                  return !this.failed && receivedMinCalls(this);
2658              },
2659  
2660              verifyCallAllowed: function verifyCallAllowed(thisValue, args) {
2661                  if (receivedMaxCalls(this)) {
2662                      this.failed = true;
2663                      sinon.expectation.fail(this.method + " already called " + times(this.maxCalls));
2664                  }
2665  
2666                  if ("expectedThis" in this && this.expectedThis !== thisValue) {
2667                      sinon.expectation.fail(this.method + " called with " + thisValue + " as thisValue, expected " +
2668                          this.expectedThis);
2669                  }
2670  
2671                  if (!("expectedArguments" in this)) {
2672                      return;
2673                  }
2674  
2675                  if (!args) {
2676                      sinon.expectation.fail(this.method + " received no arguments, expected " +
2677                          sinon.format(this.expectedArguments));
2678                  }
2679  
2680                  if (args.length < this.expectedArguments.length) {
2681                      sinon.expectation.fail(this.method + " received too few arguments (" + sinon.format(args) +
2682                          "), expected " + sinon.format(this.expectedArguments));
2683                  }
2684  
2685                  if (this.expectsExactArgCount &&
2686                      args.length != this.expectedArguments.length) {
2687                      sinon.expectation.fail(this.method + " received too many arguments (" + sinon.format(args) +
2688                          "), expected " + sinon.format(this.expectedArguments));
2689                  }
2690  
2691                  for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {
2692  
2693                      if (!verifyMatcher(this.expectedArguments[i],args[i])) {
2694                          sinon.expectation.fail(this.method + " received wrong arguments " + sinon.format(args) +
2695                              ", didn't match " + this.expectedArguments.toString());
2696                      }
2697  
2698                      if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {
2699                          sinon.expectation.fail(this.method + " received wrong arguments " + sinon.format(args) +
2700                              ", expected " + sinon.format(this.expectedArguments));
2701                      }
2702                  }
2703              },
2704  
2705              allowsCall: function allowsCall(thisValue, args) {
2706                  if (this.met() && receivedMaxCalls(this)) {
2707                      return false;
2708                  }
2709  
2710                  if ("expectedThis" in this && this.expectedThis !== thisValue) {
2711                      return false;
2712                  }
2713  
2714                  if (!("expectedArguments" in this)) {
2715                      return true;
2716                  }
2717  
2718                  args = args || [];
2719  
2720                  if (args.length < this.expectedArguments.length) {
2721                      return false;
2722                  }
2723  
2724                  if (this.expectsExactArgCount &&
2725                      args.length != this.expectedArguments.length) {
2726                      return false;
2727                  }
2728  
2729                  for (var i = 0, l = this.expectedArguments.length; i < l; i += 1) {
2730                      if (!verifyMatcher(this.expectedArguments[i],args[i])) {
2731                          return false;
2732                      }
2733  
2734                      if (!sinon.deepEqual(this.expectedArguments[i], args[i])) {
2735                          return false;
2736                      }
2737                  }
2738  
2739                  return true;
2740              },
2741  
2742              withArgs: function withArgs() {
2743                  this.expectedArguments = slice.call(arguments);
2744                  return this;
2745              },
2746  
2747              withExactArgs: function withExactArgs() {
2748                  this.withArgs.apply(this, arguments);
2749                  this.expectsExactArgCount = true;
2750                  return this;
2751              },
2752  
2753              on: function on(thisValue) {
2754                  this.expectedThis = thisValue;
2755                  return this;
2756              },
2757  
2758              toString: function () {
2759                  var args = (this.expectedArguments || []).slice();
2760  
2761                  if (!this.expectsExactArgCount) {
2762                      push.call(args, "[...]");
2763                  }
2764  
2765                  var callStr = sinon.spyCall.toString.call({
2766                      proxy: this.method || "anonymous mock expectation",
2767                      args: args
2768                  });
2769  
2770                  var message = callStr.replace(", [...", "[, ...") + " " +
2771                      expectedCallCountInWords(this);
2772  
2773                  if (this.met()) {
2774                      return "Expectation met: " + message;
2775                  }
2776  
2777                  return "Expected " + message + " (" +
2778                      callCountInWords(this.callCount) + ")";
2779              },
2780  
2781              verify: function verify() {
2782                  if (!this.met()) {
2783                      sinon.expectation.fail(this.toString());
2784                  } else {
2785                      sinon.expectation.pass(this.toString());
2786                  }
2787  
2788                  return true;
2789              },
2790  
2791              pass: function(message) {
2792                sinon.assert.pass(message);
2793              },
2794              fail: function (message) {
2795                  var exception = new Error(message);
2796                  exception.name = "ExpectationError";
2797  
2798                  throw exception;
2799              }
2800          };
2801      }());
2802  
2803      sinon.mock = mock;
2804  
2805      if (typeof define === "function" && define.amd) {
2806          define(["module"], function(module) { module.exports = mock; });
2807      } else if (commonJSModule) {
2808          module.exports = mock;
2809      }
2810  }(typeof sinon == "object" && sinon || null));
2811  
2812  /**
2813   * @depend ../sinon.js
2814   * @depend stub.js
2815   * @depend mock.js
2816   */
2817  /*jslint eqeqeq: false, onevar: false, forin: true*/
2818  /*global module, require, sinon*/
2819  /**
2820   * Collections of stubs, spies and mocks.
2821   *
2822   * @author Christian Johansen ([email protected])
2823   * @license BSD
2824   *
2825   * Copyright (c) 2010-2013 Christian Johansen
2826   */
2827  
2828  (function (sinon) {
2829      var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function";
2830      var push = [].push;
2831      var hasOwnProperty = Object.prototype.hasOwnProperty;
2832  
2833      if (!sinon && commonJSModule) {
2834          sinon = require("../sinon");
2835      }
2836  
2837      if (!sinon) {
2838          return;
2839      }
2840  
2841      function getFakes(fakeCollection) {
2842          if (!fakeCollection.fakes) {
2843              fakeCollection.fakes = [];
2844          }
2845  
2846          return fakeCollection.fakes;
2847      }
2848  
2849      function each(fakeCollection, method) {
2850          var fakes = getFakes(fakeCollection);
2851  
2852          for (var i = 0, l = fakes.length; i < l; i += 1) {
2853              if (typeof fakes[i][method] == "function") {
2854                  fakes[i][method]();
2855              }
2856          }
2857      }
2858  
2859      function compact(fakeCollection) {
2860          var fakes = getFakes(fakeCollection);
2861          var i = 0;
2862          while (i < fakes.length) {
2863            fakes.splice(i, 1);
2864          }
2865      }
2866  
2867      var collection = {
2868          verify: function resolve() {
2869              each(this, "verify");
2870          },
2871  
2872          restore: function restore() {
2873              each(this, "restore");
2874              compact(this);
2875          },
2876  
2877          verifyAndRestore: function verifyAndRestore() {
2878              var exception;
2879  
2880              try {
2881                  this.verify();
2882              } catch (e) {
2883                  exception = e;
2884              }
2885  
2886              this.restore();
2887  
2888              if (exception) {
2889                  throw exception;
2890              }
2891          },
2892  
2893          add: function add(fake) {
2894              push.call(getFakes(this), fake);
2895              return fake;
2896          },
2897  
2898          spy: function spy() {
2899              return this.add(sinon.spy.apply(sinon, arguments));
2900          },
2901  
2902          stub: function stub(object, property, value) {
2903              if (property) {
2904                  var original = object[property];
2905  
2906                  if (typeof original != "function") {
2907                      if (!hasOwnProperty.call(object, property)) {
2908                          throw new TypeError("Cannot stub non-existent own property " + property);
2909                      }
2910  
2911                      object[property] = value;
2912  
2913                      return this.add({
2914                          restore: function () {
2915                              object[property] = original;
2916                          }
2917                      });
2918                  }
2919              }
2920              if (!property && !!object && typeof object == "object") {
2921                  var stubbedObj = sinon.stub.apply(sinon, arguments);
2922  
2923                  for (var prop in stubbedObj) {
2924                      if (typeof stubbedObj[prop] === "function") {
2925                          this.add(stubbedObj[prop]);
2926                      }
2927                  }
2928  
2929                  return stubbedObj;
2930              }
2931  
2932              return this.add(sinon.stub.apply(sinon, arguments));
2933          },
2934  
2935          mock: function mock() {
2936              return this.add(sinon.mock.apply(sinon, arguments));
2937          },
2938  
2939          inject: function inject(obj) {
2940              var col = this;
2941  
2942              obj.spy = function () {
2943                  return col.spy.apply(col, arguments);
2944              };
2945  
2946              obj.stub = function () {
2947                  return col.stub.apply(col, arguments);
2948              };
2949  
2950              obj.mock = function () {
2951                  return col.mock.apply(col, arguments);
2952              };
2953  
2954              return obj;
2955          }
2956      };
2957  
2958      sinon.collection = collection;
2959  
2960      if (typeof define === "function" && define.amd) {
2961          define(["module"], function(module) { module.exports = collection; });
2962      } else if (commonJSModule) {
2963          module.exports = collection;
2964      }
2965  }(typeof sinon == "object" && sinon || null));
2966  
2967  /*jslint eqeqeq: false, plusplus: false, evil: true, onevar: false, browser: true, forin: false*/
2968  /*global module, require, window*/
2969  /**
2970   * Fake timer API
2971   * setTimeout
2972   * setInterval
2973   * clearTimeout
2974   * clearInterval
2975   * tick
2976   * reset
2977   * Date
2978   *
2979   * Inspired by jsUnitMockTimeOut from JsUnit
2980   *
2981   * @author Christian Johansen ([email protected])
2982   * @license BSD
2983   *
2984   * Copyright (c) 2010-2013 Christian Johansen
2985   */
2986  
2987  if (typeof sinon == "undefined") {
2988      var sinon = {};
2989  }
2990  
2991  (function (global) {
2992      // node expects setTimeout/setInterval to return a fn object w/ .ref()/.unref()
2993      // browsers, a number.
2994      // see https://github.com/cjohansen/Sinon.JS/pull/436
2995      var timeoutResult = setTimeout(function() {}, 0);
2996      var addTimerReturnsObject = typeof timeoutResult === 'object';
2997      clearTimeout(timeoutResult);
2998  
2999      var id = 1;
3000  
3001      function addTimer(args, recurring) {
3002          if (args.length === 0) {
3003              throw new Error("Function requires at least 1 parameter");
3004          }
3005  
3006          if (typeof args[0] === "undefined") {
3007              throw new Error("Callback must be provided to timer calls");
3008          }
3009  
3010          var toId = id++;
3011          var delay = args[1] || 0;
3012  
3013          if (!this.timeouts) {
3014              this.timeouts = {};
3015          }
3016  
3017          this.timeouts[toId] = {
3018              id: toId,
3019              func: args[0],
3020              callAt: this.now + delay,
3021              invokeArgs: Array.prototype.slice.call(args, 2)
3022          };
3023  
3024          if (recurring === true) {
3025              this.timeouts[toId].interval = delay;
3026          }
3027  
3028          if (addTimerReturnsObject) {
3029              return {
3030                  id: toId,
3031                  ref: function() {},
3032                  unref: function() {}
3033              };
3034          }
3035          else {
3036              return toId;
3037          }
3038      }
3039  
3040      function parseTime(str) {
3041          if (!str) {
3042              return 0;
3043          }
3044  
3045          var strings = str.split(":");
3046          var l = strings.length, i = l;
3047          var ms = 0, parsed;
3048  
3049          if (l > 3 || !/^(\d\d:){0,2}\d\d?$/.test(str)) {
3050              throw new Error("tick only understands numbers and 'h:m:s'");
3051          }
3052  
3053          while (i--) {
3054              parsed = parseInt(strings[i], 10);
3055  
3056              if (parsed >= 60) {
3057                  throw new Error("Invalid time " + str);
3058              }
3059  
3060              ms += parsed * Math.pow(60, (l - i - 1));
3061          }
3062  
3063          return ms * 1000;
3064      }
3065  
3066      function createObject(object) {
3067          var newObject;
3068  
3069          if (Object.create) {
3070              newObject = Object.create(object);
3071          } else {
3072              var F = function () {};
3073              F.prototype = object;
3074              newObject = new F();
3075          }
3076  
3077          newObject.Date.clock = newObject;
3078          return newObject;
3079      }
3080  
3081      sinon.clock = {
3082          now: 0,
3083  
3084          create: function create(now) {
3085              var clock = createObject(this);
3086  
3087              if (typeof now == "number") {
3088                  clock.now = now;
3089              }
3090  
3091              if (!!now && typeof now == "object") {
3092                  throw new TypeError("now should be milliseconds since UNIX epoch");
3093              }
3094  
3095              return clock;
3096          },
3097  
3098          setTimeout: function setTimeout(callback, timeout) {
3099              return addTimer.call(this, arguments, false);
3100          },
3101  
3102          clearTimeout: function clearTimeout(timerId) {
3103              if (!timerId) {
3104                  // null appears to be allowed in most browsers, and appears to be relied upon by some libraries, like Bootstrap carousel
3105                  return;
3106              }
3107              if (!this.timeouts) {
3108                  this.timeouts = [];
3109              }
3110              // in Node, timerId is an object with .ref()/.unref(), and
3111              // its .id field is the actual timer id.
3112              if (typeof timerId === 'object') {
3113                timerId = timerId.id
3114              }
3115              if (timerId in this.timeouts) {
3116                  delete this.timeouts[timerId];
3117              }
3118          },
3119  
3120          setInterval: function setInterval(callback, timeout) {
3121              return addTimer.call(this, arguments, true);
3122          },
3123  
3124          clearInterval: function clearInterval(timerId) {
3125              this.clearTimeout(timerId);
3126          },
3127  
3128          setImmediate: function setImmediate(callback) {
3129              var passThruArgs = Array.prototype.slice.call(arguments, 1);
3130  
3131              return addTimer.call(this, [callback, 0].concat(passThruArgs), false);
3132          },
3133  
3134          clearImmediate: function clearImmediate(timerId) {
3135              this.clearTimeout(timerId);
3136          },
3137  
3138          tick: function tick(ms) {
3139              ms = typeof ms == "number" ? ms : parseTime(ms);
3140              var tickFrom = this.now, tickTo = this.now + ms, previous = this.now;
3141              var timer = this.firstTimerInRange(tickFrom, tickTo);
3142  
3143              var firstException;
3144              while (timer && tickFrom <= tickTo) {
3145                  if (this.timeouts[timer.id]) {
3146                      tickFrom = this.now = timer.callAt;
3147                      try {
3148                        this.callTimer(timer);
3149                      } catch (e) {
3150                        firstException = firstException || e;
3151                      }
3152                  }
3153  
3154                  timer = this.firstTimerInRange(previous, tickTo);
3155                  previous = tickFrom;
3156              }
3157  
3158              this.now = tickTo;
3159  
3160              if (firstException) {
3161                throw firstException;
3162              }
3163  
3164              return this.now;
3165          },
3166  
3167          firstTimerInRange: function (from, to) {
3168              var timer, smallest = null, originalTimer;
3169  
3170              for (var id in this.timeouts) {
3171                  if (this.timeouts.hasOwnProperty(id)) {
3172                      if (this.timeouts[id].callAt < from || this.timeouts[id].callAt > to) {
3173                          continue;
3174                      }
3175  
3176                      if (smallest === null || this.timeouts[id].callAt < smallest) {
3177                          originalTimer = this.timeouts[id];
3178                          smallest = this.timeouts[id].callAt;
3179  
3180                          timer = {
3181                              func: this.timeouts[id].func,
3182                              callAt: this.timeouts[id].callAt,
3183                              interval: this.timeouts[id].interval,
3184                              id: this.timeouts[id].id,
3185                              invokeArgs: this.timeouts[id].invokeArgs
3186                          };
3187                      }
3188                  }
3189              }
3190  
3191              return timer || null;
3192          },
3193  
3194          callTimer: function (timer) {
3195              if (typeof timer.interval == "number") {
3196                  this.timeouts[timer.id].callAt += timer.interval;
3197              } else {
3198                  delete this.timeouts[timer.id];
3199              }
3200  
3201              try {
3202                  if (typeof timer.func == "function") {
3203                      timer.func.apply(null, timer.invokeArgs);
3204                  } else {
3205                      eval(timer.func);
3206                  }
3207              } catch (e) {
3208                var exception = e;
3209              }
3210  
3211              if (!this.timeouts[timer.id]) {
3212                  if (exception) {
3213                    throw exception;
3214                  }
3215                  return;
3216              }
3217  
3218              if (exception) {
3219                throw exception;
3220              }
3221          },
3222  
3223          reset: function reset() {
3224              this.timeouts = {};
3225          },
3226  
3227          Date: (function () {
3228              var NativeDate = Date;
3229  
3230              function ClockDate(year, month, date, hour, minute, second, ms) {
3231                  // Defensive and verbose to avoid potential harm in passing
3232                  // explicit undefined when user does not pass argument
3233                  switch (arguments.length) {
3234                  case 0:
3235                      return new NativeDate(ClockDate.clock.now);
3236                  case 1:
3237                      return new NativeDate(year);
3238                  case 2:
3239                      return new NativeDate(year, month);
3240                  case 3:
3241                      return new NativeDate(year, month, date);
3242                  case 4:
3243                      return new NativeDate(year, month, date, hour);
3244                  case 5:
3245                      return new NativeDate(year, month, date, hour, minute);
3246                  case 6:
3247                      return new NativeDate(year, month, date, hour, minute, second);
3248                  default:
3249                      return new NativeDate(year, month, date, hour, minute, second, ms);
3250                  }
3251              }
3252  
3253              return mirrorDateProperties(ClockDate, NativeDate);
3254          }())
3255      };
3256  
3257      function mirrorDateProperties(target, source) {
3258          if (source.now) {
3259              target.now = function now() {
3260                  return target.clock.now;
3261              };
3262          } else {
3263              delete target.now;
3264          }
3265  
3266          if (source.toSource) {
3267              target.toSource = function toSource() {
3268                  return source.toSource();
3269              };
3270          } else {
3271              delete target.toSource;
3272          }
3273  
3274          target.toString = function toString() {
3275              return source.toString();
3276          };
3277  
3278          target.prototype = source.prototype;
3279          target.parse = source.parse;
3280          target.UTC = source.UTC;
3281          target.prototype.toUTCString = source.prototype.toUTCString;
3282  
3283          for (var prop in source) {
3284              if (source.hasOwnProperty(prop)) {
3285                  target[prop] = source[prop];
3286              }
3287          }
3288  
3289          return target;
3290      }
3291  
3292      var methods = ["Date", "setTimeout", "setInterval",
3293                     "clearTimeout", "clearInterval"];
3294  
3295      if (typeof global.setImmediate !== "undefined") {
3296          methods.push("setImmediate");
3297      }
3298  
3299      if (typeof global.clearImmediate !== "undefined") {
3300          methods.push("clearImmediate");
3301      }
3302  
3303      function restore() {
3304          var method;
3305  
3306          for (var i = 0, l = this.methods.length; i < l; i++) {
3307              method = this.methods[i];
3308  
3309              if (global[method].hadOwnProperty) {
3310                  global[method] = this["_" + method];
3311              } else {
3312                  try {
3313                      delete global[method];
3314                  } catch (e) {}
3315              }
3316          }
3317  
3318          // Prevent multiple executions which will completely remove these props
3319          this.methods = [];
3320      }
3321  
3322      function stubGlobal(method, clock) {
3323          clock[method].hadOwnProperty = Object.prototype.hasOwnProperty.call(global, method);
3324          clock["_" + method] = global[method];
3325  
3326          if (method == "Date") {
3327              var date = mirrorDateProperties(clock[method], global[method]);
3328              global[method] = date;
3329          } else {
3330              global[method] = function () {
3331                  return clock[method].apply(clock, arguments);
3332              };
3333  
3334              for (var prop in clock[method]) {
3335                  if (clock[method].hasOwnProperty(prop)) {
3336                      global[method][prop] = clock[method][prop];
3337                  }
3338              }
3339          }
3340  
3341          global[method].clock = clock;
3342      }
3343  
3344      sinon.useFakeTimers = function useFakeTimers(now) {
3345          var clock = sinon.clock.create(now);
3346          clock.restore = restore;
3347          clock.methods = Array.prototype.slice.call(arguments,
3348                                                     typeof now == "number" ? 1 : 0);
3349  
3350          if (clock.methods.length === 0) {
3351              clock.methods = methods;
3352          }
3353  
3354          for (var i = 0, l = clock.methods.length; i < l; i++) {
3355              stubGlobal(clock.methods[i], clock);
3356          }
3357  
3358          return clock;
3359      };
3360  }(typeof global != "undefined" && typeof global !== "function" ? global : this));
3361  
3362  sinon.timers = {
3363      setTimeout: setTimeout,
3364      clearTimeout: clearTimeout,
3365      setImmediate: (typeof setImmediate !== "undefined" ? setImmediate : undefined),
3366      clearImmediate: (typeof clearImmediate !== "undefined" ? clearImmediate: undefined),
3367      setInterval: setInterval,
3368      clearInterval: clearInterval,
3369      Date: Date
3370  };
3371  
3372  if (typeof module !== 'undefined' && module.exports) {
3373      module.exports = sinon;
3374  }
3375  
3376  /*jslint eqeqeq: false, onevar: false*/
3377  /*global sinon, module, require, ActiveXObject, XMLHttpRequest, DOMParser*/
3378  /**
3379   * Minimal Event interface implementation
3380   *
3381   * Original implementation by Sven Fuchs: https://gist.github.com/995028
3382   * Modifications and tests by Christian Johansen.
3383   *
3384   * @author Sven Fuchs ([email protected])
3385   * @author Christian Johansen ([email protected])
3386   * @license BSD
3387   *
3388   * Copyright (c) 2011 Sven Fuchs, Christian Johansen
3389   */
3390  
3391  if (typeof sinon == "undefined") {
3392      this.sinon = {};
3393  }
3394  
3395  (function () {
3396      var push = [].push;
3397  
3398      sinon.Event = function Event(type, bubbles, cancelable, target) {
3399          this.initEvent(type, bubbles, cancelable, target);
3400      };
3401  
3402      sinon.Event.prototype = {
3403          initEvent: function(type, bubbles, cancelable, target) {
3404              this.type = type;
3405              this.bubbles = bubbles;
3406              this.cancelable = cancelable;
3407              this.target = target;
3408          },
3409  
3410          stopPropagation: function () {},
3411  
3412          preventDefault: function () {
3413              this.defaultPrevented = true;
3414          }
3415      };
3416  
3417      sinon.ProgressEvent = function ProgressEvent(type, progressEventRaw, target) {
3418          this.initEvent(type, false, false, target);
3419          this.loaded = progressEventRaw.loaded || null;
3420          this.total = progressEventRaw.total || null;
3421      };
3422  
3423      sinon.ProgressEvent.prototype = new sinon.Event();
3424  
3425      sinon.ProgressEvent.prototype.constructor =  sinon.ProgressEvent;
3426  
3427      sinon.CustomEvent = function CustomEvent(type, customData, target) {
3428          this.initEvent(type, false, false, target);
3429          this.detail = customData.detail || null;
3430      };
3431  
3432      sinon.CustomEvent.prototype = new sinon.Event();
3433  
3434      sinon.CustomEvent.prototype.constructor =  sinon.CustomEvent;
3435  
3436      sinon.EventTarget = {
3437          addEventListener: function addEventListener(event, listener) {
3438              this.eventListeners = this.eventListeners || {};
3439              this.eventListeners[event] = this.eventListeners[event] || [];
3440              push.call(this.eventListeners[event], listener);
3441          },
3442  
3443          removeEventListener: function removeEventListener(event, listener) {
3444              var listeners = this.eventListeners && this.eventListeners[event] || [];
3445  
3446              for (var i = 0, l = listeners.length; i < l; ++i) {
3447                  if (listeners[i] == listener) {
3448                      return listeners.splice(i, 1);
3449                  }
3450              }
3451          },
3452  
3453          dispatchEvent: function dispatchEvent(event) {
3454              var type = event.type;
3455              var listeners = this.eventListeners && this.eventListeners[type] || [];
3456  
3457              for (var i = 0; i < listeners.length; i++) {
3458                  if (typeof listeners[i] == "function") {
3459                      listeners[i].call(this, event);
3460                  } else {
3461                      listeners[i].handleEvent(event);
3462                  }
3463              }
3464  
3465              return !!event.defaultPrevented;
3466          }
3467      };
3468  }());
3469  
3470  /**
3471   * @depend ../../sinon.js
3472   * @depend event.js
3473   */
3474  /*jslint eqeqeq: false, onevar: false*/
3475  /*global sinon, module, require, ActiveXObject, XMLHttpRequest, DOMParser*/
3476  /**
3477   * Fake XMLHttpRequest object
3478   *
3479   * @author Christian Johansen ([email protected])
3480   * @license BSD
3481   *
3482   * Copyright (c) 2010-2013 Christian Johansen
3483   */
3484  
3485  // wrapper for global
3486  (function(global) {
3487      if (typeof sinon === "undefined") {
3488          global.sinon = {};
3489      }
3490  
3491      var supportsProgress = typeof ProgressEvent !== "undefined";
3492      var supportsCustomEvent = typeof CustomEvent !== "undefined";
3493      sinon.xhr = { XMLHttpRequest: global.XMLHttpRequest };
3494      var xhr = sinon.xhr;
3495      xhr.GlobalXMLHttpRequest = global.XMLHttpRequest;
3496      xhr.GlobalActiveXObject = global.ActiveXObject;
3497      xhr.supportsActiveX = typeof xhr.GlobalActiveXObject != "undefined";
3498      xhr.supportsXHR = typeof xhr.GlobalXMLHttpRequest != "undefined";
3499      xhr.workingXHR = xhr.supportsXHR ? xhr.GlobalXMLHttpRequest : xhr.supportsActiveX
3500                                       ? function() { return new xhr.GlobalActiveXObject("MSXML2.XMLHTTP.3.0") } : false;
3501      xhr.supportsCORS = xhr.supportsXHR && 'withCredentials' in (new sinon.xhr.GlobalXMLHttpRequest());
3502  
3503      /*jsl:ignore*/
3504      var unsafeHeaders = {
3505          "Accept-Charset": true,
3506          "Accept-Encoding": true,
3507          "Connection": true,
3508          "Content-Length": true,
3509          "Cookie": true,
3510          "Cookie2": true,
3511          "Content-Transfer-Encoding": true,
3512          "Date": true,
3513          "Expect": true,
3514          "Host": true,
3515          "Keep-Alive": true,
3516          "Referer": true,
3517          "TE": true,
3518          "Trailer": true,
3519          "Transfer-Encoding": true,
3520          "Upgrade": true,
3521          "User-Agent": true,
3522          "Via": true
3523      };
3524      /*jsl:end*/
3525  
3526      function FakeXMLHttpRequest() {
3527          this.readyState = FakeXMLHttpRequest.UNSENT;
3528          this.requestHeaders = {};
3529          this.requestBody = null;
3530          this.status = 0;
3531          this.statusText = "";
3532          this.upload = new UploadProgress();
3533          if (sinon.xhr.supportsCORS) {
3534              this.withCredentials = false;
3535          }
3536  
3537  
3538          var xhr = this;
3539          var events = ["loadstart", "load", "abort", "loadend"];
3540  
3541          function addEventListener(eventName) {
3542              xhr.addEventListener(eventName, function (event) {
3543                  var listener = xhr["on" + eventName];
3544  
3545                  if (listener && typeof listener == "function") {
3546                      listener.call(this, event);
3547                  }
3548              });
3549          }
3550  
3551          for (var i = events.length - 1; i >= 0; i--) {
3552              addEventListener(events[i]);
3553          }
3554  
3555          if (typeof FakeXMLHttpRequest.onCreate == "function") {
3556              FakeXMLHttpRequest.onCreate(this);
3557          }
3558      }
3559  
3560      // An upload object is created for each
3561      // FakeXMLHttpRequest and allows upload
3562      // events to be simulated using uploadProgress
3563      // and uploadError.
3564      function UploadProgress() {
3565          this.eventListeners = {
3566              "progress": [],
3567              "load": [],
3568              "abort": [],
3569              "error": []
3570          }
3571      }
3572  
3573      UploadProgress.prototype.addEventListener = function(event, listener) {
3574          this.eventListeners[event].push(listener);
3575      };
3576  
3577      UploadProgress.prototype.removeEventListener = function(event, listener) {
3578          var listeners = this.eventListeners[event] || [];
3579  
3580          for (var i = 0, l = listeners.length; i < l; ++i) {
3581              if (listeners[i] == listener) {
3582                  return listeners.splice(i, 1);
3583              }
3584          }
3585      };
3586  
3587      UploadProgress.prototype.dispatchEvent = function(event) {
3588          var listeners = this.eventListeners[event.type] || [];
3589  
3590          for (var i = 0, listener; (listener = listeners[i]) != null; i++) {
3591              listener(event);
3592          }
3593      };
3594  
3595      function verifyState(xhr) {
3596          if (xhr.readyState !== FakeXMLHttpRequest.OPENED) {
3597              throw new Error("INVALID_STATE_ERR");
3598          }
3599  
3600          if (xhr.sendFlag) {
3601              throw new Error("INVALID_STATE_ERR");
3602          }
3603      }
3604  
3605      // filtering to enable a white-list version of Sinon FakeXhr,
3606      // where whitelisted requests are passed through to real XHR
3607      function each(collection, callback) {
3608          if (!collection) return;
3609          for (var i = 0, l = collection.length; i < l; i += 1) {
3610              callback(collection[i]);
3611          }
3612      }
3613      function some(collection, callback) {
3614          for (var index = 0; index < collection.length; index++) {
3615              if(callback(collection[index]) === true) return true;
3616          }
3617          return false;
3618      }
3619      // largest arity in XHR is 5 - XHR#open
3620      var apply = function(obj,method,args) {
3621          switch(args.length) {
3622          case 0: return obj[method]();
3623          case 1: return obj[method](args[0]);
3624          case 2: return obj[method](args[0],args[1]);
3625          case 3: return obj[method](args[0],args[1],args[2]);
3626          case 4: return obj[method](args[0],args[1],args[2],args[3]);
3627          case 5: return obj[method](args[0],args[1],args[2],args[3],args[4]);
3628          }
3629      };
3630  
3631      FakeXMLHttpRequest.filters = [];
3632      FakeXMLHttpRequest.addFilter = function(fn) {
3633          this.filters.push(fn)
3634      };
3635      var IE6Re = /MSIE 6/;
3636      FakeXMLHttpRequest.defake = function(fakeXhr,xhrArgs) {
3637          var xhr = new sinon.xhr.workingXHR();
3638          each(["open","setRequestHeader","send","abort","getResponseHeader",
3639                "getAllResponseHeaders","addEventListener","overrideMimeType","removeEventListener"],
3640               function(method) {
3641                   fakeXhr[method] = function() {
3642                     return apply(xhr,method,arguments);
3643                   };
3644               });
3645  
3646          var copyAttrs = function(args) {
3647              each(args, function(attr) {
3648                try {
3649                  fakeXhr[attr] = xhr[attr]
3650                } catch(e) {
3651                  if(!IE6Re.test(navigator.userAgent)) throw e;
3652                }
3653              });
3654          };
3655  
3656          var stateChange = function() {
3657              fakeXhr.readyState = xhr.readyState;
3658              if(xhr.readyState >= FakeXMLHttpRequest.HEADERS_RECEIVED) {
3659                  copyAttrs(["status","statusText"]);
3660              }
3661              if(xhr.readyState >= FakeXMLHttpRequest.LOADING) {
3662                  copyAttrs(["responseText"]);
3663              }
3664              if(xhr.readyState === FakeXMLHttpRequest.DONE) {
3665                  copyAttrs(["responseXML"]);
3666              }
3667              if(fakeXhr.onreadystatechange) fakeXhr.onreadystatechange.call(fakeXhr, { target: fakeXhr });
3668          };
3669          if(xhr.addEventListener) {
3670            for(var event in fakeXhr.eventListeners) {
3671                if(fakeXhr.eventListeners.hasOwnProperty(event)) {
3672                    each(fakeXhr.eventListeners[event],function(handler) {
3673                        xhr.addEventListener(event, handler);
3674                    });
3675                }
3676            }
3677            xhr.addEventListener("readystatechange",stateChange);
3678          } else {
3679            xhr.onreadystatechange = stateChange;
3680          }
3681          apply(xhr,"open",xhrArgs);
3682      };
3683      FakeXMLHttpRequest.useFilters = false;
3684  
3685      function verifyRequestOpened(xhr) {
3686          if (xhr.readyState != FakeXMLHttpRequest.OPENED) {
3687              throw new Error("INVALID_STATE_ERR - " + xhr.readyState);
3688          }
3689      }
3690  
3691      function verifyRequestSent(xhr) {
3692          if (xhr.readyState == FakeXMLHttpRequest.DONE) {
3693              throw new Error("Request done");
3694          }
3695      }
3696  
3697      function verifyHeadersReceived(xhr) {
3698          if (xhr.async && xhr.readyState != FakeXMLHttpRequest.HEADERS_RECEIVED) {
3699              throw new Error("No headers received");
3700          }
3701      }
3702  
3703      function verifyResponseBodyType(body) {
3704          if (typeof body != "string") {
3705              var error = new Error("Attempted to respond to fake XMLHttpRequest with " +
3706                                   body + ", which is not a string.");
3707              error.name = "InvalidBodyException";
3708              throw error;
3709          }
3710      }
3711  
3712      sinon.extend(FakeXMLHttpRequest.prototype, sinon.EventTarget, {
3713          async: true,
3714  
3715          open: function open(method, url, async, username, password) {
3716              this.method = method;
3717              this.url = url;
3718              this.async = typeof async == "boolean" ? async : true;
3719              this.username = username;
3720              this.password = password;
3721              this.responseText = null;
3722              this.responseXML = null;
3723              this.requestHeaders = {};
3724              this.sendFlag = false;
3725              if(sinon.FakeXMLHttpRequest.useFilters === true) {
3726                  var xhrArgs = arguments;
3727                  var defake = some(FakeXMLHttpRequest.filters,function(filter) {
3728                      return filter.apply(this,xhrArgs)
3729                  });
3730                  if (defake) {
3731                    return sinon.FakeXMLHttpRequest.defake(this,arguments);
3732                  }
3733              }
3734              this.readyStateChange(FakeXMLHttpRequest.OPENED);
3735          },
3736  
3737          readyStateChange: function readyStateChange(state) {
3738              this.readyState = state;
3739  
3740              if (typeof this.onreadystatechange == "function") {
3741                  try {
3742                      this.onreadystatechange();
3743                  } catch (e) {
3744                      sinon.logError("Fake XHR onreadystatechange handler", e);
3745                  }
3746              }
3747  
3748              this.dispatchEvent(new sinon.Event("readystatechange"));
3749  
3750              switch (this.readyState) {
3751                  case FakeXMLHttpRequest.DONE:
3752                      this.dispatchEvent(new sinon.Event("load", false, false, this));
3753                      this.dispatchEvent(new sinon.Event("loadend", false, false, this));
3754                      this.upload.dispatchEvent(new sinon.Event("load", false, false, this));
3755                      if (supportsProgress) {
3756                          this.upload.dispatchEvent(new sinon.ProgressEvent('progress', {loaded: 100, total: 100}));
3757                      }
3758                      break;
3759              }
3760          },
3761  
3762          setRequestHeader: function setRequestHeader(header, value) {
3763              verifyState(this);
3764  
3765              if (unsafeHeaders[header] || /^(Sec-|Proxy-)/.test(header)) {
3766                  throw new Error("Refused to set unsafe header \"" + header + "\"");
3767              }
3768  
3769              if (this.requestHeaders[header]) {
3770                  this.requestHeaders[header] += "," + value;
3771              } else {
3772                  this.requestHeaders[header] = value;
3773              }
3774          },
3775  
3776          // Helps testing
3777          setResponseHeaders: function setResponseHeaders(headers) {
3778              verifyRequestOpened(this);
3779              this.responseHeaders = {};
3780  
3781              for (var header in headers) {
3782                  if (headers.hasOwnProperty(header)) {
3783                      this.responseHeaders[header] = headers[header];
3784                  }
3785              }
3786  
3787              if (this.async) {
3788                  this.readyStateChange(FakeXMLHttpRequest.HEADERS_RECEIVED);
3789              } else {
3790                  this.readyState = FakeXMLHttpRequest.HEADERS_RECEIVED;
3791              }
3792          },
3793  
3794          // Currently treats ALL data as a DOMString (i.e. no Document)
3795          send: function send(data) {
3796              verifyState(this);
3797  
3798              if (!/^(get|head)$/i.test(this.method)) {
3799                  if (this.requestHeaders["Content-Type"]) {
3800                      var value = this.requestHeaders["Content-Type"].split(";");
3801                      this.requestHeaders["Content-Type"] = value[0] + ";charset=utf-8";
3802                  } else {
3803                      this.requestHeaders["Content-Type"] = "text/plain;charset=utf-8";
3804                  }
3805  
3806                  this.requestBody = data;
3807              }
3808  
3809              this.errorFlag = false;
3810              this.sendFlag = this.async;
3811              this.readyStateChange(FakeXMLHttpRequest.OPENED);
3812  
3813              if (typeof this.onSend == "function") {
3814                  this.onSend(this);
3815              }
3816  
3817              this.dispatchEvent(new sinon.Event("loadstart", false, false, this));
3818          },
3819  
3820          abort: function abort() {
3821              this.aborted = true;
3822              this.responseText = null;
3823              this.errorFlag = true;
3824              this.requestHeaders = {};
3825  
3826              if (this.readyState > sinon.FakeXMLHttpRequest.UNSENT && this.sendFlag) {
3827                  this.readyStateChange(sinon.FakeXMLHttpRequest.DONE);
3828                  this.sendFlag = false;
3829              }
3830  
3831              this.readyState = sinon.FakeXMLHttpRequest.UNSENT;
3832  
3833              this.dispatchEvent(new sinon.Event("abort", false, false, this));
3834  
3835              this.upload.dispatchEvent(new sinon.Event("abort", false, false, this));
3836  
3837              if (typeof this.onerror === "function") {
3838                  this.onerror();
3839              }
3840          },
3841  
3842          getResponseHeader: function getResponseHeader(header) {
3843              if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {
3844                  return null;
3845              }
3846  
3847              if (/^Set-Cookie2?$/i.test(header)) {
3848                  return null;
3849              }
3850  
3851              header = header.toLowerCase();
3852  
3853              for (var h in this.responseHeaders) {
3854                  if (h.toLowerCase() == header) {
3855                      return this.responseHeaders[h];
3856                  }
3857              }
3858  
3859              return null;
3860          },
3861  
3862          getAllResponseHeaders: function getAllResponseHeaders() {
3863              if (this.readyState < FakeXMLHttpRequest.HEADERS_RECEIVED) {
3864                  return "";
3865              }
3866  
3867              var headers = "";
3868  
3869              for (var header in this.responseHeaders) {
3870                  if (this.responseHeaders.hasOwnProperty(header) &&
3871                      !/^Set-Cookie2?$/i.test(header)) {
3872                      headers += header + ": " + this.responseHeaders[header] + "\r\n";
3873                  }
3874              }
3875  
3876              return headers;
3877          },
3878  
3879          setResponseBody: function setResponseBody(body) {
3880              verifyRequestSent(this);
3881              verifyHeadersReceived(this);
3882              verifyResponseBodyType(body);
3883  
3884              var chunkSize = this.chunkSize || 10;
3885              var index = 0;
3886              this.responseText = "";
3887  
3888              do {
3889                  if (this.async) {
3890                      this.readyStateChange(FakeXMLHttpRequest.LOADING);
3891                  }
3892  
3893                  this.responseText += body.substring(index, index + chunkSize);
3894                  index += chunkSize;
3895              } while (index < body.length);
3896  
3897              var type = this.getResponseHeader("Content-Type");
3898  
3899              if (this.responseText &&
3900                  (!type || /(text\/xml)|(application\/xml)|(\+xml)/.test(type))) {
3901                  try {
3902                      this.responseXML = FakeXMLHttpRequest.parseXML(this.responseText);
3903                  } catch (e) {
3904                      // Unable to parse XML - no biggie
3905                  }
3906              }
3907  
3908              if (this.async) {
3909                  this.readyStateChange(FakeXMLHttpRequest.DONE);
3910              } else {
3911                  this.readyState = FakeXMLHttpRequest.DONE;
3912              }
3913          },
3914  
3915          respond: function respond(status, headers, body) {
3916              this.status = typeof status == "number" ? status : 200;
3917              this.statusText = FakeXMLHttpRequest.statusCodes[this.status];
3918              this.setResponseHeaders(headers || {});
3919              this.setResponseBody(body || "");
3920          },
3921  
3922          uploadProgress: function uploadProgress(progressEventRaw) {
3923              if (supportsProgress) {
3924                  this.upload.dispatchEvent(new sinon.ProgressEvent("progress", progressEventRaw));
3925              }
3926          },
3927  
3928          uploadError: function uploadError(error) {
3929              if (supportsCustomEvent) {
3930                  this.upload.dispatchEvent(new sinon.CustomEvent("error", {"detail": error}));
3931              }
3932          }
3933      });
3934  
3935      sinon.extend(FakeXMLHttpRequest, {
3936          UNSENT: 0,
3937          OPENED: 1,
3938          HEADERS_RECEIVED: 2,
3939          LOADING: 3,
3940          DONE: 4
3941      });
3942  
3943      // Borrowed from JSpec
3944      FakeXMLHttpRequest.parseXML = function parseXML(text) {
3945          var xmlDoc;
3946  
3947          if (typeof DOMParser != "undefined") {
3948              var parser = new DOMParser();
3949              xmlDoc = parser.parseFromString(text, "text/xml");
3950          } else {
3951              xmlDoc = new ActiveXObject("Microsoft.XMLDOM");
3952              xmlDoc.async = "false";
3953              xmlDoc.loadXML(text);
3954          }
3955  
3956          return xmlDoc;
3957      };
3958  
3959      FakeXMLHttpRequest.statusCodes = {
3960          100: "Continue",
3961          101: "Switching Protocols",
3962          200: "OK",
3963          201: "Created",
3964          202: "Accepted",
3965          203: "Non-Authoritative Information",
3966          204: "No Content",
3967          205: "Reset Content",
3968          206: "Partial Content",
3969          300: "Multiple Choice",
3970          301: "Moved Permanently",
3971          302: "Found",
3972          303: "See Other",
3973          304: "Not Modified",
3974          305: "Use Proxy",
3975          307: "Temporary Redirect",
3976          400: "Bad Request",
3977          401: "Unauthorized",
3978          402: "Payment Required",
3979          403: "Forbidden",
3980          404: "Not Found",
3981          405: "Method Not Allowed",
3982          406: "Not Acceptable",
3983          407: "Proxy Authentication Required",
3984          408: "Request Timeout",
3985          409: "Conflict",
3986          410: "Gone",
3987          411: "Length Required",
3988          412: "Precondition Failed",
3989          413: "Request Entity Too Large",
3990          414: "Request-URI Too Long",
3991          415: "Unsupported Media Type",
3992          416: "Requested Range Not Satisfiable",
3993          417: "Expectation Failed",
3994          422: "Unprocessable Entity",
3995          500: "Internal Server Error",
3996          501: "Not Implemented",
3997          502: "Bad Gateway",
3998          503: "Service Unavailable",
3999          504: "Gateway Timeout",
4000          505: "HTTP Version Not Supported"
4001      };
4002  
4003      sinon.useFakeXMLHttpRequest = function () {
4004          sinon.FakeXMLHttpRequest.restore = function restore(keepOnCreate) {
4005              if (xhr.supportsXHR) {
4006                  global.XMLHttpRequest = xhr.GlobalXMLHttpRequest;
4007              }
4008  
4009              if (xhr.supportsActiveX) {
4010                  global.ActiveXObject = xhr.GlobalActiveXObject;
4011              }
4012  
4013              delete sinon.FakeXMLHttpRequest.restore;
4014  
4015              if (keepOnCreate !== true) {
4016                  delete sinon.FakeXMLHttpRequest.onCreate;
4017              }
4018          };
4019          if (xhr.supportsXHR) {
4020              global.XMLHttpRequest = sinon.FakeXMLHttpRequest;
4021          }
4022  
4023          if (xhr.supportsActiveX) {
4024              global.ActiveXObject = function ActiveXObject(objId) {
4025                  if (objId == "Microsoft.XMLHTTP" || /^Msxml2\.XMLHTTP/i.test(objId)) {
4026  
4027                      return new sinon.FakeXMLHttpRequest();
4028                  }
4029  
4030                  return new xhr.GlobalActiveXObject(objId);
4031              };
4032          }
4033  
4034          return sinon.FakeXMLHttpRequest;
4035      };
4036  
4037      sinon.FakeXMLHttpRequest = FakeXMLHttpRequest;
4038  
4039  })((function(){ return typeof global === "object" ? global : this; })());
4040  
4041  if (typeof module !== 'undefined' && module.exports) {
4042      module.exports = sinon;
4043  }
4044  
4045  /**
4046   * @depend fake_xml_http_request.js
4047   */
4048  /*jslint eqeqeq: false, onevar: false, regexp: false, plusplus: false*/
4049  /*global module, require, window*/
4050  /**
4051   * The Sinon "server" mimics a web server that receives requests from
4052   * sinon.FakeXMLHttpRequest and provides an API to respond to those requests,
4053   * both synchronously and asynchronously. To respond synchronuously, canned
4054   * answers have to be provided upfront.
4055   *
4056   * @author Christian Johansen ([email protected])
4057   * @license BSD
4058   *
4059   * Copyright (c) 2010-2013 Christian Johansen
4060   */
4061  
4062  if (typeof sinon == "undefined") {
4063      var sinon = {};
4064  }
4065  
4066  sinon.fakeServer = (function () {
4067      var push = [].push;
4068      function F() {}
4069  
4070      function create(proto) {
4071          F.prototype = proto;
4072          return new F();
4073      }
4074  
4075      function responseArray(handler) {
4076          var response = handler;
4077  
4078          if (Object.prototype.toString.call(handler) != "[object Array]") {
4079              response = [200, {}, handler];
4080          }
4081  
4082          if (typeof response[2] != "string") {
4083              throw new TypeError("Fake server response body should be string, but was " +
4084                                  typeof response[2]);
4085          }
4086  
4087          return response;
4088      }
4089  
4090      var wloc = typeof window !== "undefined" ? window.location : {};
4091      var rCurrLoc = new RegExp("^" + wloc.protocol + "//" + wloc.host);
4092  
4093      function matchOne(response, reqMethod, reqUrl) {
4094          var rmeth = response.method;
4095          var matchMethod = !rmeth || rmeth.toLowerCase() == reqMethod.toLowerCase();
4096          var url = response.url;
4097          var matchUrl = !url || url == reqUrl || (typeof url.test == "function" && url.test(reqUrl));
4098  
4099          return matchMethod && matchUrl;
4100      }
4101  
4102      function match(response, request) {
4103          var requestUrl = request.url;
4104  
4105          if (!/^https?:\/\//.test(requestUrl) || rCurrLoc.test(requestUrl)) {
4106              requestUrl = requestUrl.replace(rCurrLoc, "");
4107          }
4108  
4109          if (matchOne(response, this.getHTTPMethod(request), requestUrl)) {
4110              if (typeof response.response == "function") {
4111                  var ru = response.url;
4112                  var args = [request].concat(ru && typeof ru.exec == "function" ? ru.exec(requestUrl).slice(1) : []);
4113                  return response.response.apply(response, args);
4114              }
4115  
4116              return true;
4117          }
4118  
4119          return false;
4120      }
4121  
4122      return {
4123          create: function () {
4124              var server = create(this);
4125              this.xhr = sinon.useFakeXMLHttpRequest();
4126              server.requests = [];
4127  
4128              this.xhr.onCreate = function (xhrObj) {
4129                  server.addRequest(xhrObj);
4130              };
4131  
4132              return server;
4133          },
4134  
4135          addRequest: function addRequest(xhrObj) {
4136              var server = this;
4137              push.call(this.requests, xhrObj);
4138  
4139              xhrObj.onSend = function () {
4140                  server.handleRequest(this);
4141  
4142                  if (server.autoRespond && !server.responding) {
4143                      setTimeout(function () {
4144                          server.responding = false;
4145                          server.respond();
4146                      }, server.autoRespondAfter || 10);
4147  
4148                      server.responding = true;
4149                  }
4150              };
4151          },
4152  
4153          getHTTPMethod: function getHTTPMethod(request) {
4154              if (this.fakeHTTPMethods && /post/i.test(request.method)) {
4155                  var matches = (request.requestBody || "").match(/_method=([^\b;]+)/);
4156                  return !!matches ? matches[1] : request.method;
4157              }
4158  
4159              return request.method;
4160          },
4161  
4162          handleRequest: function handleRequest(xhr) {
4163              if (xhr.async) {
4164                  if (!this.queue) {
4165                      this.queue = [];
4166                  }
4167  
4168                  push.call(this.queue, xhr);
4169              } else {
4170                  this.processRequest(xhr);
4171              }
4172          },
4173  
4174          log: function(response, request) {
4175              var str;
4176  
4177              str =  "Request:\n"  + sinon.format(request)  + "\n\n";
4178              str += "Response:\n" + sinon.format(response) + "\n\n";
4179  
4180              sinon.log(str);
4181          },
4182  
4183          respondWith: function respondWith(method, url, body) {
4184              if (arguments.length == 1 && typeof method != "function") {
4185                  this.response = responseArray(method);
4186                  return;
4187              }
4188  
4189              if (!this.responses) { this.responses = []; }
4190  
4191              if (arguments.length == 1) {
4192                  body = method;
4193                  url = method = null;
4194              }
4195  
4196              if (arguments.length == 2) {
4197                  body = url;
4198                  url = method;
4199                  method = null;
4200              }
4201  
4202              push.call(this.responses, {
4203                  method: method,
4204                  url: url,
4205                  response: typeof body == "function" ? body : responseArray(body)
4206              });
4207          },
4208  
4209          respond: function respond() {
4210              if (arguments.length > 0) this.respondWith.apply(this, arguments);
4211              var queue = this.queue || [];
4212              var requests = queue.splice(0, queue.length);
4213              var request;
4214  
4215              while(request = requests.shift()) {
4216                  this.processRequest(request);
4217              }
4218          },
4219  
4220          processRequest: function processRequest(request) {
4221              try {
4222                  if (request.aborted) {
4223                      return;
4224                  }
4225  
4226                  var response = this.response || [404, {}, ""];
4227  
4228                  if (this.responses) {
4229                      for (var l = this.responses.length, i = l - 1; i >= 0; i--) {
4230                          if (match.call(this, this.responses[i], request)) {
4231                              response = this.responses[i].response;
4232                              break;
4233                          }
4234                      }
4235                  }
4236  
4237                  if (request.readyState != 4) {
4238                      sinon.fakeServer.log(response, request);
4239  
4240                      request.respond(response[0], response[1], response[2]);
4241                  }
4242              } catch (e) {
4243                  sinon.logError("Fake server request processing", e);
4244              }
4245          },
4246  
4247          restore: function restore() {
4248              return this.xhr.restore && this.xhr.restore.apply(this.xhr, arguments);
4249          }
4250      };
4251  }());
4252  
4253  if (typeof module !== 'undefined' && module.exports) {
4254      module.exports = sinon;
4255  }
4256  
4257  /**
4258   * @depend fake_server.js
4259   * @depend fake_timers.js
4260   */
4261  /*jslint browser: true, eqeqeq: false, onevar: false*/
4262  /*global sinon*/
4263  /**
4264   * Add-on for sinon.fakeServer that automatically handles a fake timer along with
4265   * the FakeXMLHttpRequest. The direct inspiration for this add-on is jQuery
4266   * 1.3.x, which does not use xhr object's onreadystatehandler at all - instead,
4267   * it polls the object for completion with setInterval. Dispite the direct
4268   * motivation, there is nothing jQuery-specific in this file, so it can be used
4269   * in any environment where the ajax implementation depends on setInterval or
4270   * setTimeout.
4271   *
4272   * @author Christian Johansen ([email protected])
4273   * @license BSD
4274   *
4275   * Copyright (c) 2010-2013 Christian Johansen
4276   */
4277  
4278  (function () {
4279      function Server() {}
4280      Server.prototype = sinon.fakeServer;
4281  
4282      sinon.fakeServerWithClock = new Server();
4283  
4284      sinon.fakeServerWithClock.addRequest = function addRequest(xhr) {
4285          if (xhr.async) {
4286              if (typeof setTimeout.clock == "object") {
4287                  this.clock = setTimeout.clock;
4288              } else {
4289                  this.clock = sinon.useFakeTimers();
4290                  this.resetClock = true;
4291              }
4292  
4293              if (!this.longestTimeout) {
4294                  var clockSetTimeout = this.clock.setTimeout;
4295                  var clockSetInterval = this.clock.setInterval;
4296                  var server = this;
4297  
4298                  this.clock.setTimeout = function (fn, timeout) {
4299                      server.longestTimeout = Math.max(timeout, server.longestTimeout || 0);
4300  
4301                      return clockSetTimeout.apply(this, arguments);
4302                  };
4303  
4304                  this.clock.setInterval = function (fn, timeout) {
4305                      server.longestTimeout = Math.max(timeout, server.longestTimeout || 0);
4306  
4307                      return clockSetInterval.apply(this, arguments);
4308                  };
4309              }
4310          }
4311  
4312          return sinon.fakeServer.addRequest.call(this, xhr);
4313      };
4314  
4315      sinon.fakeServerWithClock.respond = function respond() {
4316          var returnVal = sinon.fakeServer.respond.apply(this, arguments);
4317  
4318          if (this.clock) {
4319              this.clock.tick(this.longestTimeout || 0);
4320              this.longestTimeout = 0;
4321  
4322              if (this.resetClock) {
4323                  this.clock.restore();
4324                  this.resetClock = false;
4325              }
4326          }
4327  
4328          return returnVal;
4329      };
4330  
4331      sinon.fakeServerWithClock.restore = function restore() {
4332          if (this.clock) {
4333              this.clock.restore();
4334          }
4335  
4336          return sinon.fakeServer.restore.apply(this, arguments);
4337      };
4338  }());
4339  
4340  /**
4341   * @depend ../sinon.js
4342   * @depend collection.js
4343   * @depend util/fake_timers.js
4344   * @depend util/fake_server_with_clock.js
4345   */
4346  /*jslint eqeqeq: false, onevar: false, plusplus: false*/
4347  /*global require, module*/
4348  /**
4349   * Manages fake collections as well as fake utilities such as Sinon's
4350   * timers and fake XHR implementation in one convenient object.
4351   *
4352   * @author Christian Johansen ([email protected])
4353   * @license BSD
4354   *
4355   * Copyright (c) 2010-2013 Christian Johansen
4356   */
4357  
4358  if (typeof module !== "undefined" && module.exports && typeof require == "function") {
4359      var sinon = require("../sinon");
4360      sinon.extend(sinon, require("./util/fake_timers"));
4361  }
4362  
4363  (function () {
4364      var push = [].push;
4365  
4366      function exposeValue(sandbox, config, key, value) {
4367          if (!value) {
4368              return;
4369          }
4370  
4371          if (config.injectInto && !(key in config.injectInto)) {
4372              config.injectInto[key] = value;
4373              sandbox.injectedKeys.push(key);
4374          } else {
4375              push.call(sandbox.args, value);
4376          }
4377      }
4378  
4379      function prepareSandboxFromConfig(config) {
4380          var sandbox = sinon.create(sinon.sandbox);
4381  
4382          if (config.useFakeServer) {
4383              if (typeof config.useFakeServer == "object") {
4384                  sandbox.serverPrototype = config.useFakeServer;
4385              }
4386  
4387              sandbox.useFakeServer();
4388          }
4389  
4390          if (config.useFakeTimers) {
4391              if (typeof config.useFakeTimers == "object") {
4392                  sandbox.useFakeTimers.apply(sandbox, config.useFakeTimers);
4393              } else {
4394                  sandbox.useFakeTimers();
4395              }
4396          }
4397  
4398          return sandbox;
4399      }
4400  
4401      sinon.sandbox = sinon.extend(sinon.create(sinon.collection), {
4402          useFakeTimers: function useFakeTimers() {
4403              this.clock = sinon.useFakeTimers.apply(sinon, arguments);
4404  
4405              return this.add(this.clock);
4406          },
4407  
4408          serverPrototype: sinon.fakeServer,
4409  
4410          useFakeServer: function useFakeServer() {
4411              var proto = this.serverPrototype || sinon.fakeServer;
4412  
4413              if (!proto || !proto.create) {
4414                  return null;
4415              }
4416  
4417              this.server = proto.create();
4418              return this.add(this.server);
4419          },
4420  
4421          inject: function (obj) {
4422              sinon.collection.inject.call(this, obj);
4423  
4424              if (this.clock) {
4425                  obj.clock = this.clock;
4426              }
4427  
4428              if (this.server) {
4429                  obj.server = this.server;
4430                  obj.requests = this.server.requests;
4431              }
4432  
4433              return obj;
4434          },
4435  
4436          restore: function () {
4437              sinon.collection.restore.apply(this, arguments);
4438              this.restoreContext();
4439          },
4440  
4441          restoreContext: function () {
4442              if (this.injectedKeys) {
4443                  for (var i = 0, j = this.injectedKeys.length; i < j; i++) {
4444                      delete this.injectInto[this.injectedKeys[i]];
4445                  }
4446                  this.injectedKeys = [];
4447              }
4448          },
4449  
4450          create: function (config) {
4451              if (!config) {
4452                  return sinon.create(sinon.sandbox);
4453              }
4454  
4455              var sandbox = prepareSandboxFromConfig(config);
4456              sandbox.args = sandbox.args || [];
4457              sandbox.injectedKeys = [];
4458              sandbox.injectInto = config.injectInto;
4459              var prop, value, exposed = sandbox.inject({});
4460  
4461              if (config.properties) {
4462                  for (var i = 0, l = config.properties.length; i < l; i++) {
4463                      prop = config.properties[i];
4464                      value = exposed[prop] || prop == "sandbox" && sandbox;
4465                      exposeValue(sandbox, config, prop, value);
4466                  }
4467              } else {
4468                  exposeValue(sandbox, config, "sandbox", value);
4469              }
4470  
4471              return sandbox;
4472          }
4473      });
4474  
4475      sinon.sandbox.useFakeXMLHttpRequest = sinon.sandbox.useFakeServer;
4476  
4477      if (typeof define === "function" && define.amd) {
4478          define(["module"], function(module) { module.exports = sinon.sandbox; });
4479      } else if (typeof module !== 'undefined' && module.exports) {
4480          module.exports = sinon.sandbox;
4481      }
4482  }());
4483  
4484  /**
4485   * @depend ../sinon.js
4486   * @depend stub.js
4487   * @depend mock.js
4488   * @depend sandbox.js
4489   */
4490  /*jslint eqeqeq: false, onevar: false, forin: true, plusplus: false*/
4491  /*global module, require, sinon*/
4492  /**
4493   * Test function, sandboxes fakes
4494   *
4495   * @author Christian Johansen ([email protected])
4496   * @license BSD
4497   *
4498   * Copyright (c) 2010-2013 Christian Johansen
4499   */
4500  
4501  (function (sinon) {
4502      var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function";
4503  
4504      if (!sinon && commonJSModule) {
4505          sinon = require("../sinon");
4506      }
4507  
4508      if (!sinon) {
4509          return;
4510      }
4511  
4512      function test(callback) {
4513          var type = typeof callback;
4514  
4515          if (type != "function") {
4516              throw new TypeError("sinon.test needs to wrap a test function, got " + type);
4517          }
4518  
4519          function sinonSandboxedTest() {
4520              var config = sinon.getConfig(sinon.config);
4521              config.injectInto = config.injectIntoThis && this || config.injectInto;
4522              var sandbox = sinon.sandbox.create(config);
4523              var exception, result;
4524              var args = Array.prototype.slice.call(arguments).concat(sandbox.args);
4525  
4526              try {
4527                  result = callback.apply(this, args);
4528              } catch (e) {
4529                  exception = e;
4530              }
4531  
4532              if (typeof exception !== "undefined") {
4533                  sandbox.restore();
4534                  throw exception;
4535              }
4536              else {
4537                  sandbox.verifyAndRestore();
4538              }
4539  
4540              return result;
4541          };
4542  
4543          if (callback.length) {
4544              return function sinonAsyncSandboxedTest(callback) {
4545                  return sinonSandboxedTest.apply(this, arguments);
4546              };
4547          }
4548  
4549          return sinonSandboxedTest;
4550      }
4551  
4552      test.config = {
4553          injectIntoThis: true,
4554          injectInto: null,
4555          properties: ["spy", "stub", "mock", "clock", "server", "requests"],
4556          useFakeTimers: true,
4557          useFakeServer: true
4558      };
4559  
4560      sinon.test = test;
4561  
4562      if (typeof define === "function" && define.amd) {
4563          define(["module"], function(module) { module.exports = test; });
4564      } else if (commonJSModule) {
4565          module.exports = test;
4566      }
4567  }(typeof sinon == "object" && sinon || null));
4568  
4569  /**
4570   * @depend ../sinon.js
4571   * @depend test.js
4572   */
4573  /*jslint eqeqeq: false, onevar: false, eqeqeq: false*/
4574  /*global module, require, sinon*/
4575  /**
4576   * Test case, sandboxes all test functions
4577   *
4578   * @author Christian Johansen ([email protected])
4579   * @license BSD
4580   *
4581   * Copyright (c) 2010-2013 Christian Johansen
4582   */
4583  
4584  (function (sinon) {
4585      var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function";
4586  
4587      if (!sinon && commonJSModule) {
4588          sinon = require("../sinon");
4589      }
4590  
4591      if (!sinon || !Object.prototype.hasOwnProperty) {
4592          return;
4593      }
4594  
4595      function createTest(property, setUp, tearDown) {
4596          return function () {
4597              if (setUp) {
4598                  setUp.apply(this, arguments);
4599              }
4600  
4601              var exception, result;
4602  
4603              try {
4604                  result = property.apply(this, arguments);
4605              } catch (e) {
4606                  exception = e;
4607              }
4608  
4609              if (tearDown) {
4610                  tearDown.apply(this, arguments);
4611              }
4612  
4613              if (exception) {
4614                  throw exception;
4615              }
4616  
4617              return result;
4618          };
4619      }
4620  
4621      function testCase(tests, prefix) {
4622          /*jsl:ignore*/
4623          if (!tests || typeof tests != "object") {
4624              throw new TypeError("sinon.testCase needs an object with test functions");
4625          }
4626          /*jsl:end*/
4627  
4628          prefix = prefix || "test";
4629          var rPrefix = new RegExp("^" + prefix);
4630          var methods = {}, testName, property, method;
4631          var setUp = tests.setUp;
4632          var tearDown = tests.tearDown;
4633  
4634          for (testName in tests) {
4635              if (tests.hasOwnProperty(testName)) {
4636                  property = tests[testName];
4637  
4638                  if (/^(setUp|tearDown)$/.test(testName)) {
4639                      continue;
4640                  }
4641  
4642                  if (typeof property == "function" && rPrefix.test(testName)) {
4643                      method = property;
4644  
4645                      if (setUp || tearDown) {
4646                          method = createTest(property, setUp, tearDown);
4647                      }
4648  
4649                      methods[testName] = sinon.test(method);
4650                  } else {
4651                      methods[testName] = tests[testName];
4652                  }
4653              }
4654          }
4655  
4656          return methods;
4657      }
4658  
4659      sinon.testCase = testCase;
4660  
4661      if (typeof define === "function" && define.amd) {
4662          define(["module"], function(module) { module.exports = testCase; });
4663      } else if (commonJSModule) {
4664          module.exports = testCase;
4665      }
4666  }(typeof sinon == "object" && sinon || null));
4667  
4668  /**
4669   * @depend ../sinon.js
4670   * @depend stub.js
4671   */
4672  /*jslint eqeqeq: false, onevar: false, nomen: false, plusplus: false*/
4673  /*global module, require, sinon*/
4674  /**
4675   * Assertions matching the test spy retrieval interface.
4676   *
4677   * @author Christian Johansen ([email protected])
4678   * @license BSD
4679   *
4680   * Copyright (c) 2010-2013 Christian Johansen
4681   */
4682  
4683  (function (sinon, global) {
4684      var commonJSModule = typeof module !== "undefined" && module.exports && typeof require == "function";
4685      var slice = Array.prototype.slice;
4686      var assert;
4687  
4688      if (!sinon && commonJSModule) {
4689          sinon = require("../sinon");
4690      }
4691  
4692      if (!sinon) {
4693          return;
4694      }
4695  
4696      function verifyIsStub() {
4697          var method;
4698  
4699          for (var i = 0, l = arguments.length; i < l; ++i) {
4700              method = arguments[i];
4701  
4702              if (!method) {
4703                  assert.fail("fake is not a spy");
4704              }
4705  
4706              if (typeof method != "function") {
4707                  assert.fail(method + " is not a function");
4708              }
4709  
4710              if (typeof method.getCall != "function") {
4711                  assert.fail(method + " is not stubbed");
4712              }
4713          }
4714      }
4715  
4716      function failAssertion(object, msg) {
4717          object = object || global;
4718          var failMethod = object.fail || assert.fail;
4719          failMethod.call(object, msg);
4720      }
4721  
4722      function mirrorPropAsAssertion(name, method, message) {
4723          if (arguments.length == 2) {
4724              message = method;
4725              method = name;
4726          }
4727  
4728          assert[name] = function (fake) {
4729              verifyIsStub(fake);
4730  
4731              var args = slice.call(arguments, 1);
4732              var failed = false;
4733  
4734              if (typeof method == "function") {
4735                  failed = !method(fake);
4736              } else {
4737                  failed = typeof fake[method] == "function" ?
4738                      !fake[method].apply(fake, args) : !fake[method];
4739              }
4740  
4741              if (failed) {
4742                  failAssertion(this, fake.printf.apply(fake, [message].concat(args)));
4743              } else {
4744                  assert.pass(name);
4745              }
4746          };
4747      }
4748  
4749      function exposedName(prefix, prop) {
4750          return !prefix || /^fail/.test(prop) ? prop :
4751              prefix + prop.slice(0, 1).toUpperCase() + prop.slice(1);
4752      }
4753  
4754      assert = {
4755          failException: "AssertError",
4756  
4757          fail: function fail(message) {
4758              var error = new Error(message);
4759              error.name = this.failException || assert.failException;
4760  
4761              throw error;
4762          },
4763  
4764          pass: function pass(assertion) {},
4765  
4766          callOrder: function assertCallOrder() {
4767              verifyIsStub.apply(null, arguments);
4768              var expected = "", actual = "";
4769  
4770              if (!sinon.calledInOrder(arguments)) {
4771                  try {
4772                      expected = [].join.call(arguments, ", ");
4773                      var calls = slice.call(arguments);
4774                      var i = calls.length;
4775                      while (i) {
4776                          if (!calls[--i].called) {
4777                              calls.splice(i, 1);
4778                          }
4779                      }
4780                      actual = sinon.orderByFirstCall(calls).join(", ");
4781                  } catch (e) {
4782                      // If this fails, we'll just fall back to the blank string
4783                  }
4784  
4785                  failAssertion(this, "expected " + expected + " to be " +
4786                                "called in order but were called as " + actual);
4787              } else {
4788                  assert.pass("callOrder");
4789              }
4790          },
4791  
4792          callCount: function assertCallCount(method, count) {
4793              verifyIsStub(method);
4794  
4795              if (method.callCount != count) {
4796                  var msg = "expected %n to be called " + sinon.timesInWords(count) +
4797                      " but was called %c%C";
4798                  failAssertion(this, method.printf(msg));
4799              } else {
4800                  assert.pass("callCount");
4801              }
4802          },
4803  
4804          expose: function expose(target, options) {
4805              if (!target) {
4806                  throw new TypeError("target is null or undefined");
4807              }
4808  
4809              var o = options || {};
4810              var prefix = typeof o.prefix == "undefined" && "assert" || o.prefix;
4811              var includeFail = typeof o.includeFail == "undefined" || !!o.includeFail;
4812  
4813              for (var method in this) {
4814                  if (method != "export" && (includeFail || !/^(fail)/.test(method))) {
4815                      target[exposedName(prefix, method)] = this[method];
4816                  }
4817              }
4818  
4819              return target;
4820          },
4821  
4822          match: function match(actual, expectation) {
4823              var matcher = sinon.match(expectation);
4824              if (matcher.test(actual)) {
4825                  assert.pass("match");
4826              } else {
4827                  var formatted = [
4828                      "expected value to match",
4829                      "    expected = " + sinon.format(expectation),
4830                      "    actual = " + sinon.format(actual)
4831                  ]
4832                  failAssertion(this, formatted.join("\n"));
4833              }
4834          }
4835      };
4836  
4837      mirrorPropAsAssertion("called", "expected %n to have been called at least once but was never called");
4838      mirrorPropAsAssertion("notCalled", function (spy) { return !spy.called; },
4839                            "expected %n to not have been called but was called %c%C");
4840      mirrorPropAsAssertion("calledOnce", "expected %n to be called once but was called %c%C");
4841      mirrorPropAsAssertion("calledTwice", "expected %n to be called twice but was called %c%C");
4842      mirrorPropAsAssertion("calledThrice", "expected %n to be called thrice but was called %c%C");
4843      mirrorPropAsAssertion("calledOn", "expected %n to be called with %1 as this but was called with %t");
4844      mirrorPropAsAssertion("alwaysCalledOn", "expected %n to always be called with %1 as this but was called with %t");
4845      mirrorPropAsAssertion("calledWithNew", "expected %n to be called with new");
4846      mirrorPropAsAssertion("alwaysCalledWithNew", "expected %n to always be called with new");
4847      mirrorPropAsAssertion("calledWith", "expected %n to be called with arguments %*%C");
4848      mirrorPropAsAssertion("calledWithMatch", "expected %n to be called with match %*%C");
4849      mirrorPropAsAssertion("alwaysCalledWith", "expected %n to always be called with arguments %*%C");
4850      mirrorPropAsAssertion("alwaysCalledWithMatch", "expected %n to always be called with match %*%C");
4851      mirrorPropAsAssertion("calledWithExactly", "expected %n to be called with exact arguments %*%C");
4852      mirrorPropAsAssertion("alwaysCalledWithExactly", "expected %n to always be called with exact arguments %*%C");
4853      mirrorPropAsAssertion("neverCalledWith", "expected %n to never be called with arguments %*%C");
4854      mirrorPropAsAssertion("neverCalledWithMatch", "expected %n to never be called with match %*%C");
4855      mirrorPropAsAssertion("threw", "%n did not throw exception%C");
4856      mirrorPropAsAssertion("alwaysThrew", "%n did not always throw exception%C");
4857  
4858      sinon.assert = assert;
4859  
4860      if (typeof define === "function" && define.amd) {
4861          define(["module"], function(module) { module.exports = assert; });
4862      } else if (commonJSModule) {
4863          module.exports = assert;
4864      }
4865  }(typeof sinon == "object" && sinon || null, typeof window != "undefined" ? window : (typeof self != "undefined") ? self : global));
4866  
4867  /**
4868   * @depend ../../sinon.js
4869   * @depend event.js
4870   */
4871  /*jslint eqeqeq: false, onevar: false*/
4872  /*global sinon, module, require, XDomainRequest*/
4873  /**
4874   * Fake XDomainRequest object
4875   */
4876  
4877  if (typeof sinon == "undefined") {
4878      this.sinon = {};
4879  }
4880  sinon.xdr = { XDomainRequest: this.XDomainRequest };
4881  
4882  // wrapper for global
4883  (function (global) {
4884      var xdr = sinon.xdr;
4885      xdr.GlobalXDomainRequest = global.XDomainRequest;
4886      xdr.supportsXDR = typeof xdr.GlobalXDomainRequest != "undefined";
4887      xdr.workingXDR = xdr.supportsXDR ? xdr.GlobalXDomainRequest :  false;
4888  
4889      function FakeXDomainRequest() {
4890          this.readyState = FakeXDomainRequest.UNSENT;
4891          this.requestBody = null;
4892          this.requestHeaders = {};
4893          this.status = 0;
4894          this.timeout = null;
4895  
4896          if (typeof FakeXDomainRequest.onCreate == "function") {
4897              FakeXDomainRequest.onCreate(this);
4898          }
4899      }
4900  
4901      function verifyState(xdr) {
4902          if (xdr.readyState !== FakeXDomainRequest.OPENED) {
4903              throw new Error("INVALID_STATE_ERR");
4904          }
4905  
4906          if (xdr.sendFlag) {
4907              throw new Error("INVALID_STATE_ERR");
4908          }
4909      }
4910  
4911      function verifyRequestSent(xdr) {
4912          if (xdr.readyState == FakeXDomainRequest.UNSENT) {
4913              throw new Error("Request not sent");
4914          }
4915          if (xdr.readyState == FakeXDomainRequest.DONE) {
4916              throw new Error("Request done");
4917          }
4918      }
4919  
4920      function verifyResponseBodyType(body) {
4921          if (typeof body != "string") {
4922              var error = new Error("Attempted to respond to fake XDomainRequest with " +
4923                                    body + ", which is not a string.");
4924              error.name = "InvalidBodyException";
4925              throw error;
4926          }
4927      }
4928  
4929      sinon.extend(FakeXDomainRequest.prototype, sinon.EventTarget, {
4930          open: function open(method, url) {
4931              this.method = method;
4932              this.url = url;
4933  
4934              this.responseText = null;
4935              this.sendFlag = false;
4936  
4937              this.readyStateChange(FakeXDomainRequest.OPENED);
4938          },
4939  
4940          readyStateChange: function readyStateChange(state) {
4941              this.readyState = state;
4942              var eventName = '';
4943              switch (this.readyState) {
4944              case FakeXDomainRequest.UNSENT:
4945                  break;
4946              case FakeXDomainRequest.OPENED:
4947                  break;
4948              case FakeXDomainRequest.LOADING:
4949                  if (this.sendFlag){
4950                      //raise the progress event
4951                      eventName = 'onprogress';
4952                  }
4953                  break;
4954              case FakeXDomainRequest.DONE:
4955                  if (this.isTimeout){
4956                      eventName = 'ontimeout'
4957                  }
4958                  else if (this.errorFlag || (this.status < 200 || this.status > 299)) {
4959                      eventName = 'onerror';
4960                  }
4961                  else {
4962                      eventName = 'onload'
4963                  }
4964                  break;
4965              }
4966  
4967              // raising event (if defined)
4968              if (eventName) {
4969                  if (typeof this[eventName] == "function") {
4970                      try {
4971                          this[eventName]();
4972                      } catch (e) {
4973                          sinon.logError("Fake XHR " + eventName + " handler", e);
4974                      }
4975                  }
4976              }
4977          },
4978  
4979          send: function send(data) {
4980              verifyState(this);
4981  
4982              if (!/^(get|head)$/i.test(this.method)) {
4983                  this.requestBody = data;
4984              }
4985              this.requestHeaders["Content-Type"] = "text/plain;charset=utf-8";
4986  
4987              this.errorFlag = false;
4988              this.sendFlag = true;
4989              this.readyStateChange(FakeXDomainRequest.OPENED);
4990  
4991              if (typeof this.onSend == "function") {
4992                  this.onSend(this);
4993              }
4994          },
4995  
4996          abort: function abort() {
4997              this.aborted = true;
4998              this.responseText = null;
4999              this.errorFlag = true;
5000  
5001              if (this.readyState > sinon.FakeXDomainRequest.UNSENT && this.sendFlag) {
5002                  this.readyStateChange(sinon.FakeXDomainRequest.DONE);
5003                  this.sendFlag = false;
5004              }
5005          },
5006  
5007          setResponseBody: function setResponseBody(body) {
5008              verifyRequestSent(this);
5009              verifyResponseBodyType(body);
5010  
5011              var chunkSize = this.chunkSize || 10;
5012              var index = 0;
5013              this.responseText = "";
5014  
5015              do {
5016                  this.readyStateChange(FakeXDomainRequest.LOADING);
5017                  this.responseText += body.substring(index, index + chunkSize);
5018                  index += chunkSize;
5019              } while (index < body.length);
5020  
5021              this.readyStateChange(FakeXDomainRequest.DONE);
5022          },
5023  
5024          respond: function respond(status, contentType, body) {
5025              // content-type ignored, since XDomainRequest does not carry this
5026              // we keep the same syntax for respond(...) as for FakeXMLHttpRequest to ease
5027              // test integration across browsers
5028              this.status = typeof status == "number" ? status : 200;
5029              this.setResponseBody(body || "");
5030          },
5031  
5032          simulatetimeout: function(){
5033              this.status = 0;
5034              this.isTimeout = true;
5035              // Access to this should actually throw an error
5036              this.responseText = undefined;
5037              this.readyStateChange(FakeXDomainRequest.DONE);
5038          }
5039      });
5040  
5041      sinon.extend(FakeXDomainRequest, {
5042          UNSENT: 0,
5043          OPENED: 1,
5044          LOADING: 3,
5045          DONE: 4
5046      });
5047  
5048      sinon.useFakeXDomainRequest = function () {
5049          sinon.FakeXDomainRequest.restore = function restore(keepOnCreate) {
5050              if (xdr.supportsXDR) {
5051                  global.XDomainRequest = xdr.GlobalXDomainRequest;
5052              }
5053  
5054              delete sinon.FakeXDomainRequest.restore;
5055  
5056              if (keepOnCreate !== true) {
5057                  delete sinon.FakeXDomainRequest.onCreate;
5058              }
5059          };
5060          if (xdr.supportsXDR) {
5061              global.XDomainRequest = sinon.FakeXDomainRequest;
5062          }
5063          return sinon.FakeXDomainRequest;
5064      };
5065  
5066      sinon.FakeXDomainRequest = FakeXDomainRequest;
5067  })(this);
5068  
5069  if (typeof module == "object" && typeof require == "function") {
5070      module.exports = sinon;
5071  }
5072  
5073  return sinon;}.call(typeof window != 'undefined' && window || {}));