[Summary view] [Print] [Text view]

   1  /*!
   2   * QUnit 1.14.0
   3   * http://qunitjs.com/
   4   *
   5   * Copyright 2013 jQuery Foundation and other contributors
   6   * Released under the MIT license
   7   * http://jquery.org/license
   8   *
   9   * Date: 2014-01-31T16:40Z
  10   */
  11  
  12  (function( window ) {
  13  
  14  var QUnit,
  15      assert,
  16      config,
  17      onErrorFnPrev,
  18      testId = 0,
  19      fileName = (sourceFromStacktrace( 0 ) || "" ).replace(/(:\d+)+\)?/, "").replace(/.+\//, ""),
  20      toString = Object.prototype.toString,
  21      hasOwn = Object.prototype.hasOwnProperty,
  22      // Keep a local reference to Date (GH-283)
  23      Date = window.Date,
  24      setTimeout = window.setTimeout,
  25      clearTimeout = window.clearTimeout,
  26      defined = {
  27          document: typeof window.document !== "undefined",
  28          setTimeout: typeof window.setTimeout !== "undefined",
  29          sessionStorage: (function() {
  30              var x = "qunit-test-string";
  31              try {
  32                  sessionStorage.setItem( x, x );
  33                  sessionStorage.removeItem( x );
  34                  return true;
  35              } catch( e ) {
  36                  return false;
  37              }
  38          }())
  39      },
  40      /**
  41       * Provides a normalized error string, correcting an issue
  42       * with IE 7 (and prior) where Error.prototype.toString is
  43       * not properly implemented
  44       *
  45       * Based on http://es5.github.com/#x15.11.4.4
  46       *
  47       * @param {String|Error} error
  48       * @return {String} error message
  49       */
  50      errorString = function( error ) {
  51          var name, message,
  52              errorString = error.toString();
  53          if ( errorString.substring( 0, 7 ) === "[object" ) {
  54              name = error.name ? error.name.toString() : "Error";
  55              message = error.message ? error.message.toString() : "";
  56              if ( name && message ) {
  57                  return name + ": " + message;
  58              } else if ( name ) {
  59                  return name;
  60              } else if ( message ) {
  61                  return message;
  62              } else {
  63                  return "Error";
  64              }
  65          } else {
  66              return errorString;
  67          }
  68      },
  69      /**
  70       * Makes a clone of an object using only Array or Object as base,
  71       * and copies over the own enumerable properties.
  72       *
  73       * @param {Object} obj
  74       * @return {Object} New object with only the own properties (recursively).
  75       */
  76      objectValues = function( obj ) {
  77          // Grunt 0.3.x uses an older version of jshint that still has jshint/jshint#392.
  78          /*jshint newcap: false */
  79          var key, val,
  80              vals = QUnit.is( "array", obj ) ? [] : {};
  81          for ( key in obj ) {
  82              if ( hasOwn.call( obj, key ) ) {
  83                  val = obj[key];
  84                  vals[key] = val === Object(val) ? objectValues(val) : val;
  85              }
  86          }
  87          return vals;
  88      };
  89  
  90  
  91  // Root QUnit object.
  92  // `QUnit` initialized at top of scope
  93  QUnit = {
  94  
  95      // call on start of module test to prepend name to all tests
  96      module: function( name, testEnvironment ) {
  97          config.currentModule = name;
  98          config.currentModuleTestEnvironment = testEnvironment;
  99          config.modules[name] = true;
 100      },
 101  
 102      asyncTest: function( testName, expected, callback ) {
 103          if ( arguments.length === 2 ) {
 104              callback = expected;
 105              expected = null;
 106          }
 107  
 108          QUnit.test( testName, expected, callback, true );
 109      },
 110  
 111      test: function( testName, expected, callback, async ) {
 112          var test,
 113              nameHtml = "<span class='test-name'>" + escapeText( testName ) + "</span>";
 114  
 115          if ( arguments.length === 2 ) {
 116              callback = expected;
 117              expected = null;
 118          }
 119  
 120          if ( config.currentModule ) {
 121              nameHtml = "<span class='module-name'>" + escapeText( config.currentModule ) + "</span>: " + nameHtml;
 122          }
 123  
 124          test = new Test({
 125              nameHtml: nameHtml,
 126              testName: testName,
 127              expected: expected,
 128              async: async,
 129              callback: callback,
 130              module: config.currentModule,
 131              moduleTestEnvironment: config.currentModuleTestEnvironment,
 132              stack: sourceFromStacktrace( 2 )
 133          });
 134  
 135          if ( !validTest( test ) ) {
 136              return;
 137          }
 138  
 139          test.queue();
 140      },
 141  
 142      // Specify the number of expected assertions to guarantee that failed test (no assertions are run at all) don't slip through.
 143      expect: function( asserts ) {
 144          if (arguments.length === 1) {
 145              config.current.expected = asserts;
 146          } else {
 147              return config.current.expected;
 148          }
 149      },
 150  
 151      start: function( count ) {
 152          // QUnit hasn't been initialized yet.
 153          // Note: RequireJS (et al) may delay onLoad
 154          if ( config.semaphore === undefined ) {
 155              QUnit.begin(function() {
 156                  // This is triggered at the top of QUnit.load, push start() to the event loop, to allow QUnit.load to finish first
 157                  setTimeout(function() {
 158                      QUnit.start( count );
 159                  });
 160              });
 161              return;
 162          }
 163  
 164          config.semaphore -= count || 1;
 165          // don't start until equal number of stop-calls
 166          if ( config.semaphore > 0 ) {
 167              return;
 168          }
 169          // ignore if start is called more often then stop
 170          if ( config.semaphore < 0 ) {
 171              config.semaphore = 0;
 172              QUnit.pushFailure( "Called start() while already started (QUnit.config.semaphore was 0 already)", null, sourceFromStacktrace(2) );
 173              return;
 174          }
 175          // A slight delay, to avoid any current callbacks
 176          if ( defined.setTimeout ) {
 177              setTimeout(function() {
 178                  if ( config.semaphore > 0 ) {
 179                      return;
 180                  }
 181                  if ( config.timeout ) {
 182                      clearTimeout( config.timeout );
 183                  }
 184  
 185                  config.blocking = false;
 186                  process( true );
 187              }, 13);
 188          } else {
 189              config.blocking = false;
 190              process( true );
 191          }
 192      },
 193  
 194      stop: function( count ) {
 195          config.semaphore += count || 1;
 196          config.blocking = true;
 197  
 198          if ( config.testTimeout && defined.setTimeout ) {
 199              clearTimeout( config.timeout );
 200              config.timeout = setTimeout(function() {
 201                  QUnit.ok( false, "Test timed out" );
 202                  config.semaphore = 1;
 203                  QUnit.start();
 204              }, config.testTimeout );
 205          }
 206      }
 207  };
 208  
 209  // We use the prototype to distinguish between properties that should
 210  // be exposed as globals (and in exports) and those that shouldn't
 211  (function() {
 212      function F() {}
 213      F.prototype = QUnit;
 214      QUnit = new F();
 215      // Make F QUnit's constructor so that we can add to the prototype later
 216      QUnit.constructor = F;
 217  }());
 218  
 219  /**
 220   * Config object: Maintain internal state
 221   * Later exposed as QUnit.config
 222   * `config` initialized at top of scope
 223   */
 224  config = {
 225      // The queue of tests to run
 226      queue: [],
 227  
 228      // block until document ready
 229      blocking: true,
 230  
 231      // when enabled, show only failing tests
 232      // gets persisted through sessionStorage and can be changed in UI via checkbox
 233      hidepassed: false,
 234  
 235      // by default, run previously failed tests first
 236      // very useful in combination with "Hide passed tests" checked
 237      reorder: true,
 238  
 239      // by default, modify document.title when suite is done
 240      altertitle: true,
 241  
 242      // by default, scroll to top of the page when suite is done
 243      scrolltop: true,
 244  
 245      // when enabled, all tests must call expect()
 246      requireExpects: false,
 247  
 248      // add checkboxes that are persisted in the query-string
 249      // when enabled, the id is set to `true` as a `QUnit.config` property
 250      urlConfig: [
 251          {
 252              id: "noglobals",
 253              label: "Check for Globals",
 254              tooltip: "Enabling this will test if any test introduces new properties on the `window` object. Stored as query-strings."
 255          },
 256          {
 257              id: "notrycatch",
 258              label: "No try-catch",
 259              tooltip: "Enabling this will run tests outside of a try-catch block. Makes debugging exceptions in IE reasonable. Stored as query-strings."
 260          }
 261      ],
 262  
 263      // Set of all modules.
 264      modules: {},
 265  
 266      // logging callback queues
 267      begin: [],
 268      done: [],
 269      log: [],
 270      testStart: [],
 271      testDone: [],
 272      moduleStart: [],
 273      moduleDone: []
 274  };
 275  
 276  // Initialize more QUnit.config and QUnit.urlParams
 277  (function() {
 278      var i, current,
 279          location = window.location || { search: "", protocol: "file:" },
 280          params = location.search.slice( 1 ).split( "&" ),
 281          length = params.length,
 282          urlParams = {};
 283  
 284      if ( params[ 0 ] ) {
 285          for ( i = 0; i < length; i++ ) {
 286              current = params[ i ].split( "=" );
 287              current[ 0 ] = decodeURIComponent( current[ 0 ] );
 288  
 289              // allow just a key to turn on a flag, e.g., test.html?noglobals
 290              current[ 1 ] = current[ 1 ] ? decodeURIComponent( current[ 1 ] ) : true;
 291              if ( urlParams[ current[ 0 ] ] ) {
 292                  urlParams[ current[ 0 ] ] = [].concat( urlParams[ current[ 0 ] ], current[ 1 ] );
 293              } else {
 294                  urlParams[ current[ 0 ] ] = current[ 1 ];
 295              }
 296          }
 297      }
 298  
 299      QUnit.urlParams = urlParams;
 300  
 301      // String search anywhere in moduleName+testName
 302      config.filter = urlParams.filter;
 303  
 304      // Exact match of the module name
 305      config.module = urlParams.module;
 306  
 307      config.testNumber = [];
 308      if ( urlParams.testNumber ) {
 309  
 310          // Ensure that urlParams.testNumber is an array
 311          urlParams.testNumber = [].concat( urlParams.testNumber );
 312          for ( i = 0; i < urlParams.testNumber.length; i++ ) {
 313              current = urlParams.testNumber[ i ];
 314              config.testNumber.push( parseInt( current, 10 ) );
 315          }
 316      }
 317  
 318      // Figure out if we're running the tests from a server or not
 319      QUnit.isLocal = location.protocol === "file:";
 320  }());
 321  
 322  extend( QUnit, {
 323  
 324      config: config,
 325  
 326      // Initialize the configuration options
 327      init: function() {
 328          extend( config, {
 329              stats: { all: 0, bad: 0 },
 330              moduleStats: { all: 0, bad: 0 },
 331              started: +new Date(),
 332              updateRate: 1000,
 333              blocking: false,
 334              autostart: true,
 335              autorun: false,
 336              filter: "",
 337              queue: [],
 338              semaphore: 1
 339          });
 340  
 341          var tests, banner, result,
 342              qunit = id( "qunit" );
 343  
 344          if ( qunit ) {
 345              qunit.innerHTML =
 346                  "<h1 id='qunit-header'>" + escapeText( document.title ) + "</h1>" +
 347                  "<h2 id='qunit-banner'></h2>" +
 348                  "<div id='qunit-testrunner-toolbar'></div>" +
 349                  "<h2 id='qunit-userAgent'></h2>" +
 350                  "<ol id='qunit-tests'></ol>";
 351          }
 352  
 353          tests = id( "qunit-tests" );
 354          banner = id( "qunit-banner" );
 355          result = id( "qunit-testresult" );
 356  
 357          if ( tests ) {
 358              tests.innerHTML = "";
 359          }
 360  
 361          if ( banner ) {
 362              banner.className = "";
 363          }
 364  
 365          if ( result ) {
 366              result.parentNode.removeChild( result );
 367          }
 368  
 369          if ( tests ) {
 370              result = document.createElement( "p" );
 371              result.id = "qunit-testresult";
 372              result.className = "result";
 373              tests.parentNode.insertBefore( result, tests );
 374              result.innerHTML = "Running...<br/>&nbsp;";
 375          }
 376      },
 377  
 378      // Resets the test setup. Useful for tests that modify the DOM.
 379      /*
 380      DEPRECATED: Use multiple tests instead of resetting inside a test.
 381      Use testStart or testDone for custom cleanup.
 382      This method will throw an error in 2.0, and will be removed in 2.1
 383      */
 384      reset: function() {
 385          var fixture = id( "qunit-fixture" );
 386          if ( fixture ) {
 387              fixture.innerHTML = config.fixture;
 388          }
 389      },
 390  
 391      // Safe object type checking
 392      is: function( type, obj ) {
 393          return QUnit.objectType( obj ) === type;
 394      },
 395  
 396      objectType: function( obj ) {
 397          if ( typeof obj === "undefined" ) {
 398              return "undefined";
 399          }
 400  
 401          // Consider: typeof null === object
 402          if ( obj === null ) {
 403              return "null";
 404          }
 405  
 406          var match = toString.call( obj ).match(/^\[object\s(.*)\]$/),
 407              type = match && match[1] || "";
 408  
 409          switch ( type ) {
 410              case "Number":
 411                  if ( isNaN(obj) ) {
 412                      return "nan";
 413                  }
 414                  return "number";
 415              case "String":
 416              case "Boolean":
 417              case "Array":
 418              case "Date":
 419              case "RegExp":
 420              case "Function":
 421                  return type.toLowerCase();
 422          }
 423          if ( typeof obj === "object" ) {
 424              return "object";
 425          }
 426          return undefined;
 427      },
 428  
 429      push: function( result, actual, expected, message ) {
 430          if ( !config.current ) {
 431              throw new Error( "assertion outside test context, was " + sourceFromStacktrace() );
 432          }
 433  
 434          var output, source,
 435              details = {
 436                  module: config.current.module,
 437                  name: config.current.testName,
 438                  result: result,
 439                  message: message,
 440                  actual: actual,
 441                  expected: expected
 442              };
 443  
 444          message = escapeText( message ) || ( result ? "okay" : "failed" );
 445          message = "<span class='test-message'>" + message + "</span>";
 446          output = message;
 447  
 448          if ( !result ) {
 449              expected = escapeText( QUnit.jsDump.parse(expected) );
 450              actual = escapeText( QUnit.jsDump.parse(actual) );
 451              output += "<table><tr class='test-expected'><th>Expected: </th><td><pre>" + expected + "</pre></td></tr>";
 452  
 453              if ( actual !== expected ) {
 454                  output += "<tr class='test-actual'><th>Result: </th><td><pre>" + actual + "</pre></td></tr>";
 455                  output += "<tr class='test-diff'><th>Diff: </th><td><pre>" + QUnit.diff( expected, actual ) + "</pre></td></tr>";
 456              }
 457  
 458              source = sourceFromStacktrace();
 459  
 460              if ( source ) {
 461                  details.source = source;
 462                  output += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr>";
 463              }
 464  
 465              output += "</table>";
 466          }
 467  
 468          runLoggingCallbacks( "log", QUnit, details );
 469  
 470          config.current.assertions.push({
 471              result: !!result,
 472              message: output
 473          });
 474      },
 475  
 476      pushFailure: function( message, source, actual ) {
 477          if ( !config.current ) {
 478              throw new Error( "pushFailure() assertion outside test context, was " + sourceFromStacktrace(2) );
 479          }
 480  
 481          var output,
 482              details = {
 483                  module: config.current.module,
 484                  name: config.current.testName,
 485                  result: false,
 486                  message: message
 487              };
 488  
 489          message = escapeText( message ) || "error";
 490          message = "<span class='test-message'>" + message + "</span>";
 491          output = message;
 492  
 493          output += "<table>";
 494  
 495          if ( actual ) {
 496              output += "<tr class='test-actual'><th>Result: </th><td><pre>" + escapeText( actual ) + "</pre></td></tr>";
 497          }
 498  
 499          if ( source ) {
 500              details.source = source;
 501              output += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr>";
 502          }
 503  
 504          output += "</table>";
 505  
 506          runLoggingCallbacks( "log", QUnit, details );
 507  
 508          config.current.assertions.push({
 509              result: false,
 510              message: output
 511          });
 512      },
 513  
 514      url: function( params ) {
 515          params = extend( extend( {}, QUnit.urlParams ), params );
 516          var key,
 517              querystring = "?";
 518  
 519          for ( key in params ) {
 520              if ( hasOwn.call( params, key ) ) {
 521                  querystring += encodeURIComponent( key ) + "=" +
 522                      encodeURIComponent( params[ key ] ) + "&";
 523              }
 524          }
 525          return window.location.protocol + "//" + window.location.host +
 526              window.location.pathname + querystring.slice( 0, -1 );
 527      },
 528  
 529      extend: extend,
 530      id: id,
 531      addEvent: addEvent,
 532      addClass: addClass,
 533      hasClass: hasClass,
 534      removeClass: removeClass
 535      // load, equiv, jsDump, diff: Attached later
 536  });
 537  
 538  /**
 539   * @deprecated: Created for backwards compatibility with test runner that set the hook function
 540   * into QUnit.{hook}, instead of invoking it and passing the hook function.
 541   * QUnit.constructor is set to the empty F() above so that we can add to it's prototype here.
 542   * Doing this allows us to tell if the following methods have been overwritten on the actual
 543   * QUnit object.
 544   */
 545  extend( QUnit.constructor.prototype, {
 546  
 547      // Logging callbacks; all receive a single argument with the listed properties
 548      // run test/logs.html for any related changes
 549      begin: registerLoggingCallback( "begin" ),
 550  
 551      // done: { failed, passed, total, runtime }
 552      done: registerLoggingCallback( "done" ),
 553  
 554      // log: { result, actual, expected, message }
 555      log: registerLoggingCallback( "log" ),
 556  
 557      // testStart: { name }
 558      testStart: registerLoggingCallback( "testStart" ),
 559  
 560      // testDone: { name, failed, passed, total, runtime }
 561      testDone: registerLoggingCallback( "testDone" ),
 562  
 563      // moduleStart: { name }
 564      moduleStart: registerLoggingCallback( "moduleStart" ),
 565  
 566      // moduleDone: { name, failed, passed, total }
 567      moduleDone: registerLoggingCallback( "moduleDone" )
 568  });
 569  
 570  if ( !defined.document || document.readyState === "complete" ) {
 571      config.autorun = true;
 572  }
 573  
 574  QUnit.load = function() {
 575      runLoggingCallbacks( "begin", QUnit, {} );
 576  
 577      // Initialize the config, saving the execution queue
 578      var banner, filter, i, j, label, len, main, ol, toolbar, val, selection,
 579          urlConfigContainer, moduleFilter, userAgent,
 580          numModules = 0,
 581          moduleNames = [],
 582          moduleFilterHtml = "",
 583          urlConfigHtml = "",
 584          oldconfig = extend( {}, config );
 585  
 586      QUnit.init();
 587      extend(config, oldconfig);
 588  
 589      config.blocking = false;
 590  
 591      len = config.urlConfig.length;
 592  
 593      for ( i = 0; i < len; i++ ) {
 594          val = config.urlConfig[i];
 595          if ( typeof val === "string" ) {
 596              val = {
 597                  id: val,
 598                  label: val
 599              };
 600          }
 601          config[ val.id ] = QUnit.urlParams[ val.id ];
 602          if ( !val.value || typeof val.value === "string" ) {
 603              urlConfigHtml += "<input id='qunit-urlconfig-" + escapeText( val.id ) +
 604                  "' name='" + escapeText( val.id ) +
 605                  "' type='checkbox'" +
 606                  ( val.value ? " value='" + escapeText( val.value ) + "'" : "" ) +
 607                  ( config[ val.id ] ? " checked='checked'" : "" ) +
 608                  " title='" + escapeText( val.tooltip ) +
 609                  "'><label for='qunit-urlconfig-" + escapeText( val.id ) +
 610                  "' title='" + escapeText( val.tooltip ) + "'>" + val.label + "</label>";
 611          } else {
 612              urlConfigHtml += "<label for='qunit-urlconfig-" + escapeText( val.id ) +
 613                  "' title='" + escapeText( val.tooltip ) +
 614                  "'>" + val.label +
 615                  ": </label><select id='qunit-urlconfig-" + escapeText( val.id ) +
 616                  "' name='" + escapeText( val.id ) +
 617                  "' title='" + escapeText( val.tooltip ) +
 618                  "'><option></option>";
 619              selection = false;
 620              if ( QUnit.is( "array", val.value ) ) {
 621                  for ( j = 0; j < val.value.length; j++ ) {
 622                      urlConfigHtml += "<option value='" + escapeText( val.value[j] ) + "'" +
 623                          ( config[ val.id ] === val.value[j] ?
 624                              (selection = true) && " selected='selected'" :
 625                              "" ) +
 626                          ">" + escapeText( val.value[j] ) + "</option>";
 627                  }
 628              } else {
 629                  for ( j in val.value ) {
 630                      if ( hasOwn.call( val.value, j ) ) {
 631                          urlConfigHtml += "<option value='" + escapeText( j ) + "'" +
 632                              ( config[ val.id ] === j ?
 633                                  (selection = true) && " selected='selected'" :
 634                                  "" ) +
 635                              ">" + escapeText( val.value[j] ) + "</option>";
 636                      }
 637                  }
 638              }
 639              if ( config[ val.id ] && !selection ) {
 640                  urlConfigHtml += "<option value='" + escapeText( config[ val.id ] ) +
 641                      "' selected='selected' disabled='disabled'>" +
 642                      escapeText( config[ val.id ] ) +
 643                      "</option>";
 644              }
 645              urlConfigHtml += "</select>";
 646          }
 647      }
 648      for ( i in config.modules ) {
 649          if ( config.modules.hasOwnProperty( i ) ) {
 650              moduleNames.push(i);
 651          }
 652      }
 653      numModules = moduleNames.length;
 654      moduleNames.sort( function( a, b ) {
 655          return a.localeCompare( b );
 656      });
 657      moduleFilterHtml += "<label for='qunit-modulefilter'>Module: </label><select id='qunit-modulefilter' name='modulefilter'><option value='' " +
 658          ( config.module === undefined  ? "selected='selected'" : "" ) +
 659          ">< All Modules ></option>";
 660  
 661  
 662      for ( i = 0; i < numModules; i++) {
 663              moduleFilterHtml += "<option value='" + escapeText( encodeURIComponent(moduleNames[i]) ) + "' " +
 664                  ( config.module === moduleNames[i] ? "selected='selected'" : "" ) +
 665                  ">" + escapeText(moduleNames[i]) + "</option>";
 666      }
 667      moduleFilterHtml += "</select>";
 668  
 669      // `userAgent` initialized at top of scope
 670      userAgent = id( "qunit-userAgent" );
 671      if ( userAgent ) {
 672          userAgent.innerHTML = navigator.userAgent;
 673      }
 674  
 675      // `banner` initialized at top of scope
 676      banner = id( "qunit-header" );
 677      if ( banner ) {
 678          banner.innerHTML = "<a href='" + QUnit.url({ filter: undefined, module: undefined, testNumber: undefined }) + "'>" + banner.innerHTML + "</a> ";
 679      }
 680  
 681      // `toolbar` initialized at top of scope
 682      toolbar = id( "qunit-testrunner-toolbar" );
 683      if ( toolbar ) {
 684          // `filter` initialized at top of scope
 685          filter = document.createElement( "input" );
 686          filter.type = "checkbox";
 687          filter.id = "qunit-filter-pass";
 688  
 689          addEvent( filter, "click", function() {
 690              var tmp,
 691                  ol = id( "qunit-tests" );
 692  
 693              if ( filter.checked ) {
 694                  ol.className = ol.className + " hidepass";
 695              } else {
 696                  tmp = " " + ol.className.replace( /[\n\t\r]/g, " " ) + " ";
 697                  ol.className = tmp.replace( / hidepass /, " " );
 698              }
 699              if ( defined.sessionStorage ) {
 700                  if (filter.checked) {
 701                      sessionStorage.setItem( "qunit-filter-passed-tests", "true" );
 702                  } else {
 703                      sessionStorage.removeItem( "qunit-filter-passed-tests" );
 704                  }
 705              }
 706          });
 707  
 708          if ( config.hidepassed || defined.sessionStorage && sessionStorage.getItem( "qunit-filter-passed-tests" ) ) {
 709              filter.checked = true;
 710              // `ol` initialized at top of scope
 711              ol = id( "qunit-tests" );
 712              ol.className = ol.className + " hidepass";
 713          }
 714          toolbar.appendChild( filter );
 715  
 716          // `label` initialized at top of scope
 717          label = document.createElement( "label" );
 718          label.setAttribute( "for", "qunit-filter-pass" );
 719          label.setAttribute( "title", "Only show tests and assertions that fail. Stored in sessionStorage." );
 720          label.innerHTML = "Hide passed tests";
 721          toolbar.appendChild( label );
 722  
 723          urlConfigContainer = document.createElement("span");
 724          urlConfigContainer.innerHTML = urlConfigHtml;
 725          // For oldIE support:
 726          // * Add handlers to the individual elements instead of the container
 727          // * Use "click" instead of "change" for checkboxes
 728          // * Fallback from event.target to event.srcElement
 729          addEvents( urlConfigContainer.getElementsByTagName("input"), "click", function( event ) {
 730              var params = {},
 731                  target = event.target || event.srcElement;
 732              params[ target.name ] = target.checked ?
 733                  target.defaultValue || true :
 734                  undefined;
 735              window.location = QUnit.url( params );
 736          });
 737          addEvents( urlConfigContainer.getElementsByTagName("select"), "change", function( event ) {
 738              var params = {},
 739                  target = event.target || event.srcElement;
 740              params[ target.name ] = target.options[ target.selectedIndex ].value || undefined;
 741              window.location = QUnit.url( params );
 742          });
 743          toolbar.appendChild( urlConfigContainer );
 744  
 745          if (numModules > 1) {
 746              moduleFilter = document.createElement( "span" );
 747              moduleFilter.setAttribute( "id", "qunit-modulefilter-container" );
 748              moduleFilter.innerHTML = moduleFilterHtml;
 749              addEvent( moduleFilter.lastChild, "change", function() {
 750                  var selectBox = moduleFilter.getElementsByTagName("select")[0],
 751                      selectedModule = decodeURIComponent(selectBox.options[selectBox.selectedIndex].value);
 752  
 753                  window.location = QUnit.url({
 754                      module: ( selectedModule === "" ) ? undefined : selectedModule,
 755                      // Remove any existing filters
 756                      filter: undefined,
 757                      testNumber: undefined
 758                  });
 759              });
 760              toolbar.appendChild(moduleFilter);
 761          }
 762      }
 763  
 764      // `main` initialized at top of scope
 765      main = id( "qunit-fixture" );
 766      if ( main ) {
 767          config.fixture = main.innerHTML;
 768      }
 769  
 770      if ( config.autostart ) {
 771          QUnit.start();
 772      }
 773  };
 774  
 775  if ( defined.document ) {
 776      addEvent( window, "load", QUnit.load );
 777  }
 778  
 779  // `onErrorFnPrev` initialized at top of scope
 780  // Preserve other handlers
 781  onErrorFnPrev = window.onerror;
 782  
 783  // Cover uncaught exceptions
 784  // Returning true will suppress the default browser handler,
 785  // returning false will let it run.
 786  window.onerror = function ( error, filePath, linerNr ) {
 787      var ret = false;
 788      if ( onErrorFnPrev ) {
 789          ret = onErrorFnPrev( error, filePath, linerNr );
 790      }
 791  
 792      // Treat return value as window.onerror itself does,
 793      // Only do our handling if not suppressed.
 794      if ( ret !== true ) {
 795          if ( QUnit.config.current ) {
 796              if ( QUnit.config.current.ignoreGlobalErrors ) {
 797                  return true;
 798              }
 799              QUnit.pushFailure( error, filePath + ":" + linerNr );
 800          } else {
 801              QUnit.test( "global failure", extend( function() {
 802                  QUnit.pushFailure( error, filePath + ":" + linerNr );
 803              }, { validTest: validTest } ) );
 804          }
 805          return false;
 806      }
 807  
 808      return ret;
 809  };
 810  
 811  function done() {
 812      config.autorun = true;
 813  
 814      // Log the last module results
 815      if ( config.previousModule ) {
 816          runLoggingCallbacks( "moduleDone", QUnit, {
 817              name: config.previousModule,
 818              failed: config.moduleStats.bad,
 819              passed: config.moduleStats.all - config.moduleStats.bad,
 820              total: config.moduleStats.all
 821          });
 822      }
 823      delete config.previousModule;
 824  
 825      var i, key,
 826          banner = id( "qunit-banner" ),
 827          tests = id( "qunit-tests" ),
 828          runtime = +new Date() - config.started,
 829          passed = config.stats.all - config.stats.bad,
 830          html = [
 831              "Tests completed in ",
 832              runtime,
 833              " milliseconds.<br/>",
 834              "<span class='passed'>",
 835              passed,
 836              "</span> assertions of <span class='total'>",
 837              config.stats.all,
 838              "</span> passed, <span class='failed'>",
 839              config.stats.bad,
 840              "</span> failed."
 841          ].join( "" );
 842  
 843      if ( banner ) {
 844          banner.className = ( config.stats.bad ? "qunit-fail" : "qunit-pass" );
 845      }
 846  
 847      if ( tests ) {
 848          id( "qunit-testresult" ).innerHTML = html;
 849      }
 850  
 851      if ( config.altertitle && defined.document && document.title ) {
 852          // show ✖ for good, ✔ for bad suite result in title
 853          // use escape sequences in case file gets loaded with non-utf-8-charset
 854          document.title = [
 855              ( config.stats.bad ? "\u2716" : "\u2714" ),
 856              document.title.replace( /^[\u2714\u2716] /i, "" )
 857          ].join( " " );
 858      }
 859  
 860      // clear own sessionStorage items if all tests passed
 861      if ( config.reorder && defined.sessionStorage && config.stats.bad === 0 ) {
 862          // `key` & `i` initialized at top of scope
 863          for ( i = 0; i < sessionStorage.length; i++ ) {
 864              key = sessionStorage.key( i++ );
 865              if ( key.indexOf( "qunit-test-" ) === 0 ) {
 866                  sessionStorage.removeItem( key );
 867              }
 868          }
 869      }
 870  
 871      // scroll back to top to show results
 872      if ( config.scrolltop && window.scrollTo ) {
 873          window.scrollTo(0, 0);
 874      }
 875  
 876      runLoggingCallbacks( "done", QUnit, {
 877          failed: config.stats.bad,
 878          passed: passed,
 879          total: config.stats.all,
 880          runtime: runtime
 881      });
 882  }
 883  
 884  /** @return Boolean: true if this test should be ran */
 885  function validTest( test ) {
 886      var include,
 887          filter = config.filter && config.filter.toLowerCase(),
 888          module = config.module && config.module.toLowerCase(),
 889          fullName = ( test.module + ": " + test.testName ).toLowerCase();
 890  
 891      // Internally-generated tests are always valid
 892      if ( test.callback && test.callback.validTest === validTest ) {
 893          delete test.callback.validTest;
 894          return true;
 895      }
 896  
 897      if ( config.testNumber.length > 0 ) {
 898          if ( inArray( test.testNumber, config.testNumber ) < 0 ) {
 899              return false;
 900          }
 901      }
 902  
 903      if ( module && ( !test.module || test.module.toLowerCase() !== module ) ) {
 904          return false;
 905      }
 906  
 907      if ( !filter ) {
 908          return true;
 909      }
 910  
 911      include = filter.charAt( 0 ) !== "!";
 912      if ( !include ) {
 913          filter = filter.slice( 1 );
 914      }
 915  
 916      // If the filter matches, we need to honour include
 917      if ( fullName.indexOf( filter ) !== -1 ) {
 918          return include;
 919      }
 920  
 921      // Otherwise, do the opposite
 922      return !include;
 923  }
 924  
 925  // so far supports only Firefox, Chrome and Opera (buggy), Safari (for real exceptions)
 926  // Later Safari and IE10 are supposed to support error.stack as well
 927  // See also https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error/Stack
 928  function extractStacktrace( e, offset ) {
 929      offset = offset === undefined ? 3 : offset;
 930  
 931      var stack, include, i;
 932  
 933      if ( e.stacktrace ) {
 934          // Opera
 935          return e.stacktrace.split( "\n" )[ offset + 3 ];
 936      } else if ( e.stack ) {
 937          // Firefox, Chrome
 938          stack = e.stack.split( "\n" );
 939          if (/^error$/i.test( stack[0] ) ) {
 940              stack.shift();
 941          }
 942          if ( fileName ) {
 943              include = [];
 944              for ( i = offset; i < stack.length; i++ ) {
 945                  if ( stack[ i ].indexOf( fileName ) !== -1 ) {
 946                      break;
 947                  }
 948                  include.push( stack[ i ] );
 949              }
 950              if ( include.length ) {
 951                  return include.join( "\n" );
 952              }
 953          }
 954          return stack[ offset ];
 955      } else if ( e.sourceURL ) {
 956          // Safari, PhantomJS
 957          // hopefully one day Safari provides actual stacktraces
 958          // exclude useless self-reference for generated Error objects
 959          if ( /qunit.js$/.test( e.sourceURL ) ) {
 960              return;
 961          }
 962          // for actual exceptions, this is useful
 963          return e.sourceURL + ":" + e.line;
 964      }
 965  }
 966  function sourceFromStacktrace( offset ) {
 967      try {
 968          throw new Error();
 969      } catch ( e ) {
 970          return extractStacktrace( e, offset );
 971      }
 972  }
 973  
 974  /**
 975   * Escape text for attribute or text content.
 976   */
 977  function escapeText( s ) {
 978      if ( !s ) {
 979          return "";
 980      }
 981      s = s + "";
 982      // Both single quotes and double quotes (for attributes)
 983      return s.replace( /['"<>&]/g, function( s ) {
 984          switch( s ) {
 985              case "'":
 986                  return "&#039;";
 987              case "\"":
 988                  return "&quot;";
 989              case "<":
 990                  return "&lt;";
 991              case ">":
 992                  return "&gt;";
 993              case "&":
 994                  return "&amp;";
 995          }
 996      });
 997  }
 998  
 999  function synchronize( callback, last ) {
1000      config.queue.push( callback );
1001  
1002      if ( config.autorun && !config.blocking ) {
1003          process( last );
1004      }
1005  }
1006  
1007  function process( last ) {
1008  	function next() {
1009          process( last );
1010      }
1011      var start = new Date().getTime();
1012      config.depth = config.depth ? config.depth + 1 : 1;
1013  
1014      while ( config.queue.length && !config.blocking ) {
1015          if ( !defined.setTimeout || config.updateRate <= 0 || ( ( new Date().getTime() - start ) < config.updateRate ) ) {
1016              config.queue.shift()();
1017          } else {
1018              setTimeout( next, 13 );
1019              break;
1020          }
1021      }
1022      config.depth--;
1023      if ( last && !config.blocking && !config.queue.length && config.depth === 0 ) {
1024          done();
1025      }
1026  }
1027  
1028  function saveGlobal() {
1029      config.pollution = [];
1030  
1031      if ( config.noglobals ) {
1032          for ( var key in window ) {
1033              if ( hasOwn.call( window, key ) ) {
1034                  // in Opera sometimes DOM element ids show up here, ignore them
1035                  if ( /^qunit-test-output/.test( key ) ) {
1036                      continue;
1037                  }
1038                  config.pollution.push( key );
1039              }
1040          }
1041      }
1042  }
1043  
1044  function checkPollution() {
1045      var newGlobals,
1046          deletedGlobals,
1047          old = config.pollution;
1048  
1049      saveGlobal();
1050  
1051      newGlobals = diff( config.pollution, old );
1052      if ( newGlobals.length > 0 ) {
1053          QUnit.pushFailure( "Introduced global variable(s): " + newGlobals.join(", ") );
1054      }
1055  
1056      deletedGlobals = diff( old, config.pollution );
1057      if ( deletedGlobals.length > 0 ) {
1058          QUnit.pushFailure( "Deleted global variable(s): " + deletedGlobals.join(", ") );
1059      }
1060  }
1061  
1062  // returns a new Array with the elements that are in a but not in b
1063  function diff( a, b ) {
1064      var i, j,
1065          result = a.slice();
1066  
1067      for ( i = 0; i < result.length; i++ ) {
1068          for ( j = 0; j < b.length; j++ ) {
1069              if ( result[i] === b[j] ) {
1070                  result.splice( i, 1 );
1071                  i--;
1072                  break;
1073              }
1074          }
1075      }
1076      return result;
1077  }
1078  
1079  function extend( a, b ) {
1080      for ( var prop in b ) {
1081          if ( hasOwn.call( b, prop ) ) {
1082              // Avoid "Member not found" error in IE8 caused by messing with window.constructor
1083              if ( !( prop === "constructor" && a === window ) ) {
1084                  if ( b[ prop ] === undefined ) {
1085                      delete a[ prop ];
1086                  } else {
1087                      a[ prop ] = b[ prop ];
1088                  }
1089              }
1090          }
1091      }
1092  
1093      return a;
1094  }
1095  
1096  /**
1097   * @param {HTMLElement} elem
1098   * @param {string} type
1099   * @param {Function} fn
1100   */
1101  function addEvent( elem, type, fn ) {
1102      if ( elem.addEventListener ) {
1103  
1104          // Standards-based browsers
1105          elem.addEventListener( type, fn, false );
1106      } else if ( elem.attachEvent ) {
1107  
1108          // support: IE <9
1109          elem.attachEvent( "on" + type, fn );
1110      } else {
1111  
1112          // Caller must ensure support for event listeners is present
1113          throw new Error( "addEvent() was called in a context without event listener support" );
1114      }
1115  }
1116  
1117  /**
1118   * @param {Array|NodeList} elems
1119   * @param {string} type
1120   * @param {Function} fn
1121   */
1122  function addEvents( elems, type, fn ) {
1123      var i = elems.length;
1124      while ( i-- ) {
1125          addEvent( elems[i], type, fn );
1126      }
1127  }
1128  
1129  function hasClass( elem, name ) {
1130      return (" " + elem.className + " ").indexOf(" " + name + " ") > -1;
1131  }
1132  
1133  function addClass( elem, name ) {
1134      if ( !hasClass( elem, name ) ) {
1135          elem.className += (elem.className ? " " : "") + name;
1136      }
1137  }
1138  
1139  function removeClass( elem, name ) {
1140      var set = " " + elem.className + " ";
1141      // Class name may appear multiple times
1142      while ( set.indexOf(" " + name + " ") > -1 ) {
1143          set = set.replace(" " + name + " " , " ");
1144      }
1145      // If possible, trim it for prettiness, but not necessarily
1146      elem.className = typeof set.trim === "function" ? set.trim() : set.replace(/^\s+|\s+$/g, "");
1147  }
1148  
1149  function id( name ) {
1150      return defined.document && document.getElementById && document.getElementById( name );
1151  }
1152  
1153  function registerLoggingCallback( key ) {
1154      return function( callback ) {
1155          config[key].push( callback );
1156      };
1157  }
1158  
1159  // Supports deprecated method of completely overwriting logging callbacks
1160  function runLoggingCallbacks( key, scope, args ) {
1161      var i, callbacks;
1162      if ( QUnit.hasOwnProperty( key ) ) {
1163          QUnit[ key ].call(scope, args );
1164      } else {
1165          callbacks = config[ key ];
1166          for ( i = 0; i < callbacks.length; i++ ) {
1167              callbacks[ i ].call( scope, args );
1168          }
1169      }
1170  }
1171  
1172  // from jquery.js
1173  function inArray( elem, array ) {
1174      if ( array.indexOf ) {
1175          return array.indexOf( elem );
1176      }
1177  
1178      for ( var i = 0, length = array.length; i < length; i++ ) {
1179          if ( array[ i ] === elem ) {
1180              return i;
1181          }
1182      }
1183  
1184      return -1;
1185  }
1186  
1187  function Test( settings ) {
1188      extend( this, settings );
1189      this.assertions = [];
1190      this.testNumber = ++Test.count;
1191  }
1192  
1193  Test.count = 0;
1194  
1195  Test.prototype = {
1196      init: function() {
1197          var a, b, li,
1198              tests = id( "qunit-tests" );
1199  
1200          if ( tests ) {
1201              b = document.createElement( "strong" );
1202              b.innerHTML = this.nameHtml;
1203  
1204              // `a` initialized at top of scope
1205              a = document.createElement( "a" );
1206              a.innerHTML = "Rerun";
1207              a.href = QUnit.url({ testNumber: this.testNumber });
1208  
1209              li = document.createElement( "li" );
1210              li.appendChild( b );
1211              li.appendChild( a );
1212              li.className = "running";
1213              li.id = this.id = "qunit-test-output" + testId++;
1214  
1215              tests.appendChild( li );
1216          }
1217      },
1218      setup: function() {
1219          if (
1220              // Emit moduleStart when we're switching from one module to another
1221              this.module !== config.previousModule ||
1222                  // They could be equal (both undefined) but if the previousModule property doesn't
1223                  // yet exist it means this is the first test in a suite that isn't wrapped in a
1224                  // module, in which case we'll just emit a moduleStart event for 'undefined'.
1225                  // Without this, reporters can get testStart before moduleStart  which is a problem.
1226                  !hasOwn.call( config, "previousModule" )
1227          ) {
1228              if ( hasOwn.call( config, "previousModule" ) ) {
1229                  runLoggingCallbacks( "moduleDone", QUnit, {
1230                      name: config.previousModule,
1231                      failed: config.moduleStats.bad,
1232                      passed: config.moduleStats.all - config.moduleStats.bad,
1233                      total: config.moduleStats.all
1234                  });
1235              }
1236              config.previousModule = this.module;
1237              config.moduleStats = { all: 0, bad: 0 };
1238              runLoggingCallbacks( "moduleStart", QUnit, {
1239                  name: this.module
1240              });
1241          }
1242  
1243          config.current = this;
1244  
1245          this.testEnvironment = extend({
1246              setup: function() {},
1247              teardown: function() {}
1248          }, this.moduleTestEnvironment );
1249  
1250          this.started = +new Date();
1251          runLoggingCallbacks( "testStart", QUnit, {
1252              name: this.testName,
1253              module: this.module
1254          });
1255  
1256          /*jshint camelcase:false */
1257  
1258  
1259          /**
1260           * Expose the current test environment.
1261           *
1262           * @deprecated since 1.12.0: Use QUnit.config.current.testEnvironment instead.
1263           */
1264          QUnit.current_testEnvironment = this.testEnvironment;
1265  
1266          /*jshint camelcase:true */
1267  
1268          if ( !config.pollution ) {
1269              saveGlobal();
1270          }
1271          if ( config.notrycatch ) {
1272              this.testEnvironment.setup.call( this.testEnvironment, QUnit.assert );
1273              return;
1274          }
1275          try {
1276              this.testEnvironment.setup.call( this.testEnvironment, QUnit.assert );
1277          } catch( e ) {
1278              QUnit.pushFailure( "Setup failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) );
1279          }
1280      },
1281      run: function() {
1282          config.current = this;
1283  
1284          var running = id( "qunit-testresult" );
1285  
1286          if ( running ) {
1287              running.innerHTML = "Running: <br/>" + this.nameHtml;
1288          }
1289  
1290          if ( this.async ) {
1291              QUnit.stop();
1292          }
1293  
1294          this.callbackStarted = +new Date();
1295  
1296          if ( config.notrycatch ) {
1297              this.callback.call( this.testEnvironment, QUnit.assert );
1298              this.callbackRuntime = +new Date() - this.callbackStarted;
1299              return;
1300          }
1301  
1302          try {
1303              this.callback.call( this.testEnvironment, QUnit.assert );
1304              this.callbackRuntime = +new Date() - this.callbackStarted;
1305          } catch( e ) {
1306              this.callbackRuntime = +new Date() - this.callbackStarted;
1307  
1308              QUnit.pushFailure( "Died on test #" + (this.assertions.length + 1) + " " + this.stack + ": " + ( e.message || e ), extractStacktrace( e, 0 ) );
1309              // else next test will carry the responsibility
1310              saveGlobal();
1311  
1312              // Restart the tests if they're blocking
1313              if ( config.blocking ) {
1314                  QUnit.start();
1315              }
1316          }
1317      },
1318      teardown: function() {
1319          config.current = this;
1320          if ( config.notrycatch ) {
1321              if ( typeof this.callbackRuntime === "undefined" ) {
1322                  this.callbackRuntime = +new Date() - this.callbackStarted;
1323              }
1324              this.testEnvironment.teardown.call( this.testEnvironment, QUnit.assert );
1325              return;
1326          } else {
1327              try {
1328                  this.testEnvironment.teardown.call( this.testEnvironment, QUnit.assert );
1329              } catch( e ) {
1330                  QUnit.pushFailure( "Teardown failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) );
1331              }
1332          }
1333          checkPollution();
1334      },
1335      finish: function() {
1336          config.current = this;
1337          if ( config.requireExpects && this.expected === null ) {
1338              QUnit.pushFailure( "Expected number of assertions to be defined, but expect() was not called.", this.stack );
1339          } else if ( this.expected !== null && this.expected !== this.assertions.length ) {
1340              QUnit.pushFailure( "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run", this.stack );
1341          } else if ( this.expected === null && !this.assertions.length ) {
1342              QUnit.pushFailure( "Expected at least one assertion, but none were run - call expect(0) to accept zero assertions.", this.stack );
1343          }
1344  
1345          var i, assertion, a, b, time, li, ol,
1346              test = this,
1347              good = 0,
1348              bad = 0,
1349              tests = id( "qunit-tests" );
1350  
1351          this.runtime = +new Date() - this.started;
1352          config.stats.all += this.assertions.length;
1353          config.moduleStats.all += this.assertions.length;
1354  
1355          if ( tests ) {
1356              ol = document.createElement( "ol" );
1357              ol.className = "qunit-assert-list";
1358  
1359              for ( i = 0; i < this.assertions.length; i++ ) {
1360                  assertion = this.assertions[i];
1361  
1362                  li = document.createElement( "li" );
1363                  li.className = assertion.result ? "pass" : "fail";
1364                  li.innerHTML = assertion.message || ( assertion.result ? "okay" : "failed" );
1365                  ol.appendChild( li );
1366  
1367                  if ( assertion.result ) {
1368                      good++;
1369                  } else {
1370                      bad++;
1371                      config.stats.bad++;
1372                      config.moduleStats.bad++;
1373                  }
1374              }
1375  
1376              // store result when possible
1377              if ( QUnit.config.reorder && defined.sessionStorage ) {
1378                  if ( bad ) {
1379                      sessionStorage.setItem( "qunit-test-" + this.module + "-" + this.testName, bad );
1380                  } else {
1381                      sessionStorage.removeItem( "qunit-test-" + this.module + "-" + this.testName );
1382                  }
1383              }
1384  
1385              if ( bad === 0 ) {
1386                  addClass( ol, "qunit-collapsed" );
1387              }
1388  
1389              // `b` initialized at top of scope
1390              b = document.createElement( "strong" );
1391              b.innerHTML = this.nameHtml + " <b class='counts'>(<b class='failed'>" + bad + "</b>, <b class='passed'>" + good + "</b>, " + this.assertions.length + ")</b>";
1392  
1393              addEvent(b, "click", function() {
1394                  var next = b.parentNode.lastChild,
1395                      collapsed = hasClass( next, "qunit-collapsed" );
1396                  ( collapsed ? removeClass : addClass )( next, "qunit-collapsed" );
1397              });
1398  
1399              addEvent(b, "dblclick", function( e ) {
1400                  var target = e && e.target ? e.target : window.event.srcElement;
1401                  if ( target.nodeName.toLowerCase() === "span" || target.nodeName.toLowerCase() === "b" ) {
1402                      target = target.parentNode;
1403                  }
1404                  if ( window.location && target.nodeName.toLowerCase() === "strong" ) {
1405                      window.location = QUnit.url({ testNumber: test.testNumber });
1406                  }
1407              });
1408  
1409              // `time` initialized at top of scope
1410              time = document.createElement( "span" );
1411              time.className = "runtime";
1412              time.innerHTML = this.runtime + " ms";
1413  
1414              // `li` initialized at top of scope
1415              li = id( this.id );
1416              li.className = bad ? "fail" : "pass";
1417              li.removeChild( li.firstChild );
1418              a = li.firstChild;
1419              li.appendChild( b );
1420              li.appendChild( a );
1421              li.appendChild( time );
1422              li.appendChild( ol );
1423  
1424          } else {
1425              for ( i = 0; i < this.assertions.length; i++ ) {
1426                  if ( !this.assertions[i].result ) {
1427                      bad++;
1428                      config.stats.bad++;
1429                      config.moduleStats.bad++;
1430                  }
1431              }
1432          }
1433  
1434          runLoggingCallbacks( "testDone", QUnit, {
1435              name: this.testName,
1436              module: this.module,
1437              failed: bad,
1438              passed: this.assertions.length - bad,
1439              total: this.assertions.length,
1440              runtime: this.runtime,
1441              // DEPRECATED: this property will be removed in 2.0.0, use runtime instead
1442              duration: this.runtime
1443          });
1444  
1445          QUnit.reset();
1446  
1447          config.current = undefined;
1448      },
1449  
1450      queue: function() {
1451          var bad,
1452              test = this;
1453  
1454          synchronize(function() {
1455              test.init();
1456          });
1457  		function run() {
1458              // each of these can by async
1459              synchronize(function() {
1460                  test.setup();
1461              });
1462              synchronize(function() {
1463                  test.run();
1464              });
1465              synchronize(function() {
1466                  test.teardown();
1467              });
1468              synchronize(function() {
1469                  test.finish();
1470              });
1471          }
1472  
1473          // `bad` initialized at top of scope
1474          // defer when previous test run passed, if storage is available
1475          bad = QUnit.config.reorder && defined.sessionStorage &&
1476                          +sessionStorage.getItem( "qunit-test-" + this.module + "-" + this.testName );
1477  
1478          if ( bad ) {
1479              run();
1480          } else {
1481              synchronize( run, true );
1482          }
1483      }
1484  };
1485  
1486  // `assert` initialized at top of scope
1487  // Assert helpers
1488  // All of these must either call QUnit.push() or manually do:
1489  // - runLoggingCallbacks( "log", .. );
1490  // - config.current.assertions.push({ .. });
1491  assert = QUnit.assert = {
1492      /**
1493       * Asserts rough true-ish result.
1494       * @name ok
1495       * @function
1496       * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" );
1497       */
1498      ok: function( result, msg ) {
1499          if ( !config.current ) {
1500              throw new Error( "ok() assertion outside test context, was " + sourceFromStacktrace(2) );
1501          }
1502          result = !!result;
1503          msg = msg || ( result ? "okay" : "failed" );
1504  
1505          var source,
1506              details = {
1507                  module: config.current.module,
1508                  name: config.current.testName,
1509                  result: result,
1510                  message: msg
1511              };
1512  
1513          msg = "<span class='test-message'>" + escapeText( msg ) + "</span>";
1514  
1515          if ( !result ) {
1516              source = sourceFromStacktrace( 2 );
1517              if ( source ) {
1518                  details.source = source;
1519                  msg += "<table><tr class='test-source'><th>Source: </th><td><pre>" +
1520                      escapeText( source ) +
1521                      "</pre></td></tr></table>";
1522              }
1523          }
1524          runLoggingCallbacks( "log", QUnit, details );
1525          config.current.assertions.push({
1526              result: result,
1527              message: msg
1528          });
1529      },
1530  
1531      /**
1532       * Assert that the first two arguments are equal, with an optional message.
1533       * Prints out both actual and expected values.
1534       * @name equal
1535       * @function
1536       * @example equal( format( "Received {0} bytes.", 2), "Received 2 bytes.", "format() replaces {0} with next argument" );
1537       */
1538      equal: function( actual, expected, message ) {
1539          /*jshint eqeqeq:false */
1540          QUnit.push( expected == actual, actual, expected, message );
1541      },
1542  
1543      /**
1544       * @name notEqual
1545       * @function
1546       */
1547      notEqual: function( actual, expected, message ) {
1548          /*jshint eqeqeq:false */
1549          QUnit.push( expected != actual, actual, expected, message );
1550      },
1551  
1552      /**
1553       * @name propEqual
1554       * @function
1555       */
1556      propEqual: function( actual, expected, message ) {
1557          actual = objectValues(actual);
1558          expected = objectValues(expected);
1559          QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
1560      },
1561  
1562      /**
1563       * @name notPropEqual
1564       * @function
1565       */
1566      notPropEqual: function( actual, expected, message ) {
1567          actual = objectValues(actual);
1568          expected = objectValues(expected);
1569          QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
1570      },
1571  
1572      /**
1573       * @name deepEqual
1574       * @function
1575       */
1576      deepEqual: function( actual, expected, message ) {
1577          QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
1578      },
1579  
1580      /**
1581       * @name notDeepEqual
1582       * @function
1583       */
1584      notDeepEqual: function( actual, expected, message ) {
1585          QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
1586      },
1587  
1588      /**
1589       * @name strictEqual
1590       * @function
1591       */
1592      strictEqual: function( actual, expected, message ) {
1593          QUnit.push( expected === actual, actual, expected, message );
1594      },
1595  
1596      /**
1597       * @name notStrictEqual
1598       * @function
1599       */
1600      notStrictEqual: function( actual, expected, message ) {
1601          QUnit.push( expected !== actual, actual, expected, message );
1602      },
1603  
1604      "throws": function( block, expected, message ) {
1605          var actual,
1606              expectedOutput = expected,
1607              ok = false;
1608  
1609          // 'expected' is optional
1610          if ( !message && typeof expected === "string" ) {
1611              message = expected;
1612              expected = null;
1613          }
1614  
1615          config.current.ignoreGlobalErrors = true;
1616          try {
1617              block.call( config.current.testEnvironment );
1618          } catch (e) {
1619              actual = e;
1620          }
1621          config.current.ignoreGlobalErrors = false;
1622  
1623          if ( actual ) {
1624  
1625              // we don't want to validate thrown error
1626              if ( !expected ) {
1627                  ok = true;
1628                  expectedOutput = null;
1629  
1630              // expected is an Error object
1631              } else if ( expected instanceof Error ) {
1632                  ok = actual instanceof Error &&
1633                       actual.name === expected.name &&
1634                       actual.message === expected.message;
1635  
1636              // expected is a regexp
1637              } else if ( QUnit.objectType( expected ) === "regexp" ) {
1638                  ok = expected.test( errorString( actual ) );
1639  
1640              // expected is a string
1641              } else if ( QUnit.objectType( expected ) === "string" ) {
1642                  ok = expected === errorString( actual );
1643  
1644              // expected is a constructor
1645              } else if ( actual instanceof expected ) {
1646                  ok = true;
1647  
1648              // expected is a validation function which returns true is validation passed
1649              } else if ( expected.call( {}, actual ) === true ) {
1650                  expectedOutput = null;
1651                  ok = true;
1652              }
1653  
1654              QUnit.push( ok, actual, expectedOutput, message );
1655          } else {
1656              QUnit.pushFailure( message, null, "No exception was thrown." );
1657          }
1658      }
1659  };
1660  
1661  /**
1662   * @deprecated since 1.8.0
1663   * Kept assertion helpers in root for backwards compatibility.
1664   */
1665  extend( QUnit.constructor.prototype, assert );
1666  
1667  /**
1668   * @deprecated since 1.9.0
1669   * Kept to avoid TypeErrors for undefined methods.
1670   */
1671  QUnit.constructor.prototype.raises = function() {
1672      QUnit.push( false, false, false, "QUnit.raises has been deprecated since 2012 (fad3c1ea), use QUnit.throws instead" );
1673  };
1674  
1675  /**
1676   * @deprecated since 1.0.0, replaced with error pushes since 1.3.0
1677   * Kept to avoid TypeErrors for undefined methods.
1678   */
1679  QUnit.constructor.prototype.equals = function() {
1680      QUnit.push( false, false, false, "QUnit.equals has been deprecated since 2009 (e88049a0), use QUnit.equal instead" );
1681  };
1682  QUnit.constructor.prototype.same = function() {
1683      QUnit.push( false, false, false, "QUnit.same has been deprecated since 2009 (e88049a0), use QUnit.deepEqual instead" );
1684  };
1685  
1686  // Test for equality any JavaScript type.
1687  // Author: Philippe Rathé <[email protected]>
1688  QUnit.equiv = (function() {
1689  
1690      // Call the o related callback with the given arguments.
1691  	function bindCallbacks( o, callbacks, args ) {
1692          var prop = QUnit.objectType( o );
1693          if ( prop ) {
1694              if ( QUnit.objectType( callbacks[ prop ] ) === "function" ) {
1695                  return callbacks[ prop ].apply( callbacks, args );
1696              } else {
1697                  return callbacks[ prop ]; // or undefined
1698              }
1699          }
1700      }
1701  
1702      // the real equiv function
1703      var innerEquiv,
1704          // stack to decide between skip/abort functions
1705          callers = [],
1706          // stack to avoiding loops from circular referencing
1707          parents = [],
1708          parentsB = [],
1709  
1710          getProto = Object.getPrototypeOf || function ( obj ) {
1711              /*jshint camelcase:false */
1712              return obj.__proto__;
1713          },
1714          callbacks = (function () {
1715  
1716              // for string, boolean, number and null
1717  			function useStrictEquality( b, a ) {
1718                  /*jshint eqeqeq:false */
1719                  if ( b instanceof a.constructor || a instanceof b.constructor ) {
1720                      // to catch short annotation VS 'new' annotation of a
1721                      // declaration
1722                      // e.g. var i = 1;
1723                      // var j = new Number(1);
1724                      return a == b;
1725                  } else {
1726                      return a === b;
1727                  }
1728              }
1729  
1730              return {
1731                  "string": useStrictEquality,
1732                  "boolean": useStrictEquality,
1733                  "number": useStrictEquality,
1734                  "null": useStrictEquality,
1735                  "undefined": useStrictEquality,
1736  
1737                  "nan": function( b ) {
1738                      return isNaN( b );
1739                  },
1740  
1741                  "date": function( b, a ) {
1742                      return QUnit.objectType( b ) === "date" && a.valueOf() === b.valueOf();
1743                  },
1744  
1745                  "regexp": function( b, a ) {
1746                      return QUnit.objectType( b ) === "regexp" &&
1747                          // the regex itself
1748                          a.source === b.source &&
1749                          // and its modifiers
1750                          a.global === b.global &&
1751                          // (gmi) ...
1752                          a.ignoreCase === b.ignoreCase &&
1753                          a.multiline === b.multiline &&
1754                          a.sticky === b.sticky;
1755                  },
1756  
1757                  // - skip when the property is a method of an instance (OOP)
1758                  // - abort otherwise,
1759                  // initial === would have catch identical references anyway
1760                  "function": function() {
1761                      var caller = callers[callers.length - 1];
1762                      return caller !== Object && typeof caller !== "undefined";
1763                  },
1764  
1765                  "array": function( b, a ) {
1766                      var i, j, len, loop, aCircular, bCircular;
1767  
1768                      // b could be an object literal here
1769                      if ( QUnit.objectType( b ) !== "array" ) {
1770                          return false;
1771                      }
1772  
1773                      len = a.length;
1774                      if ( len !== b.length ) {
1775                          // safe and faster
1776                          return false;
1777                      }
1778  
1779                      // track reference to avoid circular references
1780                      parents.push( a );
1781                      parentsB.push( b );
1782                      for ( i = 0; i < len; i++ ) {
1783                          loop = false;
1784                          for ( j = 0; j < parents.length; j++ ) {
1785                              aCircular = parents[j] === a[i];
1786                              bCircular = parentsB[j] === b[i];
1787                              if ( aCircular || bCircular ) {
1788                                  if ( a[i] === b[i] || aCircular && bCircular ) {
1789                                      loop = true;
1790                                  } else {
1791                                      parents.pop();
1792                                      parentsB.pop();
1793                                      return false;
1794                                  }
1795                              }
1796                          }
1797                          if ( !loop && !innerEquiv(a[i], b[i]) ) {
1798                              parents.pop();
1799                              parentsB.pop();
1800                              return false;
1801                          }
1802                      }
1803                      parents.pop();
1804                      parentsB.pop();
1805                      return true;
1806                  },
1807  
1808                  "object": function( b, a ) {
1809                      /*jshint forin:false */
1810                      var i, j, loop, aCircular, bCircular,
1811                          // Default to true
1812                          eq = true,
1813                          aProperties = [],
1814                          bProperties = [];
1815  
1816                      // comparing constructors is more strict than using
1817                      // instanceof
1818                      if ( a.constructor !== b.constructor ) {
1819                          // Allow objects with no prototype to be equivalent to
1820                          // objects with Object as their constructor.
1821                          if ( !(( getProto(a) === null && getProto(b) === Object.prototype ) ||
1822                              ( getProto(b) === null && getProto(a) === Object.prototype ) ) ) {
1823                                  return false;
1824                          }
1825                      }
1826  
1827                      // stack constructor before traversing properties
1828                      callers.push( a.constructor );
1829  
1830                      // track reference to avoid circular references
1831                      parents.push( a );
1832                      parentsB.push( b );
1833  
1834                      // be strict: don't ensure hasOwnProperty and go deep
1835                      for ( i in a ) {
1836                          loop = false;
1837                          for ( j = 0; j < parents.length; j++ ) {
1838                              aCircular = parents[j] === a[i];
1839                              bCircular = parentsB[j] === b[i];
1840                              if ( aCircular || bCircular ) {
1841                                  if ( a[i] === b[i] || aCircular && bCircular ) {
1842                                      loop = true;
1843                                  } else {
1844                                      eq = false;
1845                                      break;
1846                                  }
1847                              }
1848                          }
1849                          aProperties.push(i);
1850                          if ( !loop && !innerEquiv(a[i], b[i]) ) {
1851                              eq = false;
1852                              break;
1853                          }
1854                      }
1855  
1856                      parents.pop();
1857                      parentsB.pop();
1858                      callers.pop(); // unstack, we are done
1859  
1860                      for ( i in b ) {
1861                          bProperties.push( i ); // collect b's properties
1862                      }
1863  
1864                      // Ensures identical properties name
1865                      return eq && innerEquiv( aProperties.sort(), bProperties.sort() );
1866                  }
1867              };
1868          }());
1869  
1870      innerEquiv = function() { // can take multiple arguments
1871          var args = [].slice.apply( arguments );
1872          if ( args.length < 2 ) {
1873              return true; // end transition
1874          }
1875  
1876          return (function( a, b ) {
1877              if ( a === b ) {
1878                  return true; // catch the most you can
1879              } else if ( a === null || b === null || typeof a === "undefined" ||
1880                      typeof b === "undefined" ||
1881                      QUnit.objectType(a) !== QUnit.objectType(b) ) {
1882                  return false; // don't lose time with error prone cases
1883              } else {
1884                  return bindCallbacks(a, callbacks, [ b, a ]);
1885              }
1886  
1887              // apply transition with (1..n) arguments
1888          }( args[0], args[1] ) && innerEquiv.apply( this, args.splice(1, args.length - 1 )) );
1889      };
1890  
1891      return innerEquiv;
1892  }());
1893  
1894  /**
1895   * jsDump Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com |
1896   * http://flesler.blogspot.com Licensed under BSD
1897   * (http://www.opensource.org/licenses/bsd-license.php) Date: 5/15/2008
1898   *
1899   * @projectDescription Advanced and extensible data dumping for Javascript.
1900   * @version 1.0.0
1901   * @author Ariel Flesler
1902   * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html}
1903   */
1904  QUnit.jsDump = (function() {
1905  	function quote( str ) {
1906          return "\"" + str.toString().replace( /"/g, "\\\"" ) + "\"";
1907      }
1908  	function literal( o ) {
1909          return o + "";
1910      }
1911  	function join( pre, arr, post ) {
1912          var s = jsDump.separator(),
1913              base = jsDump.indent(),
1914              inner = jsDump.indent(1);
1915          if ( arr.join ) {
1916              arr = arr.join( "," + s + inner );
1917          }
1918          if ( !arr ) {
1919              return pre + post;
1920          }
1921          return [ pre, inner + arr, base + post ].join(s);
1922      }
1923  	function array( arr, stack ) {
1924          var i = arr.length, ret = new Array(i);
1925          this.up();
1926          while ( i-- ) {
1927              ret[i] = this.parse( arr[i] , undefined , stack);
1928          }
1929          this.down();
1930          return join( "[", ret, "]" );
1931      }
1932  
1933      var reName = /^function (\w+)/,
1934          jsDump = {
1935              // type is used mostly internally, you can fix a (custom)type in advance
1936              parse: function( obj, type, stack ) {
1937                  stack = stack || [ ];
1938                  var inStack, res,
1939                      parser = this.parsers[ type || this.typeOf(obj) ];
1940  
1941                  type = typeof parser;
1942                  inStack = inArray( obj, stack );
1943  
1944                  if ( inStack !== -1 ) {
1945                      return "recursion(" + (inStack - stack.length) + ")";
1946                  }
1947                  if ( type === "function" )  {
1948                      stack.push( obj );
1949                      res = parser.call( this, obj, stack );
1950                      stack.pop();
1951                      return res;
1952                  }
1953                  return ( type === "string" ) ? parser : this.parsers.error;
1954              },
1955              typeOf: function( obj ) {
1956                  var type;
1957                  if ( obj === null ) {
1958                      type = "null";
1959                  } else if ( typeof obj === "undefined" ) {
1960                      type = "undefined";
1961                  } else if ( QUnit.is( "regexp", obj) ) {
1962                      type = "regexp";
1963                  } else if ( QUnit.is( "date", obj) ) {
1964                      type = "date";
1965                  } else if ( QUnit.is( "function", obj) ) {
1966                      type = "function";
1967                  } else if ( typeof obj.setInterval !== undefined && typeof obj.document !== "undefined" && typeof obj.nodeType === "undefined" ) {
1968                      type = "window";
1969                  } else if ( obj.nodeType === 9 ) {
1970                      type = "document";
1971                  } else if ( obj.nodeType ) {
1972                      type = "node";
1973                  } else if (
1974                      // native arrays
1975                      toString.call( obj ) === "[object Array]" ||
1976                      // NodeList objects
1977                      ( typeof obj.length === "number" && typeof obj.item !== "undefined" && ( obj.length ? obj.item(0) === obj[0] : ( obj.item( 0 ) === null && typeof obj[0] === "undefined" ) ) )
1978                  ) {
1979                      type = "array";
1980                  } else if ( obj.constructor === Error.prototype.constructor ) {
1981                      type = "error";
1982                  } else {
1983                      type = typeof obj;
1984                  }
1985                  return type;
1986              },
1987              separator: function() {
1988                  return this.multiline ?    this.HTML ? "<br />" : "\n" : this.HTML ? "&nbsp;" : " ";
1989              },
1990              // extra can be a number, shortcut for increasing-calling-decreasing
1991              indent: function( extra ) {
1992                  if ( !this.multiline ) {
1993                      return "";
1994                  }
1995                  var chr = this.indentChar;
1996                  if ( this.HTML ) {
1997                      chr = chr.replace( /\t/g, "   " ).replace( / /g, "&nbsp;" );
1998                  }
1999                  return new Array( this.depth + ( extra || 0 ) ).join(chr);
2000              },
2001              up: function( a ) {
2002                  this.depth += a || 1;
2003              },
2004              down: function( a ) {
2005                  this.depth -= a || 1;
2006              },
2007              setParser: function( name, parser ) {
2008                  this.parsers[name] = parser;
2009              },
2010              // The next 3 are exposed so you can use them
2011              quote: quote,
2012              literal: literal,
2013              join: join,
2014              //
2015              depth: 1,
2016              // This is the list of parsers, to modify them, use jsDump.setParser
2017              parsers: {
2018                  window: "[Window]",
2019                  document: "[Document]",
2020                  error: function(error) {
2021                      return "Error(\"" + error.message + "\")";
2022                  },
2023                  unknown: "[Unknown]",
2024                  "null": "null",
2025                  "undefined": "undefined",
2026                  "function": function( fn ) {
2027                      var ret = "function",
2028                          // functions never have name in IE
2029                          name = "name" in fn ? fn.name : (reName.exec(fn) || [])[1];
2030  
2031                      if ( name ) {
2032                          ret += " " + name;
2033                      }
2034                      ret += "( ";
2035  
2036                      ret = [ ret, QUnit.jsDump.parse( fn, "functionArgs" ), "){" ].join( "" );
2037                      return join( ret, QUnit.jsDump.parse(fn,"functionCode" ), "}" );
2038                  },
2039                  array: array,
2040                  nodelist: array,
2041                  "arguments": array,
2042                  object: function( map, stack ) {
2043                      /*jshint forin:false */
2044                      var ret = [ ], keys, key, val, i;
2045                      QUnit.jsDump.up();
2046                      keys = [];
2047                      for ( key in map ) {
2048                          keys.push( key );
2049                      }
2050                      keys.sort();
2051                      for ( i = 0; i < keys.length; i++ ) {
2052                          key = keys[ i ];
2053                          val = map[ key ];
2054                          ret.push( QUnit.jsDump.parse( key, "key" ) + ": " + QUnit.jsDump.parse( val, undefined, stack ) );
2055                      }
2056                      QUnit.jsDump.down();
2057                      return join( "{", ret, "}" );
2058                  },
2059                  node: function( node ) {
2060                      var len, i, val,
2061                          open = QUnit.jsDump.HTML ? "&lt;" : "<",
2062                          close = QUnit.jsDump.HTML ? "&gt;" : ">",
2063                          tag = node.nodeName.toLowerCase(),
2064                          ret = open + tag,
2065                          attrs = node.attributes;
2066  
2067                      if ( attrs ) {
2068                          for ( i = 0, len = attrs.length; i < len; i++ ) {
2069                              val = attrs[i].nodeValue;
2070                              // IE6 includes all attributes in .attributes, even ones not explicitly set.
2071                              // Those have values like undefined, null, 0, false, "" or "inherit".
2072                              if ( val && val !== "inherit" ) {
2073                                  ret += " " + attrs[i].nodeName + "=" + QUnit.jsDump.parse( val, "attribute" );
2074                              }
2075                          }
2076                      }
2077                      ret += close;
2078  
2079                      // Show content of TextNode or CDATASection
2080                      if ( node.nodeType === 3 || node.nodeType === 4 ) {
2081                          ret += node.nodeValue;
2082                      }
2083  
2084                      return ret + open + "/" + tag + close;
2085                  },
2086                  // function calls it internally, it's the arguments part of the function
2087                  functionArgs: function( fn ) {
2088                      var args,
2089                          l = fn.length;
2090  
2091                      if ( !l ) {
2092                          return "";
2093                      }
2094  
2095                      args = new Array(l);
2096                      while ( l-- ) {
2097                          // 97 is 'a'
2098                          args[l] = String.fromCharCode(97+l);
2099                      }
2100                      return " " + args.join( ", " ) + " ";
2101                  },
2102                  // object calls it internally, the key part of an item in a map
2103                  key: quote,
2104                  // function calls it internally, it's the content of the function
2105                  functionCode: "[code]",
2106                  // node calls it internally, it's an html attribute value
2107                  attribute: quote,
2108                  string: quote,
2109                  date: quote,
2110                  regexp: literal,
2111                  number: literal,
2112                  "boolean": literal
2113              },
2114              // if true, entities are escaped ( <, >, \t, space and \n )
2115              HTML: false,
2116              // indentation unit
2117              indentChar: "  ",
2118              // if true, items in a collection, are separated by a \n, else just a space.
2119              multiline: true
2120          };
2121  
2122      return jsDump;
2123  }());
2124  
2125  /*
2126   * Javascript Diff Algorithm
2127   *  By John Resig (http://ejohn.org/)
2128   *  Modified by Chu Alan "sprite"
2129   *
2130   * Released under the MIT license.
2131   *
2132   * More Info:
2133   *  http://ejohn.org/projects/javascript-diff-algorithm/
2134   *
2135   * Usage: QUnit.diff(expected, actual)
2136   *
2137   * QUnit.diff( "the quick brown fox jumped over", "the quick fox jumps over" ) == "the  quick <del>brown </del> fox <del>jumped </del><ins>jumps </ins> over"
2138   */
2139  QUnit.diff = (function() {
2140      /*jshint eqeqeq:false, eqnull:true */
2141  	function diff( o, n ) {
2142          var i,
2143              ns = {},
2144              os = {};
2145  
2146          for ( i = 0; i < n.length; i++ ) {
2147              if ( !hasOwn.call( ns, n[i] ) ) {
2148                  ns[ n[i] ] = {
2149                      rows: [],
2150                      o: null
2151                  };
2152              }
2153              ns[ n[i] ].rows.push( i );
2154          }
2155  
2156          for ( i = 0; i < o.length; i++ ) {
2157              if ( !hasOwn.call( os, o[i] ) ) {
2158                  os[ o[i] ] = {
2159                      rows: [],
2160                      n: null
2161                  };
2162              }
2163              os[ o[i] ].rows.push( i );
2164          }
2165  
2166          for ( i in ns ) {
2167              if ( hasOwn.call( ns, i ) ) {
2168                  if ( ns[i].rows.length === 1 && hasOwn.call( os, i ) && os[i].rows.length === 1 ) {
2169                      n[ ns[i].rows[0] ] = {
2170                          text: n[ ns[i].rows[0] ],
2171                          row: os[i].rows[0]
2172                      };
2173                      o[ os[i].rows[0] ] = {
2174                          text: o[ os[i].rows[0] ],
2175                          row: ns[i].rows[0]
2176                      };
2177                  }
2178              }
2179          }
2180  
2181          for ( i = 0; i < n.length - 1; i++ ) {
2182              if ( n[i].text != null && n[ i + 1 ].text == null && n[i].row + 1 < o.length && o[ n[i].row + 1 ].text == null &&
2183                          n[ i + 1 ] == o[ n[i].row + 1 ] ) {
2184  
2185                  n[ i + 1 ] = {
2186                      text: n[ i + 1 ],
2187                      row: n[i].row + 1
2188                  };
2189                  o[ n[i].row + 1 ] = {
2190                      text: o[ n[i].row + 1 ],
2191                      row: i + 1
2192                  };
2193              }
2194          }
2195  
2196          for ( i = n.length - 1; i > 0; i-- ) {
2197              if ( n[i].text != null && n[ i - 1 ].text == null && n[i].row > 0 && o[ n[i].row - 1 ].text == null &&
2198                          n[ i - 1 ] == o[ n[i].row - 1 ]) {
2199  
2200                  n[ i - 1 ] = {
2201                      text: n[ i - 1 ],
2202                      row: n[i].row - 1
2203                  };
2204                  o[ n[i].row - 1 ] = {
2205                      text: o[ n[i].row - 1 ],
2206                      row: i - 1
2207                  };
2208              }
2209          }
2210  
2211          return {
2212              o: o,
2213              n: n
2214          };
2215      }
2216  
2217      return function( o, n ) {
2218          o = o.replace( /\s+$/, "" );
2219          n = n.replace( /\s+$/, "" );
2220  
2221          var i, pre,
2222              str = "",
2223              out = diff( o === "" ? [] : o.split(/\s+/), n === "" ? [] : n.split(/\s+/) ),
2224              oSpace = o.match(/\s+/g),
2225              nSpace = n.match(/\s+/g);
2226  
2227          if ( oSpace == null ) {
2228              oSpace = [ " " ];
2229          }
2230          else {
2231              oSpace.push( " " );
2232          }
2233  
2234          if ( nSpace == null ) {
2235              nSpace = [ " " ];
2236          }
2237          else {
2238              nSpace.push( " " );
2239          }
2240  
2241          if ( out.n.length === 0 ) {
2242              for ( i = 0; i < out.o.length; i++ ) {
2243                  str += "<del>" + out.o[i] + oSpace[i] + "</del>";
2244              }
2245          }
2246          else {
2247              if ( out.n[0].text == null ) {
2248                  for ( n = 0; n < out.o.length && out.o[n].text == null; n++ ) {
2249                      str += "<del>" + out.o[n] + oSpace[n] + "</del>";
2250                  }
2251              }
2252  
2253              for ( i = 0; i < out.n.length; i++ ) {
2254                  if (out.n[i].text == null) {
2255                      str += "<ins>" + out.n[i] + nSpace[i] + "</ins>";
2256                  }
2257                  else {
2258                      // `pre` initialized at top of scope
2259                      pre = "";
2260  
2261                      for ( n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++ ) {
2262                          pre += "<del>" + out.o[n] + oSpace[n] + "</del>";
2263                      }
2264                      str += " " + out.n[i].text + nSpace[i] + pre;
2265                  }
2266              }
2267          }
2268  
2269          return str;
2270      };
2271  }());
2272  
2273  // For browser, export only select globals
2274  if ( typeof window !== "undefined" ) {
2275      extend( window, QUnit.constructor.prototype );
2276      window.QUnit = QUnit;
2277  }
2278  
2279  // For CommonJS environments, export everything
2280  if ( typeof module !== "undefined" && module.exports ) {
2281      module.exports = QUnit;
2282  }
2283  
2284  
2285  // Get a reference to the global object, like window in browsers
2286  }( (function() {
2287      return this;
2288  })() ));