1 /*!

     2  * QUnit 1.18.0

     3  * http://qunitjs.com/

     4  *

     5  * Copyright jQuery Foundation and other contributors

     6  * Released under the MIT license

     7  * http://jquery.org/license

     8  *

     9  * Date: 2015-04-03T10:23Z

    10  */

    11 

    12 (function( window ) {

    13 

    14 var QUnit,

    15 	config,

    16 	onErrorFnPrev,

    17 	loggingCallbacks = {},

    18 	fileName = ( sourceFromStacktrace( 0 ) || "" ).replace( /(:\d+)+\)?/, "" ).replace( /.+\//, "" ),

    19 	toString = Object.prototype.toString,

    20 	hasOwn = Object.prototype.hasOwnProperty,

    21 	// Keep a local reference to Date (GH-283)

    22 	Date = window.Date,

    23 	now = Date.now || function() {

    24 		return new Date().getTime();

    25 	},

    26 	globalStartCalled = false,

    27 	runStarted = false,

    28 	setTimeout = window.setTimeout,

    29 	clearTimeout = window.clearTimeout,

    30 	defined = {

    31 		document: window.document !== undefined,

    32 		setTimeout: window.setTimeout !== undefined,

    33 		sessionStorage: (function() {

    34 			var x = "qunit-test-string";

    35 			try {

    36 				sessionStorage.setItem( x, x );

    37 				sessionStorage.removeItem( x );

    38 				return true;

    39 			} catch ( e ) {

    40 				return false;

    41 			}

    42 		}())

    43 	},

    44 	/**

    45 	 * Provides a normalized error string, correcting an issue

    46 	 * with IE 7 (and prior) where Error.prototype.toString is

    47 	 * not properly implemented

    48 	 *

    49 	 * Based on http://es5.github.com/#x15.11.4.4

    50 	 *

    51 	 * @param {String|Error} error

    52 	 * @return {String} error message

    53 	 */

    54 	errorString = function( error ) {

    55 		var name, message,

    56 			errorString = error.toString();

    57 		if ( errorString.substring( 0, 7 ) === "[object" ) {

    58 			name = error.name ? error.name.toString() : "Error";

    59 			message = error.message ? error.message.toString() : "";

    60 			if ( name && message ) {

    61 				return name + ": " + message;

    62 			} else if ( name ) {

    63 				return name;

    64 			} else if ( message ) {

    65 				return message;

    66 			} else {

    67 				return "Error";

    68 			}

    69 		} else {

    70 			return errorString;

    71 		}

    72 	},

    73 	/**

    74 	 * Makes a clone of an object using only Array or Object as base,

    75 	 * and copies over the own enumerable properties.

    76 	 *

    77 	 * @param {Object} obj

    78 	 * @return {Object} New object with only the own properties (recursively).

    79 	 */

    80 	objectValues = function( obj ) {

    81 		var key, val,

    82 			vals = QUnit.is( "array", obj ) ? [] : {};

    83 		for ( key in obj ) {

    84 			if ( hasOwn.call( obj, key ) ) {

    85 				val = obj[ key ];

    86 				vals[ key ] = val === Object( val ) ? objectValues( val ) : val;

    87 			}

    88 		}

    89 		return vals;

    90 	};

    91 

    92 QUnit = {};

    93 

    94 /**

    95  * Config object: Maintain internal state

    96  * Later exposed as QUnit.config

    97  * `config` initialized at top of scope

    98  */

    99 config = {

   100 	// The queue of tests to run

   101 	queue: [],

   102 

   103 	// block until document ready

   104 	blocking: true,

   105 

   106 	// by default, run previously failed tests first

   107 	// very useful in combination with "Hide passed tests" checked

   108 	reorder: true,

   109 

   110 	// by default, modify document.title when suite is done

   111 	altertitle: true,

   112 

   113 	// by default, scroll to top of the page when suite is done

   114 	scrolltop: true,

   115 

   116 	// when enabled, all tests must call expect()

   117 	requireExpects: false,

   118 

   119 	// depth up-to which object will be dumped

   120 	maxDepth: 5,

   121 

   122 	// add checkboxes that are persisted in the query-string

   123 	// when enabled, the id is set to `true` as a `QUnit.config` property

   124 	urlConfig: [

   125 		{

   126 			id: "hidepassed",

   127 			label: "Hide passed tests",

   128 			tooltip: "Only show tests and assertions that fail. Stored as query-strings."

   129 		},

   130 		{

   131 			id: "noglobals",

   132 			label: "Check for Globals",

   133 			tooltip: "Enabling this will test if any test introduces new properties on the " +

   134 				"`window` object. Stored as query-strings."

   135 		},

   136 		{

   137 			id: "notrycatch",

   138 			label: "No try-catch",

   139 			tooltip: "Enabling this will run tests outside of a try-catch block. Makes debugging " +

   140 				"exceptions in IE reasonable. Stored as query-strings."

   141 		}

   142 	],

   143 

   144 	// Set of all modules.

   145 	modules: [],

   146 

   147 	// The first unnamed module

   148 	currentModule: {

   149 		name: "",

   150 		tests: []

   151 	},

   152 

   153 	callbacks: {}

   154 };

   155 

   156 // Push a loose unnamed module to the modules collection

   157 config.modules.push( config.currentModule );

   158 

   159 // Initialize more QUnit.config and QUnit.urlParams

   160 (function() {

   161 	var i, current,

   162 		location = window.location || { search: "", protocol: "file:" },

   163 		params = location.search.slice( 1 ).split( "&" ),

   164 		length = params.length,

   165 		urlParams = {};

   166 

   167 	if ( params[ 0 ] ) {

   168 		for ( i = 0; i < length; i++ ) {

   169 			current = params[ i ].split( "=" );

   170 			current[ 0 ] = decodeURIComponent( current[ 0 ] );

   171 

   172 			// allow just a key to turn on a flag, e.g., test.html?noglobals

   173 			current[ 1 ] = current[ 1 ] ? decodeURIComponent( current[ 1 ] ) : true;

   174 			if ( urlParams[ current[ 0 ] ] ) {

   175 				urlParams[ current[ 0 ] ] = [].concat( urlParams[ current[ 0 ] ], current[ 1 ] );

   176 			} else {

   177 				urlParams[ current[ 0 ] ] = current[ 1 ];

   178 			}

   179 		}

   180 	}

   181 

   182 	if ( urlParams.filter === true ) {

   183 		delete urlParams.filter;

   184 	}

   185 

   186 	QUnit.urlParams = urlParams;

   187 

   188 	// String search anywhere in moduleName+testName

   189 	config.filter = urlParams.filter;

   190 

   191 	if ( urlParams.maxDepth ) {

   192 		config.maxDepth = parseInt( urlParams.maxDepth, 10 ) === -1 ?

   193 			Number.POSITIVE_INFINITY :

   194 			urlParams.maxDepth;

   195 	}

   196 

   197 	config.testId = [];

   198 	if ( urlParams.testId ) {

   199 

   200 		// Ensure that urlParams.testId is an array

   201 		urlParams.testId = decodeURIComponent( urlParams.testId ).split( "," );

   202 		for ( i = 0; i < urlParams.testId.length; i++ ) {

   203 			config.testId.push( urlParams.testId[ i ] );

   204 		}

   205 	}

   206 

   207 	// Figure out if we're running the tests from a server or not

   208 	QUnit.isLocal = location.protocol === "file:";

   209 

   210 	// Expose the current QUnit version

   211 	QUnit.version = "1.18.0";

   212 }());

   213 

   214 // Root QUnit object.

   215 // `QUnit` initialized at top of scope

   216 extend( QUnit, {

   217 

   218 	// call on start of module test to prepend name to all tests

   219 	module: function( name, testEnvironment ) {

   220 		var currentModule = {

   221 			name: name,

   222 			testEnvironment: testEnvironment,

   223 			tests: []

   224 		};

   225 

   226 		// DEPRECATED: handles setup/teardown functions,

   227 		// beforeEach and afterEach should be used instead

   228 		if ( testEnvironment && testEnvironment.setup ) {

   229 			testEnvironment.beforeEach = testEnvironment.setup;

   230 			delete testEnvironment.setup;

   231 		}

   232 		if ( testEnvironment && testEnvironment.teardown ) {

   233 			testEnvironment.afterEach = testEnvironment.teardown;

   234 			delete testEnvironment.teardown;

   235 		}

   236 

   237 		config.modules.push( currentModule );

   238 		config.currentModule = currentModule;

   239 	},

   240 

   241 	// DEPRECATED: QUnit.asyncTest() will be removed in QUnit 2.0.

   242 	asyncTest: function( testName, expected, callback ) {

   243 		if ( arguments.length === 2 ) {

   244 			callback = expected;

   245 			expected = null;

   246 		}

   247 

   248 		QUnit.test( testName, expected, callback, true );

   249 	},

   250 

   251 	test: function( testName, expected, callback, async ) {

   252 		var test;

   253 

   254 		if ( arguments.length === 2 ) {

   255 			callback = expected;

   256 			expected = null;

   257 		}

   258 

   259 		test = new Test({

   260 			testName: testName,

   261 			expected: expected,

   262 			async: async,

   263 			callback: callback

   264 		});

   265 

   266 		test.queue();

   267 	},

   268 

   269 	skip: function( testName ) {

   270 		var test = new Test({

   271 			testName: testName,

   272 			skip: true

   273 		});

   274 

   275 		test.queue();

   276 	},

   277 

   278 	// DEPRECATED: The functionality of QUnit.start() will be altered in QUnit 2.0.

   279 	// In QUnit 2.0, invoking it will ONLY affect the `QUnit.config.autostart` blocking behavior.

   280 	start: function( count ) {

   281 		var globalStartAlreadyCalled = globalStartCalled;

   282 

   283 		if ( !config.current ) {

   284 			globalStartCalled = true;

   285 

   286 			if ( runStarted ) {

   287 				throw new Error( "Called start() outside of a test context while already started" );

   288 			} else if ( globalStartAlreadyCalled || count > 1 ) {

   289 				throw new Error( "Called start() outside of a test context too many times" );

   290 			} else if ( config.autostart ) {

   291 				throw new Error( "Called start() outside of a test context when " +

   292 					"QUnit.config.autostart was true" );

   293 			} else if ( !config.pageLoaded ) {

   294 

   295 				// The page isn't completely loaded yet, so bail out and let `QUnit.load` handle it

   296 				config.autostart = true;

   297 				return;

   298 			}

   299 		} else {

   300 

   301 			// If a test is running, adjust its semaphore

   302 			config.current.semaphore -= count || 1;

   303 

   304 			// Don't start until equal number of stop-calls

   305 			if ( config.current.semaphore > 0 ) {

   306 				return;

   307 			}

   308 

   309 			// throw an Error if start is called more often than stop

   310 			if ( config.current.semaphore < 0 ) {

   311 				config.current.semaphore = 0;

   312 

   313 				QUnit.pushFailure(

   314 					"Called start() while already started (test's semaphore was 0 already)",

   315 					sourceFromStacktrace( 2 )

   316 				);

   317 				return;

   318 			}

   319 		}

   320 

   321 		resumeProcessing();

   322 	},

   323 

   324 	// DEPRECATED: QUnit.stop() will be removed in QUnit 2.0.

   325 	stop: function( count ) {

   326 

   327 		// If there isn't a test running, don't allow QUnit.stop() to be called

   328 		if ( !config.current ) {

   329 			throw new Error( "Called stop() outside of a test context" );

   330 		}

   331 

   332 		// If a test is running, adjust its semaphore

   333 		config.current.semaphore += count || 1;

   334 

   335 		pauseProcessing();

   336 	},

   337 

   338 	config: config,

   339 

   340 	// Safe object type checking

   341 	is: function( type, obj ) {

   342 		return QUnit.objectType( obj ) === type;

   343 	},

   344 

   345 	objectType: function( obj ) {

   346 		if ( typeof obj === "undefined" ) {

   347 			return "undefined";

   348 		}

   349 

   350 		// Consider: typeof null === object

   351 		if ( obj === null ) {

   352 			return "null";

   353 		}

   354 

   355 		var match = toString.call( obj ).match( /^\[object\s(.*)\]$/ ),

   356 			type = match && match[ 1 ] || "";

   357 

   358 		switch ( type ) {

   359 			case "Number":

   360 				if ( isNaN( obj ) ) {

   361 					return "nan";

   362 				}

   363 				return "number";

   364 			case "String":

   365 			case "Boolean":

   366 			case "Array":

   367 			case "Date":

   368 			case "RegExp":

   369 			case "Function":

   370 				return type.toLowerCase();

   371 		}

   372 		if ( typeof obj === "object" ) {

   373 			return "object";

   374 		}

   375 		return undefined;

   376 	},

   377 

   378 	extend: extend,

   379 

   380 	load: function() {

   381 		config.pageLoaded = true;

   382 

   383 		// Initialize the configuration options

   384 		extend( config, {

   385 			stats: { all: 0, bad: 0 },

   386 			moduleStats: { all: 0, bad: 0 },

   387 			started: 0,

   388 			updateRate: 1000,

   389 			autostart: true,

   390 			filter: ""

   391 		}, true );

   392 

   393 		config.blocking = false;

   394 

   395 		if ( config.autostart ) {

   396 			resumeProcessing();

   397 		}

   398 	}

   399 });

   400 

   401 // Register logging callbacks

   402 (function() {

   403 	var i, l, key,

   404 		callbacks = [ "begin", "done", "log", "testStart", "testDone",

   405 			"moduleStart", "moduleDone" ];

   406 

   407 	function registerLoggingCallback( key ) {

   408 		var loggingCallback = function( callback ) {

   409 			if ( QUnit.objectType( callback ) !== "function" ) {

   410 				throw new Error(

   411 					"QUnit logging methods require a callback function as their first parameters."

   412 				);

   413 			}

   414 

   415 			config.callbacks[ key ].push( callback );

   416 		};

   417 

   418 		// DEPRECATED: This will be removed on QUnit 2.0.0+

   419 		// Stores the registered functions allowing restoring

   420 		// at verifyLoggingCallbacks() if modified

   421 		loggingCallbacks[ key ] = loggingCallback;

   422 

   423 		return loggingCallback;

   424 	}

   425 

   426 	for ( i = 0, l = callbacks.length; i < l; i++ ) {

   427 		key = callbacks[ i ];

   428 

   429 		// Initialize key collection of logging callback

   430 		if ( QUnit.objectType( config.callbacks[ key ] ) === "undefined" ) {

   431 			config.callbacks[ key ] = [];

   432 		}

   433 

   434 		QUnit[ key ] = registerLoggingCallback( key );

   435 	}

   436 })();

   437 

   438 // `onErrorFnPrev` initialized at top of scope

   439 // Preserve other handlers

   440 onErrorFnPrev = window.onerror;

   441 

   442 // Cover uncaught exceptions

   443 // Returning true will suppress the default browser handler,

   444 // returning false will let it run.

   445 window.onerror = function( error, filePath, linerNr ) {

   446 	var ret = false;

   447 	if ( onErrorFnPrev ) {

   448 		ret = onErrorFnPrev( error, filePath, linerNr );

   449 	}

   450 

   451 	// Treat return value as window.onerror itself does,

   452 	// Only do our handling if not suppressed.

   453 	if ( ret !== true ) {

   454 		if ( QUnit.config.current ) {

   455 			if ( QUnit.config.current.ignoreGlobalErrors ) {

   456 				return true;

   457 			}

   458 			QUnit.pushFailure( error, filePath + ":" + linerNr );

   459 		} else {

   460 			QUnit.test( "global failure", extend(function() {

   461 				QUnit.pushFailure( error, filePath + ":" + linerNr );

   462 			}, { validTest: true } ) );

   463 		}

   464 		return false;

   465 	}

   466 

   467 	return ret;

   468 };

   469 

   470 function done() {

   471 	var runtime, passed;

   472 

   473 	config.autorun = true;

   474 

   475 	// Log the last module results

   476 	if ( config.previousModule ) {

   477 		runLoggingCallbacks( "moduleDone", {

   478 			name: config.previousModule.name,

   479 			tests: config.previousModule.tests,

   480 			failed: config.moduleStats.bad,

   481 			passed: config.moduleStats.all - config.moduleStats.bad,

   482 			total: config.moduleStats.all,

   483 			runtime: now() - config.moduleStats.started

   484 		});

   485 	}

   486 	delete config.previousModule;

   487 

   488 	runtime = now() - config.started;

   489 	passed = config.stats.all - config.stats.bad;

   490 

   491 	runLoggingCallbacks( "done", {

   492 		failed: config.stats.bad,

   493 		passed: passed,

   494 		total: config.stats.all,

   495 		runtime: runtime

   496 	});

   497 }

   498 

   499 // Doesn't support IE6 to IE9, it will return undefined on these browsers

   500 // See also https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error/Stack

   501 function extractStacktrace( e, offset ) {

   502 	offset = offset === undefined ? 4 : offset;

   503 

   504 	var stack, include, i;

   505 

   506 	if ( e.stack ) {

   507 		stack = e.stack.split( "\n" );

   508 		if ( /^error$/i.test( stack[ 0 ] ) ) {

   509 			stack.shift();

   510 		}

   511 		if ( fileName ) {

   512 			include = [];

   513 			for ( i = offset; i < stack.length; i++ ) {

   514 				if ( stack[ i ].indexOf( fileName ) !== -1 ) {

   515 					break;

   516 				}

   517 				include.push( stack[ i ] );

   518 			}

   519 			if ( include.length ) {

   520 				return include.join( "\n" );

   521 			}

   522 		}

   523 		return stack[ offset ];

   524 

   525 	// Support: Safari <=6 only

   526 	} else if ( e.sourceURL ) {

   527 

   528 		// exclude useless self-reference for generated Error objects

   529 		if ( /qunit.js$/.test( e.sourceURL ) ) {

   530 			return;

   531 		}

   532 

   533 		// for actual exceptions, this is useful

   534 		return e.sourceURL + ":" + e.line;

   535 	}

   536 }

   537 

   538 function sourceFromStacktrace( offset ) {

   539 	var error = new Error();

   540 

   541 	// Support: Safari <=7 only, IE <=10 - 11 only

   542 	// Not all browsers generate the `stack` property for `new Error()`, see also #636

   543 	if ( !error.stack ) {

   544 		try {

   545 			throw error;

   546 		} catch ( err ) {

   547 			error = err;

   548 		}

   549 	}

   550 

   551 	return extractStacktrace( error, offset );

   552 }

   553 

   554 function synchronize( callback, last ) {

   555 	if ( QUnit.objectType( callback ) === "array" ) {

   556 		while ( callback.length ) {

   557 			synchronize( callback.shift() );

   558 		}

   559 		return;

   560 	}

   561 	config.queue.push( callback );

   562 

   563 	if ( config.autorun && !config.blocking ) {

   564 		process( last );

   565 	}

   566 }

   567 

   568 function process( last ) {

   569 	function next() {

   570 		process( last );

   571 	}

   572 	var start = now();

   573 	config.depth = ( config.depth || 0 ) + 1;

   574 

   575 	while ( config.queue.length && !config.blocking ) {

   576 		if ( !defined.setTimeout || config.updateRate <= 0 ||

   577 				( ( now() - start ) < config.updateRate ) ) {

   578 			if ( config.current ) {

   579 

   580 				// Reset async tracking for each phase of the Test lifecycle

   581 				config.current.usedAsync = false;

   582 			}

   583 			config.queue.shift()();

   584 		} else {

   585 			setTimeout( next, 13 );

   586 			break;

   587 		}

   588 	}

   589 	config.depth--;

   590 	if ( last && !config.blocking && !config.queue.length && config.depth === 0 ) {

   591 		done();

   592 	}

   593 }

   594 

   595 function begin() {

   596 	var i, l,

   597 		modulesLog = [];

   598 

   599 	// If the test run hasn't officially begun yet

   600 	if ( !config.started ) {

   601 

   602 		// Record the time of the test run's beginning

   603 		config.started = now();

   604 

   605 		verifyLoggingCallbacks();

   606 

   607 		// Delete the loose unnamed module if unused.

   608 		if ( config.modules[ 0 ].name === "" && config.modules[ 0 ].tests.length === 0 ) {

   609 			config.modules.shift();

   610 		}

   611 

   612 		// Avoid unnecessary information by not logging modules' test environments

   613 		for ( i = 0, l = config.modules.length; i < l; i++ ) {

   614 			modulesLog.push({

   615 				name: config.modules[ i ].name,

   616 				tests: config.modules[ i ].tests

   617 			});

   618 		}

   619 

   620 		// The test run is officially beginning now

   621 		runLoggingCallbacks( "begin", {

   622 			totalTests: Test.count,

   623 			modules: modulesLog

   624 		});

   625 	}

   626 

   627 	config.blocking = false;

   628 	process( true );

   629 }

   630 

   631 function resumeProcessing() {

   632 	runStarted = true;

   633 

   634 	// A slight delay to allow this iteration of the event loop to finish (more assertions, etc.)

   635 	if ( defined.setTimeout ) {

   636 		setTimeout(function() {

   637 			if ( config.current && config.current.semaphore > 0 ) {

   638 				return;

   639 			}

   640 			if ( config.timeout ) {

   641 				clearTimeout( config.timeout );

   642 			}

   643 

   644 			begin();

   645 		}, 13 );

   646 	} else {

   647 		begin();

   648 	}

   649 }

   650 

   651 function pauseProcessing() {

   652 	config.blocking = true;

   653 

   654 	if ( config.testTimeout && defined.setTimeout ) {

   655 		clearTimeout( config.timeout );

   656 		config.timeout = setTimeout(function() {

   657 			if ( config.current ) {

   658 				config.current.semaphore = 0;

   659 				QUnit.pushFailure( "Test timed out", sourceFromStacktrace( 2 ) );

   660 			} else {

   661 				throw new Error( "Test timed out" );

   662 			}

   663 			resumeProcessing();

   664 		}, config.testTimeout );

   665 	}

   666 }

   667 

   668 function saveGlobal() {

   669 	config.pollution = [];

   670 

   671 	if ( config.noglobals ) {

   672 		for ( var key in window ) {

   673 			if ( hasOwn.call( window, key ) ) {

   674 				// in Opera sometimes DOM element ids show up here, ignore them

   675 				if ( /^qunit-test-output/.test( key ) ) {

   676 					continue;

   677 				}

   678 				config.pollution.push( key );

   679 			}

   680 		}

   681 	}

   682 }

   683 

   684 function checkPollution() {

   685 	var newGlobals,

   686 		deletedGlobals,

   687 		old = config.pollution;

   688 

   689 	saveGlobal();

   690 

   691 	newGlobals = diff( config.pollution, old );

   692 	if ( newGlobals.length > 0 ) {

   693 		QUnit.pushFailure( "Introduced global variable(s): " + newGlobals.join( ", " ) );

   694 	}

   695 

   696 	deletedGlobals = diff( old, config.pollution );

   697 	if ( deletedGlobals.length > 0 ) {

   698 		QUnit.pushFailure( "Deleted global variable(s): " + deletedGlobals.join( ", " ) );

   699 	}

   700 }

   701 

   702 // returns a new Array with the elements that are in a but not in b

   703 function diff( a, b ) {

   704 	var i, j,

   705 		result = a.slice();

   706 

   707 	for ( i = 0; i < result.length; i++ ) {

   708 		for ( j = 0; j < b.length; j++ ) {

   709 			if ( result[ i ] === b[ j ] ) {

   710 				result.splice( i, 1 );

   711 				i--;

   712 				break;

   713 			}

   714 		}

   715 	}

   716 	return result;

   717 }

   718 

   719 function extend( a, b, undefOnly ) {

   720 	for ( var prop in b ) {

   721 		if ( hasOwn.call( b, prop ) ) {

   722 

   723 			// Avoid "Member not found" error in IE8 caused by messing with window.constructor

   724 			if ( !( prop === "constructor" && a === window ) ) {

   725 				if ( b[ prop ] === undefined ) {

   726 					delete a[ prop ];

   727 				} else if ( !( undefOnly && typeof a[ prop ] !== "undefined" ) ) {

   728 					a[ prop ] = b[ prop ];

   729 				}

   730 			}

   731 		}

   732 	}

   733 

   734 	return a;

   735 }

   736 

   737 function runLoggingCallbacks( key, args ) {

   738 	var i, l, callbacks;

   739 

   740 	callbacks = config.callbacks[ key ];

   741 	for ( i = 0, l = callbacks.length; i < l; i++ ) {

   742 		callbacks[ i ]( args );

   743 	}

   744 }

   745 

   746 // DEPRECATED: This will be removed on 2.0.0+

   747 // This function verifies if the loggingCallbacks were modified by the user

   748 // If so, it will restore it, assign the given callback and print a console warning

   749 function verifyLoggingCallbacks() {

   750 	var loggingCallback, userCallback;

   751 

   752 	for ( loggingCallback in loggingCallbacks ) {

   753 		if ( QUnit[ loggingCallback ] !== loggingCallbacks[ loggingCallback ] ) {

   754 

   755 			userCallback = QUnit[ loggingCallback ];

   756 

   757 			// Restore the callback function

   758 			QUnit[ loggingCallback ] = loggingCallbacks[ loggingCallback ];

   759 

   760 			// Assign the deprecated given callback

   761 			QUnit[ loggingCallback ]( userCallback );

   762 

   763 			if ( window.console && window.console.warn ) {

   764 				window.console.warn(

   765 					"QUnit." + loggingCallback + " was replaced with a new value.\n" +

   766 					"Please, check out the documentation on how to apply logging callbacks.\n" +

   767 					"Reference: http://api.qunitjs.com/category/callbacks/"

   768 				);

   769 			}

   770 		}

   771 	}

   772 }

   773 

   774 // from jquery.js

   775 function inArray( elem, array ) {

   776 	if ( array.indexOf ) {

   777 		return array.indexOf( elem );

   778 	}

   779 

   780 	for ( var i = 0, length = array.length; i < length; i++ ) {

   781 		if ( array[ i ] === elem ) {

   782 			return i;

   783 		}

   784 	}

   785 

   786 	return -1;

   787 }

   788 

   789 function Test( settings ) {

   790 	var i, l;

   791 

   792 	++Test.count;

   793 

   794 	extend( this, settings );

   795 	this.assertions = [];

   796 	this.semaphore = 0;

   797 	this.usedAsync = false;

   798 	this.module = config.currentModule;

   799 	this.stack = sourceFromStacktrace( 3 );

   800 

   801 	// Register unique strings

   802 	for ( i = 0, l = this.module.tests; i < l.length; i++ ) {

   803 		if ( this.module.tests[ i ].name === this.testName ) {

   804 			this.testName += " ";

   805 		}

   806 	}

   807 

   808 	this.testId = generateHash( this.module.name, this.testName );

   809 

   810 	this.module.tests.push({

   811 		name: this.testName,

   812 		testId: this.testId

   813 	});

   814 

   815 	if ( settings.skip ) {

   816 

   817 		// Skipped tests will fully ignore any sent callback

   818 		this.callback = function() {};

   819 		this.async = false;

   820 		this.expected = 0;

   821 	} else {

   822 		this.assert = new Assert( this );

   823 	}

   824 }

   825 

   826 Test.count = 0;

   827 

   828 Test.prototype = {

   829 	before: function() {

   830 		if (

   831 

   832 			// Emit moduleStart when we're switching from one module to another

   833 			this.module !== config.previousModule ||

   834 

   835 				// They could be equal (both undefined) but if the previousModule property doesn't

   836 				// yet exist it means this is the first test in a suite that isn't wrapped in a

   837 				// module, in which case we'll just emit a moduleStart event for 'undefined'.

   838 				// Without this, reporters can get testStart before moduleStart  which is a problem.

   839 				!hasOwn.call( config, "previousModule" )

   840 		) {

   841 			if ( hasOwn.call( config, "previousModule" ) ) {

   842 				runLoggingCallbacks( "moduleDone", {

   843 					name: config.previousModule.name,

   844 					tests: config.previousModule.tests,

   845 					failed: config.moduleStats.bad,

   846 					passed: config.moduleStats.all - config.moduleStats.bad,

   847 					total: config.moduleStats.all,

   848 					runtime: now() - config.moduleStats.started

   849 				});

   850 			}

   851 			config.previousModule = this.module;

   852 			config.moduleStats = { all: 0, bad: 0, started: now() };

   853 			runLoggingCallbacks( "moduleStart", {

   854 				name: this.module.name,

   855 				tests: this.module.tests

   856 			});

   857 		}

   858 

   859 		config.current = this;

   860 

   861 		this.testEnvironment = extend( {}, this.module.testEnvironment );

   862 		delete this.testEnvironment.beforeEach;

   863 		delete this.testEnvironment.afterEach;

   864 

   865 		this.started = now();

   866 		runLoggingCallbacks( "testStart", {

   867 			name: this.testName,

   868 			module: this.module.name,

   869 			testId: this.testId

   870 		});

   871 

   872 		if ( !config.pollution ) {

   873 			saveGlobal();

   874 		}

   875 	},

   876 

   877 	run: function() {

   878 		var promise;

   879 

   880 		config.current = this;

   881 

   882 		if ( this.async ) {

   883 			QUnit.stop();

   884 		}

   885 

   886 		this.callbackStarted = now();

   887 

   888 		if ( config.notrycatch ) {

   889 			promise = this.callback.call( this.testEnvironment, this.assert );

   890 			this.resolvePromise( promise );

   891 			return;

   892 		}

   893 

   894 		try {

   895 			promise = this.callback.call( this.testEnvironment, this.assert );

   896 			this.resolvePromise( promise );

   897 		} catch ( e ) {

   898 			this.pushFailure( "Died on test #" + ( this.assertions.length + 1 ) + " " +

   899 				this.stack + ": " + ( e.message || e ), extractStacktrace( e, 0 ) );

   900 

   901 			// else next test will carry the responsibility

   902 			saveGlobal();

   903 

   904 			// Restart the tests if they're blocking

   905 			if ( config.blocking ) {

   906 				QUnit.start();

   907 			}

   908 		}

   909 	},

   910 

   911 	after: function() {

   912 		checkPollution();

   913 	},

   914 

   915 	queueHook: function( hook, hookName ) {

   916 		var promise,

   917 			test = this;

   918 		return function runHook() {

   919 			config.current = test;

   920 			if ( config.notrycatch ) {

   921 				promise = hook.call( test.testEnvironment, test.assert );

   922 				test.resolvePromise( promise, hookName );

   923 				return;

   924 			}

   925 			try {

   926 				promise = hook.call( test.testEnvironment, test.assert );

   927 				test.resolvePromise( promise, hookName );

   928 			} catch ( error ) {

   929 				test.pushFailure( hookName + " failed on " + test.testName + ": " +

   930 					( error.message || error ), extractStacktrace( error, 0 ) );

   931 			}

   932 		};

   933 	},

   934 

   935 	// Currently only used for module level hooks, can be used to add global level ones

   936 	hooks: function( handler ) {

   937 		var hooks = [];

   938 

   939 		// Hooks are ignored on skipped tests

   940 		if ( this.skip ) {

   941 			return hooks;

   942 		}

   943 

   944 		if ( this.module.testEnvironment &&

   945 				QUnit.objectType( this.module.testEnvironment[ handler ] ) === "function" ) {

   946 			hooks.push( this.queueHook( this.module.testEnvironment[ handler ], handler ) );

   947 		}

   948 

   949 		return hooks;

   950 	},

   951 

   952 	finish: function() {

   953 		config.current = this;

   954 		if ( config.requireExpects && this.expected === null ) {

   955 			this.pushFailure( "Expected number of assertions to be defined, but expect() was " +

   956 				"not called.", this.stack );

   957 		} else if ( this.expected !== null && this.expected !== this.assertions.length ) {

   958 			this.pushFailure( "Expected " + this.expected + " assertions, but " +

   959 				this.assertions.length + " were run", this.stack );

   960 		} else if ( this.expected === null && !this.assertions.length ) {

   961 			this.pushFailure( "Expected at least one assertion, but none were run - call " +

   962 				"expect(0) to accept zero assertions.", this.stack );

   963 		}

   964 

   965 		var i,

   966 			bad = 0;

   967 

   968 		this.runtime = now() - this.started;

   969 		config.stats.all += this.assertions.length;

   970 		config.moduleStats.all += this.assertions.length;

   971 

   972 		for ( i = 0; i < this.assertions.length; i++ ) {

   973 			if ( !this.assertions[ i ].result ) {

   974 				bad++;

   975 				config.stats.bad++;

   976 				config.moduleStats.bad++;

   977 			}

   978 		}

   979 

   980 		runLoggingCallbacks( "testDone", {

   981 			name: this.testName,

   982 			module: this.module.name,

   983 			skipped: !!this.skip,

   984 			failed: bad,

   985 			passed: this.assertions.length - bad,

   986 			total: this.assertions.length,

   987 			runtime: this.runtime,

   988 

   989 			// HTML Reporter use

   990 			assertions: this.assertions,

   991 			testId: this.testId,

   992 

   993 			// DEPRECATED: this property will be removed in 2.0.0, use runtime instead

   994 			duration: this.runtime

   995 		});

   996 

   997 		// QUnit.reset() is deprecated and will be replaced for a new

   998 		// fixture reset function on QUnit 2.0/2.1.

   999 		// It's still called here for backwards compatibility handling

  1000 		QUnit.reset();

  1001 

  1002 		config.current = undefined;

  1003 	},

  1004 

  1005 	queue: function() {

  1006 		var bad,

  1007 			test = this;

  1008 

  1009 		if ( !this.valid() ) {

  1010 			return;

  1011 		}

  1012 

  1013 		function run() {

  1014 

  1015 			// each of these can by async

  1016 			synchronize([

  1017 				function() {

  1018 					test.before();

  1019 				},

  1020 

  1021 				test.hooks( "beforeEach" ),

  1022 

  1023 				function() {

  1024 					test.run();

  1025 				},

  1026 

  1027 				test.hooks( "afterEach" ).reverse(),

  1028 

  1029 				function() {

  1030 					test.after();

  1031 				},

  1032 				function() {

  1033 					test.finish();

  1034 				}

  1035 			]);

  1036 		}

  1037 

  1038 		// `bad` initialized at top of scope

  1039 		// defer when previous test run passed, if storage is available

  1040 		bad = QUnit.config.reorder && defined.sessionStorage &&

  1041 				+sessionStorage.getItem( "qunit-test-" + this.module.name + "-" + this.testName );

  1042 

  1043 		if ( bad ) {

  1044 			run();

  1045 		} else {

  1046 			synchronize( run, true );

  1047 		}

  1048 	},

  1049 

  1050 	push: function( result, actual, expected, message ) {

  1051 		var source,

  1052 			details = {

  1053 				module: this.module.name,

  1054 				name: this.testName,

  1055 				result: result,

  1056 				message: message,

  1057 				actual: actual,

  1058 				expected: expected,

  1059 				testId: this.testId,

  1060 				runtime: now() - this.started

  1061 			};

  1062 

  1063 		if ( !result ) {

  1064 			source = sourceFromStacktrace();

  1065 

  1066 			if ( source ) {

  1067 				details.source = source;

  1068 			}

  1069 		}

  1070 

  1071 		runLoggingCallbacks( "log", details );

  1072 

  1073 		this.assertions.push({

  1074 			result: !!result,

  1075 			message: message

  1076 		});

  1077 	},

  1078 

  1079 	pushFailure: function( message, source, actual ) {

  1080 		if ( !this instanceof Test ) {

  1081 			throw new Error( "pushFailure() assertion outside test context, was " +

  1082 				sourceFromStacktrace( 2 ) );

  1083 		}

  1084 

  1085 		var details = {

  1086 				module: this.module.name,

  1087 				name: this.testName,

  1088 				result: false,

  1089 				message: message || "error",

  1090 				actual: actual || null,

  1091 				testId: this.testId,

  1092 				runtime: now() - this.started

  1093 			};

  1094 

  1095 		if ( source ) {

  1096 			details.source = source;

  1097 		}

  1098 

  1099 		runLoggingCallbacks( "log", details );

  1100 

  1101 		this.assertions.push({

  1102 			result: false,

  1103 			message: message

  1104 		});

  1105 	},

  1106 

  1107 	resolvePromise: function( promise, phase ) {

  1108 		var then, message,

  1109 			test = this;

  1110 		if ( promise != null ) {

  1111 			then = promise.then;

  1112 			if ( QUnit.objectType( then ) === "function" ) {

  1113 				QUnit.stop();

  1114 				then.call(

  1115 					promise,

  1116 					QUnit.start,

  1117 					function( error ) {

  1118 						message = "Promise rejected " +

  1119 							( !phase ? "during" : phase.replace( /Each$/, "" ) ) +

  1120 							" " + test.testName + ": " + ( error.message || error );

  1121 						test.pushFailure( message, extractStacktrace( error, 0 ) );

  1122 

  1123 						// else next test will carry the responsibility

  1124 						saveGlobal();

  1125 

  1126 						// Unblock

  1127 						QUnit.start();

  1128 					}

  1129 				);

  1130 			}

  1131 		}

  1132 	},

  1133 

  1134 	valid: function() {

  1135 		var include,