Real-time collaboration for Jupyter Notebooks, Linux Terminals, LaTeX, VS Code, R IDE, and more,
all in one place. Commercial Alternative to JupyterHub.

1
/**
2
 * QUnit v1.12.0 - A JavaScript Unit Testing Framework
3
 *
4
 * http://qunitjs.com
5
 *
6
 * Copyright 2013 jQuery Foundation and other contributors
7
 * Released under the MIT license.
8
 * https://jquery.org/license/
9
 */
10

11
(function( window ) {
12

13
var QUnit,
14
	assert,
15
	config,
16
	onErrorFnPrev,
17
	testId = 0,
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
	setTimeout = window.setTimeout,
24
	defined = {
25
		setTimeout: typeof window.setTimeout !== "undefined",
26
		sessionStorage: (function() {
27
			var x = "qunit-test-string";
28
			try {
29
				sessionStorage.setItem( x, x );
30
				sessionStorage.removeItem( x );
31
				return true;
32
			} catch( e ) {
33
				return false;
34
			}
35
		}())
36
	},
37
	/**
38
	 * Provides a normalized error string, correcting an issue
39
	 * with IE 7 (and prior) where Error.prototype.toString is
40
	 * not properly implemented
41
	 *
42
	 * Based on http://es5.github.com/#x15.11.4.4
43
	 *
44
	 * @param {String|Error} error
45
	 * @return {String} error message
46
	 */
47
	errorString = function( error ) {
48
		var name, message,
49
			errorString = error.toString();
50
		if ( errorString.substring( 0, 7 ) === "[object" ) {
51
			name = error.name ? error.name.toString() : "Error";
52
			message = error.message ? error.message.toString() : "";
53
			if ( name && message ) {
54
				return name + ": " + message;
55
			} else if ( name ) {
56
				return name;
57
			} else if ( message ) {
58
				return message;
59
			} else {
60
				return "Error";
61
			}
62
		} else {
63
			return errorString;
64
		}
65
	},
66
	/**
67
	 * Makes a clone of an object using only Array or Object as base,
68
	 * and copies over the own enumerable properties.
69
	 *
70
	 * @param {Object} obj
71
	 * @return {Object} New object with only the own properties (recursively).
72
	 */
73
	objectValues = function( obj ) {
74
		// Grunt 0.3.x uses an older version of jshint that still has jshint/jshint#392.
75
		/*jshint newcap: false */
76
		var key, val,
77
			vals = QUnit.is( "array", obj ) ? [] : {};
78
		for ( key in obj ) {
79
			if ( hasOwn.call( obj, key ) ) {
80
				val = obj[key];
81
				vals[key] = val === Object(val) ? objectValues(val) : val;
82
			}
83
		}
84
		return vals;
85
	};
86

87
function Test( settings ) {
88
	extend( this, settings );
89
	this.assertions = [];
90
	this.testNumber = ++Test.count;
91
}
92

93
Test.count = 0;
94

95
Test.prototype = {
96
	init: function() {
97
		var a, b, li,
98
			tests = id( "qunit-tests" );
99

100
		if ( tests ) {
101
			b = document.createElement( "strong" );
102
			b.innerHTML = this.nameHtml;
103

104
			// `a` initialized at top of scope
105
			a = document.createElement( "a" );
106
			a.innerHTML = "Rerun";
107
			a.href = QUnit.url({ testNumber: this.testNumber });
108

109
			li = document.createElement( "li" );
110
			li.appendChild( b );
111
			li.appendChild( a );
112
			li.className = "running";
113
			li.id = this.id = "qunit-test-output" + testId++;
114

115
			tests.appendChild( li );
116
		}
117
	},
118
	setup: function() {
119
		if (
120
			// Emit moduleStart when we're switching from one module to another
121
			this.module !== config.previousModule ||
122
				// They could be equal (both undefined) but if the previousModule property doesn't
123
				// yet exist it means this is the first test in a suite that isn't wrapped in a
124
				// module, in which case we'll just emit a moduleStart event for 'undefined'.
125
				// Without this, reporters can get testStart before moduleStart  which is a problem.
126
				!hasOwn.call( config, "previousModule" )
127
		) {
128
			if ( hasOwn.call( config, "previousModule" ) ) {
129
				runLoggingCallbacks( "moduleDone", QUnit, {
130
					name: config.previousModule,
131
					failed: config.moduleStats.bad,
132
					passed: config.moduleStats.all - config.moduleStats.bad,
133
					total: config.moduleStats.all
134
				});
135
			}
136
			config.previousModule = this.module;
137
			config.moduleStats = { all: 0, bad: 0 };
138
			runLoggingCallbacks( "moduleStart", QUnit, {
139
				name: this.module
140
			});
141
		}
142

143
		config.current = this;
144

145
		this.testEnvironment = extend({
146
			setup: function() {},
147
			teardown: function() {}
148
		}, this.moduleTestEnvironment );
149

150
		this.started = +new Date();
151
		runLoggingCallbacks( "testStart", QUnit, {
152
			name: this.testName,
153
			module: this.module
154
		});
155

156
		/*jshint camelcase:false */
157

158

159
		/**
160
		 * Expose the current test environment.
161
		 *
162
		 * @deprecated since 1.12.0: Use QUnit.config.current.testEnvironment instead.
163
		 */
164
		QUnit.current_testEnvironment = this.testEnvironment;
165

166
		/*jshint camelcase:true */
167

168
		if ( !config.pollution ) {
169
			saveGlobal();
170
		}
171
		if ( config.notrycatch ) {
172
			this.testEnvironment.setup.call( this.testEnvironment, QUnit.assert );
173
			return;
174
		}
175
		try {
176
			this.testEnvironment.setup.call( this.testEnvironment, QUnit.assert );
177
		} catch( e ) {
178
			QUnit.pushFailure( "Setup failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) );
179
		}
180
	},
181
	run: function() {
182
		config.current = this;
183

184
		var running = id( "qunit-testresult" );
185

186
		if ( running ) {
187
			running.innerHTML = "Running: <br/>" + this.nameHtml;
188
		}
189

190
		if ( this.async ) {
191
			QUnit.stop();
192
		}
193

194
		this.callbackStarted = +new Date();
195

196
		if ( config.notrycatch ) {
197
			this.callback.call( this.testEnvironment, QUnit.assert );
198
			this.callbackRuntime = +new Date() - this.callbackStarted;
199
			return;
200
		}
201

202
		try {
203
			this.callback.call( this.testEnvironment, QUnit.assert );
204
			this.callbackRuntime = +new Date() - this.callbackStarted;
205
		} catch( e ) {
206
			this.callbackRuntime = +new Date() - this.callbackStarted;
207

208
			QUnit.pushFailure( "Died on test #" + (this.assertions.length + 1) + " " + this.stack + ": " + ( e.message || e ), extractStacktrace( e, 0 ) );
209
			// else next test will carry the responsibility
210
			saveGlobal();
211

212
			// Restart the tests if they're blocking
213
			if ( config.blocking ) {
214
				QUnit.start();
215
			}
216
		}
217
	},
218
	teardown: function() {
219
		config.current = this;
220
		if ( config.notrycatch ) {
221
			if ( typeof this.callbackRuntime === "undefined" ) {
222
				this.callbackRuntime = +new Date() - this.callbackStarted;
223
			}
224
			this.testEnvironment.teardown.call( this.testEnvironment, QUnit.assert );
225
			return;
226
		} else {
227
			try {
228
				this.testEnvironment.teardown.call( this.testEnvironment, QUnit.assert );
229
			} catch( e ) {
230
				QUnit.pushFailure( "Teardown failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) );
231
			}
232
		}
233
		checkPollution();
234
	},
235
	finish: function() {
236
		config.current = this;
237
		if ( config.requireExpects && this.expected === null ) {
238
			QUnit.pushFailure( "Expected number of assertions to be defined, but expect() was not called.", this.stack );
239
		} else if ( this.expected !== null && this.expected !== this.assertions.length ) {
240
			QUnit.pushFailure( "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run", this.stack );
241
		} else if ( this.expected === null && !this.assertions.length ) {
242
			QUnit.pushFailure( "Expected at least one assertion, but none were run - call expect(0) to accept zero assertions.", this.stack );
243
		}
244

245
		var i, assertion, a, b, time, li, ol,
246
			test = this,
247
			good = 0,
248
			bad = 0,
249
			tests = id( "qunit-tests" );
250

251
		this.runtime = +new Date() - this.started;
252
		config.stats.all += this.assertions.length;
253
		config.moduleStats.all += this.assertions.length;
254

255
		if ( tests ) {
256
			ol = document.createElement( "ol" );
257
			ol.className = "qunit-assert-list";
258

259
			for ( i = 0; i < this.assertions.length; i++ ) {
260
				assertion = this.assertions[i];
261

262
				li = document.createElement( "li" );
263
				li.className = assertion.result ? "pass" : "fail";
264
				li.innerHTML = assertion.message || ( assertion.result ? "okay" : "failed" );
265
				ol.appendChild( li );
266

267
				if ( assertion.result ) {
268
					good++;
269
				} else {
270
					bad++;
271
					config.stats.bad++;
272
					config.moduleStats.bad++;
273
				}
274
			}
275

276
			// store result when possible
277
			if ( QUnit.config.reorder && defined.sessionStorage ) {
278
				if ( bad ) {
279
					sessionStorage.setItem( "qunit-test-" + this.module + "-" + this.testName, bad );
280
				} else {
281
					sessionStorage.removeItem( "qunit-test-" + this.module + "-" + this.testName );
282
				}
283
			}
284

285
			if ( bad === 0 ) {
286
				addClass( ol, "qunit-collapsed" );
287
			}
288

289
			// `b` initialized at top of scope
290
			b = document.createElement( "strong" );
291
			b.innerHTML = this.nameHtml + " <b class='counts'>(<b class='failed'>" + bad + "</b>, <b class='passed'>" + good + "</b>, " + this.assertions.length + ")</b>";
292

293
			addEvent(b, "click", function() {
294
				var next = b.parentNode.lastChild,
295
					collapsed = hasClass( next, "qunit-collapsed" );
296
				( collapsed ? removeClass : addClass )( next, "qunit-collapsed" );
297
			});
298

299
			addEvent(b, "dblclick", function( e ) {
300
				var target = e && e.target ? e.target : window.event.srcElement;
301
				if ( target.nodeName.toLowerCase() === "span" || target.nodeName.toLowerCase() === "b" ) {
302
					target = target.parentNode;
303
				}
304
				if ( window.location && target.nodeName.toLowerCase() === "strong" ) {
305
					window.location = QUnit.url({ testNumber: test.testNumber });
306
				}
307
			});
308

309
			// `time` initialized at top of scope
310
			time = document.createElement( "span" );
311
			time.className = "runtime";
312
			time.innerHTML = this.runtime + " ms";
313

314
			// `li` initialized at top of scope
315
			li = id( this.id );
316
			li.className = bad ? "fail" : "pass";
317
			li.removeChild( li.firstChild );
318
			a = li.firstChild;
319
			li.appendChild( b );
320
			li.appendChild( a );
321
			li.appendChild( time );
322
			li.appendChild( ol );
323

324
		} else {
325
			for ( i = 0; i < this.assertions.length; i++ ) {
326
				if ( !this.assertions[i].result ) {
327
					bad++;
328
					config.stats.bad++;
329
					config.moduleStats.bad++;
330
				}
331
			}
332
		}
333

334
		runLoggingCallbacks( "testDone", QUnit, {
335
			name: this.testName,
336
			module: this.module,
337
			failed: bad,
338
			passed: this.assertions.length - bad,
339
			total: this.assertions.length,
340
			duration: this.runtime
341
		});
342

343
		QUnit.reset();
344

345
		config.current = undefined;
346
	},
347

348
	queue: function() {
349
		var bad,
350
			test = this;
351

352
		synchronize(function() {
353
			test.init();
354
		});
355
		function run() {
356
			// each of these can by async
357
			synchronize(function() {
358
				test.setup();
359
			});
360
			synchronize(function() {
361
				test.run();
362
			});
363
			synchronize(function() {
364
				test.teardown();
365
			});
366
			synchronize(function() {
367
				test.finish();
368
			});
369
		}
370

371
		// `bad` initialized at top of scope
372
		// defer when previous test run passed, if storage is available
373
		bad = QUnit.config.reorder && defined.sessionStorage &&
374
						+sessionStorage.getItem( "qunit-test-" + this.module + "-" + this.testName );
375

376
		if ( bad ) {
377
			run();
378
		} else {
379
			synchronize( run, true );
380
		}
381
	}
382
};
383

384
// Root QUnit object.
385
// `QUnit` initialized at top of scope
386
QUnit = {
387

388
	// call on start of module test to prepend name to all tests
389
	module: function( name, testEnvironment ) {
390
		config.currentModule = name;
391
		config.currentModuleTestEnvironment = testEnvironment;
392
		config.modules[name] = true;
393
	},
394

395
	asyncTest: function( testName, expected, callback ) {
396
		if ( arguments.length === 2 ) {
397
			callback = expected;
398
			expected = null;
399
		}
400

401
		QUnit.test( testName, expected, callback, true );
402
	},
403

404
	test: function( testName, expected, callback, async ) {
405
		var test,
406
			nameHtml = "<span class='test-name'>" + escapeText( testName ) + "</span>";
407

408
		if ( arguments.length === 2 ) {
409
			callback = expected;
410
			expected = null;
411
		}
412

413
		if ( config.currentModule ) {
414
			nameHtml = "<span class='module-name'>" + escapeText( config.currentModule ) + "</span>: " + nameHtml;
415
		}
416

417
		test = new Test({
418
			nameHtml: nameHtml,
419
			testName: testName,
420
			expected: expected,
421
			async: async,
422
			callback: callback,
423
			module: config.currentModule,
424
			moduleTestEnvironment: config.currentModuleTestEnvironment,
425
			stack: sourceFromStacktrace( 2 )
426
		});
427

428
		if ( !validTest( test ) ) {
429
			return;
430
		}
431

432
		test.queue();
433
	},
434

435
	// Specify the number of expected assertions to guarantee that failed test (no assertions are run at all) don't slip through.
436
	expect: function( asserts ) {
437
		if (arguments.length === 1) {
438
			config.current.expected = asserts;
439
		} else {
440
			return config.current.expected;
441
		}
442
	},
443

444
	start: function( count ) {
445
		// QUnit hasn't been initialized yet.
446
		// Note: RequireJS (et al) may delay onLoad
447
		if ( config.semaphore === undefined ) {
448
			QUnit.begin(function() {
449
				// This is triggered at the top of QUnit.load, push start() to the event loop, to allow QUnit.load to finish first
450
				setTimeout(function() {
451
					QUnit.start( count );
452
				});
453
			});
454
			return;
455
		}
456

457
		config.semaphore -= count || 1;
458
		// don't start until equal number of stop-calls
459
		if ( config.semaphore > 0 ) {
460
			return;
461
		}
462
		// ignore if start is called more often then stop
463
		if ( config.semaphore < 0 ) {
464
			config.semaphore = 0;
465
			QUnit.pushFailure( "Called start() while already started (QUnit.config.semaphore was 0 already)", null, sourceFromStacktrace(2) );
466
			return;
467
		}
468
		// A slight delay, to avoid any current callbacks
469
		if ( defined.setTimeout ) {
470
			setTimeout(function() {
471
				if ( config.semaphore > 0 ) {
472
					return;
473
				}
474
				if ( config.timeout ) {
475
					clearTimeout( config.timeout );
476
				}
477

478
				config.blocking = false;
479
				process( true );
480
			}, 13);
481
		} else {
482
			config.blocking = false;
483
			process( true );
484
		}
485
	},
486

487
	stop: function( count ) {
488
		config.semaphore += count || 1;
489
		config.blocking = true;
490

491
		if ( config.testTimeout && defined.setTimeout ) {
492
			clearTimeout( config.timeout );
493
			config.timeout = setTimeout(function() {
494
				QUnit.ok( false, "Test timed out" );
495
				config.semaphore = 1;
496
				QUnit.start();
497
			}, config.testTimeout );
498
		}
499
	}
500
};
501

502
// `assert` initialized at top of scope
503
// Assert helpers
504
// All of these must either call QUnit.push() or manually do:
505
// - runLoggingCallbacks( "log", .. );
506
// - config.current.assertions.push({ .. });
507
// We attach it to the QUnit object *after* we expose the public API,
508
// otherwise `assert` will become a global variable in browsers (#341).
509
assert = {
510
	/**
511
	 * Asserts rough true-ish result.
512
	 * @name ok
513
	 * @function
514
	 * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" );
515
	 */
516
	ok: function( result, msg ) {
517
		if ( !config.current ) {
518
			throw new Error( "ok() assertion outside test context, was " + sourceFromStacktrace(2) );
519
		}
520
		result = !!result;
521
		msg = msg || (result ? "okay" : "failed" );
522

523
		var source,
524
			details = {
525
				module: config.current.module,
526
				name: config.current.testName,
527
				result: result,
528
				message: msg
529
			};
530

531
		msg = "<span class='test-message'>" + escapeText( msg ) + "</span>";
532

533
		if ( !result ) {
534
			source = sourceFromStacktrace( 2 );
535
			if ( source ) {
536
				details.source = source;
537
				msg += "<table><tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr></table>";
538
			}
539
		}
540
		runLoggingCallbacks( "log", QUnit, details );
541
		config.current.assertions.push({
542
			result: result,
543
			message: msg
544
		});
545
	},
546

547
	/**
548
	 * Assert that the first two arguments are equal, with an optional message.
549
	 * Prints out both actual and expected values.
550
	 * @name equal
551
	 * @function
552
	 * @example equal( format( "Received {0} bytes.", 2), "Received 2 bytes.", "format() replaces {0} with next argument" );
553
	 */
554
	equal: function( actual, expected, message ) {
555
		/*jshint eqeqeq:false */
556
		QUnit.push( expected == actual, actual, expected, message );
557
	},
558

559
	/**
560
	 * @name notEqual
561
	 * @function
562
	 */
563
	notEqual: function( actual, expected, message ) {
564
		/*jshint eqeqeq:false */
565
		QUnit.push( expected != actual, actual, expected, message );
566
	},
567

568
	/**
569
	 * @name propEqual
570
	 * @function
571
	 */
572
	propEqual: function( actual, expected, message ) {
573
		actual = objectValues(actual);
574
		expected = objectValues(expected);
575
		QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
576
	},
577

578
	/**
579
	 * @name notPropEqual
580
	 * @function
581
	 */
582
	notPropEqual: function( actual, expected, message ) {
583
		actual = objectValues(actual);
584
		expected = objectValues(expected);
585
		QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
586
	},
587

588
	/**
589
	 * @name deepEqual
590
	 * @function
591
	 */
592
	deepEqual: function( actual, expected, message ) {
593
		QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
594
	},
595

596
	/**
597
	 * @name notDeepEqual
598
	 * @function
599
	 */
600
	notDeepEqual: function( actual, expected, message ) {
601
		QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
602
	},
603

604
	/**
605
	 * @name strictEqual
606
	 * @function
607
	 */
608
	strictEqual: function( actual, expected, message ) {
609
		QUnit.push( expected === actual, actual, expected, message );
610
	},
611

612
	/**
613
	 * @name notStrictEqual
614
	 * @function
615
	 */
616
	notStrictEqual: function( actual, expected, message ) {
617
		QUnit.push( expected !== actual, actual, expected, message );
618
	},
619

620
	"throws": function( block, expected, message ) {
621
		var actual,
622
			expectedOutput = expected,
623
			ok = false;
624

625
		// 'expected' is optional
626
		if ( typeof expected === "string" ) {
627
			message = expected;
628
			expected = null;
629
		}
630

631
		config.current.ignoreGlobalErrors = true;
632
		try {
633
			block.call( config.current.testEnvironment );
634
		} catch (e) {
635
			actual = e;
636
		}
637
		config.current.ignoreGlobalErrors = false;
638

639
		if ( actual ) {
640
			// we don't want to validate thrown error
641
			if ( !expected ) {
642
				ok = true;
643
				expectedOutput = null;
644
			// expected is a regexp
645
			} else if ( QUnit.objectType( expected ) === "regexp" ) {
646
				ok = expected.test( errorString( actual ) );
647
			// expected is a constructor
648
			} else if ( actual instanceof expected ) {
649
				ok = true;
650
			// expected is a validation function which returns true is validation passed
651
			} else if ( expected.call( {}, actual ) === true ) {
652
				expectedOutput = null;
653
				ok = true;
654
			}
655

656
			QUnit.push( ok, actual, expectedOutput, message );
657
		} else {
658
			QUnit.pushFailure( message, null, "No exception was thrown." );
659
		}
660
	}
661
};
662

663
/**
664
 * @deprecated since 1.8.0
665
 * Kept assertion helpers in root for backwards compatibility.
666
 */
667
extend( QUnit, assert );
668

669
/**
670
 * @deprecated since 1.9.0
671
 * Kept root "raises()" for backwards compatibility.
672
 * (Note that we don't introduce assert.raises).
673
 */
674
QUnit.raises = assert[ "throws" ];
675

676
/**
677
 * @deprecated since 1.0.0, replaced with error pushes since 1.3.0
678
 * Kept to avoid TypeErrors for undefined methods.
679
 */
680
QUnit.equals = function() {
681
	QUnit.push( false, false, false, "QUnit.equals has been deprecated since 2009 (e88049a0), use QUnit.equal instead" );
682
};
683
QUnit.same = function() {
684
	QUnit.push( false, false, false, "QUnit.same has been deprecated since 2009 (e88049a0), use QUnit.deepEqual instead" );
685
};
686

687
// We want access to the constructor's prototype
688
(function() {
689
	function F() {}
690
	F.prototype = QUnit;
691
	QUnit = new F();
692
	// Make F QUnit's constructor so that we can add to the prototype later
693
	QUnit.constructor = F;
694
}());
695

696
/**
697
 * Config object: Maintain internal state
698
 * Later exposed as QUnit.config
699
 * `config` initialized at top of scope
700
 */
701
config = {
702
	// The queue of tests to run
703
	queue: [],
704

705
	// block until document ready
706
	blocking: true,
707

708
	// when enabled, show only failing tests
709
	// gets persisted through sessionStorage and can be changed in UI via checkbox
710
	hidepassed: false,
711

712
	// by default, run previously failed tests first
713
	// very useful in combination with "Hide passed tests" checked
714
	reorder: true,
715

716
	// by default, modify document.title when suite is done
717
	altertitle: true,
718

719
	// when enabled, all tests must call expect()
720
	requireExpects: false,
721

722
	// add checkboxes that are persisted in the query-string
723
	// when enabled, the id is set to `true` as a `QUnit.config` property
724
	urlConfig: [
725
		{
726
			id: "noglobals",
727
			label: "Check for Globals",
728
			tooltip: "Enabling this will test if any test introduces new properties on the `window` object. Stored as query-strings."
729
		},
730
		{
731
			id: "notrycatch",
732
			label: "No try-catch",
733
			tooltip: "Enabling this will run tests outside of a try-catch block. Makes debugging exceptions in IE reasonable. Stored as query-strings."
734
		}
735
	],
736

737
	// Set of all modules.
738
	modules: {},
739

740
	// logging callback queues
741
	begin: [],
742
	done: [],
743
	log: [],
744
	testStart: [],
745
	testDone: [],
746
	moduleStart: [],
747
	moduleDone: []
748
};
749

750
// Export global variables, unless an 'exports' object exists,
751
// in that case we assume we're in CommonJS (dealt with on the bottom of the script)
752
if ( typeof exports === "undefined" ) {
753
	extend( window, QUnit.constructor.prototype );
754

755
	// Expose QUnit object
756
	window.QUnit = QUnit;
757
}
758

759
// Initialize more QUnit.config and QUnit.urlParams
760
(function() {
761
	var i,
762
		location = window.location || { search: "", protocol: "file:" },
763
		params = location.search.slice( 1 ).split( "&" ),
764
		length = params.length,
765
		urlParams = {},
766
		current;
767

768
	if ( params[ 0 ] ) {
769
		for ( i = 0; i < length; i++ ) {
770
			current = params[ i ].split( "=" );
771
			current[ 0 ] = decodeURIComponent( current[ 0 ] );
772
			// allow just a key to turn on a flag, e.g., test.html?noglobals
773
			current[ 1 ] = current[ 1 ] ? decodeURIComponent( current[ 1 ] ) : true;
774
			urlParams[ current[ 0 ] ] = current[ 1 ];
775
		}
776
	}
777

778
	QUnit.urlParams = urlParams;
779

780
	// String search anywhere in moduleName+testName
781
	config.filter = urlParams.filter;
782

783
	// Exact match of the module name
784
	config.module = urlParams.module;
785

786
	config.testNumber = parseInt( urlParams.testNumber, 10 ) || null;
787

788
	// Figure out if we're running the tests from a server or not
789
	QUnit.isLocal = location.protocol === "file:";
790
}());
791

792
// Extend QUnit object,
793
// these after set here because they should not be exposed as global functions
794
extend( QUnit, {
795
	assert: assert,
796

797
	config: config,
798

799
	// Initialize the configuration options
800
	init: function() {
801
		extend( config, {
802
			stats: { all: 0, bad: 0 },
803
			moduleStats: { all: 0, bad: 0 },
804
			started: +new Date(),
805
			updateRate: 1000,
806
			blocking: false,
807
			autostart: true,
808
			autorun: false,
809
			filter: "",
810
			queue: [],
811
			semaphore: 1
812
		});
813

814
		var tests, banner, result,
815
			qunit = id( "qunit" );
816

817
		if ( qunit ) {
818
			qunit.innerHTML =
819
				"<h1 id='qunit-header'>" + escapeText( document.title ) + "</h1>" +
820
				"<h2 id='qunit-banner'></h2>" +
821
				"<div id='qunit-testrunner-toolbar'></div>" +
822
				"<h2 id='qunit-userAgent'></h2>" +
823
				"<ol id='qunit-tests'></ol>";
824
		}
825

826
		tests = id( "qunit-tests" );
827
		banner = id( "qunit-banner" );
828
		result = id( "qunit-testresult" );
829

830
		if ( tests ) {
831
			tests.innerHTML = "";
832
		}
833

834
		if ( banner ) {
835
			banner.className = "";
836
		}
837

838
		if ( result ) {
839
			result.parentNode.removeChild( result );
840
		}
841

842
		if ( tests ) {
843
			result = document.createElement( "p" );
844
			result.id = "qunit-testresult";
845
			result.className = "result";
846
			tests.parentNode.insertBefore( result, tests );
847
			result.innerHTML = "Running...<br/>&nbsp;";
848
		}
849
	},
850

851
	// Resets the test setup. Useful for tests that modify the DOM.
852
	/*
853
	DEPRECATED: Use multiple tests instead of resetting inside a test.
854
	Use testStart or testDone for custom cleanup.
855
	This method will throw an error in 2.0, and will be removed in 2.1
856
	*/
857
	reset: function() {
858
		var fixture = id( "qunit-fixture" );
859
		if ( fixture ) {
860
			fixture.innerHTML = config.fixture;
861
		}
862
	},
863

864
	// Trigger an event on an element.
865
	// @example triggerEvent( document.body, "click" );
866
	triggerEvent: function( elem, type, event ) {
867
		if ( document.createEvent ) {
868
			event = document.createEvent( "MouseEvents" );
869
			event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView,
870
				0, 0, 0, 0, 0, false, false, false, false, 0, null);
871

872
			elem.dispatchEvent( event );
873
		} else if ( elem.fireEvent ) {
874
			elem.fireEvent( "on" + type );
875
		}
876
	},
877

878
	// Safe object type checking
879
	is: function( type, obj ) {
880
		return QUnit.objectType( obj ) === type;
881
	},
882

883
	objectType: function( obj ) {
884
		if ( typeof obj === "undefined" ) {
885
				return "undefined";
886
		// consider: typeof null === object
887
		}
888
		if ( obj === null ) {
889
				return "null";
890
		}
891

892
		var match = toString.call( obj ).match(/^\[object\s(.*)\]$/),
893
			type = match && match[1] || "";
894

895
		switch ( type ) {
896
			case "Number":
897
				if ( isNaN(obj) ) {
898
					return "nan";
899
				}
900
				return "number";
901
			case "String":
902
			case "Boolean":
903
			case "Array":
904
			case "Date":
905
			case "RegExp":
906
			case "Function":
907
				return type.toLowerCase();
908
		}
909
		if ( typeof obj === "object" ) {
910
			return "object";
911
		}
912
		return undefined;
913
	},
914

915
	push: function( result, actual, expected, message ) {
916
		if ( !config.current ) {
917
			throw new Error( "assertion outside test context, was " + sourceFromStacktrace() );
918
		}
919

920
		var output, source,
921
			details = {
922
				module: config.current.module,
923
				name: config.current.testName,
924
				result: result,
925
				message: message,
926
				actual: actual,
927
				expected: expected
928
			};
929

930
		message = escapeText( message ) || ( result ? "okay" : "failed" );
931
		message = "<span class='test-message'>" + message + "</span>";
932
		output = message;
933

934
		if ( !result ) {
935
			expected = escapeText( QUnit.jsDump.parse(expected) );
936
			actual = escapeText( QUnit.jsDump.parse(actual) );
937
			output += "<table><tr class='test-expected'><th>Expected: </th><td><pre>" + expected + "</pre></td></tr>";
938

939
			if ( actual !== expected ) {
940
				output += "<tr class='test-actual'><th>Result: </th><td><pre>" + actual + "</pre></td></tr>";
941
				output += "<tr class='test-diff'><th>Diff: </th><td><pre>" + QUnit.diff( expected, actual ) + "</pre></td></tr>";
942
			}
943

944
			source = sourceFromStacktrace();
945

946
			if ( source ) {
947
				details.source = source;
948
				output += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr>";
949
			}
950

951
			output += "</table>";
952
		}
953

954
		runLoggingCallbacks( "log", QUnit, details );
955

956
		config.current.assertions.push({
957
			result: !!result,
958
			message: output
959
		});
960
	},
961

962
	pushFailure: function( message, source, actual ) {
963
		if ( !config.current ) {
964
			throw new Error( "pushFailure() assertion outside test context, was " + sourceFromStacktrace(2) );
965
		}
966

967
		var output,
968
			details = {
969
				module: config.current.module,
970
				name: config.current.testName,
971
				result: false,
972
				message: message
973
			};
974

975
		message = escapeText( message ) || "error";
976
		message = "<span class='test-message'>" + message + "</span>";
977
		output = message;
978

979
		output += "<table>";
980

981
		if ( actual ) {
982
			output += "<tr class='test-actual'><th>Result: </th><td><pre>" + escapeText( actual ) + "</pre></td></tr>";
983
		}
984

985
		if ( source ) {
986
			details.source = source;
987
			output += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr>";
988
		}
989

990
		output += "</table>";
991

992
		runLoggingCallbacks( "log", QUnit, details );
993

994
		config.current.assertions.push({
995
			result: false,
996
			message: output
997
		});
998
	},
999

1000
	url: function( params ) {
1001
		params = extend( extend( {}, QUnit.urlParams ), params );
1002
		var key,
1003
			querystring = "?";
1004

1005
		for ( key in params ) {
1006
			if ( hasOwn.call( params, key ) ) {
1007
				querystring += encodeURIComponent( key ) + "=" +
1008
					encodeURIComponent( params[ key ] ) + "&";
1009
			}
1010
		}
1011
		return window.location.protocol + "//" + window.location.host +
1012
			window.location.pathname + querystring.slice( 0, -1 );
1013
	},
1014

1015
	extend: extend,
1016
	id: id,
1017
	addEvent: addEvent,
1018
	addClass: addClass,
1019
	hasClass: hasClass,
1020
	removeClass: removeClass
1021
	// load, equiv, jsDump, diff: Attached later
1022
});
1023

1024
/**
1025
 * @deprecated: Created for backwards compatibility with test runner that set the hook function
1026
 * into QUnit.{hook}, instead of invoking it and passing the hook function.
1027
 * QUnit.constructor is set to the empty F() above so that we can add to it's prototype here.
1028
 * Doing this allows us to tell if the following methods have been overwritten on the actual
1029
 * QUnit object.
1030
 */
1031
extend( QUnit.constructor.prototype, {
1032

1033
	// Logging callbacks; all receive a single argument with the listed properties
1034
	// run test/logs.html for any related changes
1035
	begin: registerLoggingCallback( "begin" ),
1036

1037
	// done: { failed, passed, total, runtime }
1038
	done: registerLoggingCallback( "done" ),
1039

1040
	// log: { result, actual, expected, message }
1041
	log: registerLoggingCallback( "log" ),
1042

1043
	// testStart: { name }
1044
	testStart: registerLoggingCallback( "testStart" ),
1045

1046
	// testDone: { name, failed, passed, total, duration }
1047
	testDone: registerLoggingCallback( "testDone" ),
1048

1049
	// moduleStart: { name }
1050
	moduleStart: registerLoggingCallback( "moduleStart" ),
1051

1052
	// moduleDone: { name, failed, passed, total }
1053
	moduleDone: registerLoggingCallback( "moduleDone" )
1054
});
1055

1056
if ( typeof document === "undefined" || document.readyState === "complete" ) {
1057
	config.autorun = true;
1058
}
1059

1060
QUnit.load = function() {
1061
	runLoggingCallbacks( "begin", QUnit, {} );
1062

1063
	// Initialize the config, saving the execution queue
1064
	var banner, filter, i, label, len, main, ol, toolbar, userAgent, val,
1065
		urlConfigCheckboxesContainer, urlConfigCheckboxes, moduleFilter,
1066
		numModules = 0,
1067
		moduleNames = [],
1068
		moduleFilterHtml = "",
1069
		urlConfigHtml = "",
1070
		oldconfig = extend( {}, config );
1071

1072
	QUnit.init();
1073
	extend(config, oldconfig);
1074

1075
	config.blocking = false;
1076

1077
	len = config.urlConfig.length;
1078

1079
	for ( i = 0; i < len; i++ ) {
1080
		val = config.urlConfig[i];
1081
		if ( typeof val === "string" ) {
1082
			val = {
1083
				id: val,
1084
				label: val,
1085
				tooltip: "[no tooltip available]"
1086
			};
1087
		}
1088
		config[ val.id ] = QUnit.urlParams[ val.id ];
1089
		urlConfigHtml += "<input id='qunit-urlconfig-" + escapeText( val.id ) +
1090
			"' name='" + escapeText( val.id ) +
1091
			"' type='checkbox'" + ( config[ val.id ] ? " checked='checked'" : "" ) +
1092
			" title='" + escapeText( val.tooltip ) +
1093
			"'><label for='qunit-urlconfig-" + escapeText( val.id ) +
1094
			"' title='" + escapeText( val.tooltip ) + "'>" + val.label + "</label>";
1095
	}
1096
	for ( i in config.modules ) {
1097
		if ( config.modules.hasOwnProperty( i ) ) {
1098
			moduleNames.push(i);
1099
		}
1100
	}
1101
	numModules = moduleNames.length;
1102
	moduleNames.sort( function( a, b ) {
1103
		return a.localeCompare( b );
1104
	});
1105
	moduleFilterHtml += "<label for='qunit-modulefilter'>Module: </label><select id='qunit-modulefilter' name='modulefilter'><option value='' " +
1106
		( config.module === undefined  ? "selected='selected'" : "" ) +
1107
		">< All Modules ></option>";
1108

1109

1110
	for ( i = 0; i < numModules; i++) {
1111
			moduleFilterHtml += "<option value='" + escapeText( encodeURIComponent(moduleNames[i]) ) + "' " +
1112
				( config.module === moduleNames[i] ? "selected='selected'" : "" ) +
1113
				">" + escapeText(moduleNames[i]) + "</option>";
1114
	}
1115
	moduleFilterHtml += "</select>";
1116

1117
	// `userAgent` initialized at top of scope
1118
	userAgent = id( "qunit-userAgent" );
1119
	if ( userAgent ) {
1120
		userAgent.innerHTML = navigator.userAgent;
1121
	}
1122

1123
	// `banner` initialized at top of scope
1124
	banner = id( "qunit-header" );
1125
	if ( banner ) {
1126
		banner.innerHTML = "<a href='" + QUnit.url({ filter: undefined, module: undefined, testNumber: undefined }) + "'>" + banner.innerHTML + "</a> ";
1127
	}
1128

1129
	// `toolbar` initialized at top of scope
1130
	toolbar = id( "qunit-testrunner-toolbar" );
1131
	if ( toolbar ) {
1132
		// `filter` initialized at top of scope
1133
		filter = document.createElement( "input" );
1134
		filter.type = "checkbox";
1135
		filter.id = "qunit-filter-pass";
1136

1137
		addEvent( filter, "click", function() {
1138
			var tmp,
1139
				ol = document.getElementById( "qunit-tests" );
1140

1141
			if ( filter.checked ) {
1142
				ol.className = ol.className + " hidepass";
1143
			} else {
1144
				tmp = " " + ol.className.replace( /[\n\t\r]/g, " " ) + " ";
1145
				ol.className = tmp.replace( / hidepass /, " " );
1146
			}
1147
			if ( defined.sessionStorage ) {
1148
				if (filter.checked) {
1149
					sessionStorage.setItem( "qunit-filter-passed-tests", "true" );
1150
				} else {
1151
					sessionStorage.removeItem( "qunit-filter-passed-tests" );
1152
				}
1153
			}
1154
		});
1155

1156
		if ( config.hidepassed || defined.sessionStorage && sessionStorage.getItem( "qunit-filter-passed-tests" ) ) {
1157
			filter.checked = true;
1158
			// `ol` initialized at top of scope
1159
			ol = document.getElementById( "qunit-tests" );
1160
			ol.className = ol.className + " hidepass";
1161
		}
1162
		toolbar.appendChild( filter );
1163

1164
		// `label` initialized at top of scope
1165
		label = document.createElement( "label" );
1166
		label.setAttribute( "for", "qunit-filter-pass" );
1167
		label.setAttribute( "title", "Only show tests and assertions that fail. Stored in sessionStorage." );
1168
		label.innerHTML = "Hide passed tests";
1169
		toolbar.appendChild( label );
1170

1171
		urlConfigCheckboxesContainer = document.createElement("span");
1172
		urlConfigCheckboxesContainer.innerHTML = urlConfigHtml;
1173
		urlConfigCheckboxes = urlConfigCheckboxesContainer.getElementsByTagName("input");
1174
		// For oldIE support:
1175
		// * Add handlers to the individual elements instead of the container
1176
		// * Use "click" instead of "change"
1177
		// * Fallback from event.target to event.srcElement
1178
		addEvents( urlConfigCheckboxes, "click", function( event ) {
1179
			var params = {},
1180
				target = event.target || event.srcElement;
1181
			params[ target.name ] = target.checked ? true : undefined;
1182
			window.location = QUnit.url( params );
1183
		});
1184
		toolbar.appendChild( urlConfigCheckboxesContainer );
1185

1186
		if (numModules > 1) {
1187
			moduleFilter = document.createElement( "span" );
1188
			moduleFilter.setAttribute( "id", "qunit-modulefilter-container" );
1189
			moduleFilter.innerHTML = moduleFilterHtml;
1190
			addEvent( moduleFilter.lastChild, "change", function() {
1191
				var selectBox = moduleFilter.getElementsByTagName("select")[0],
1192
					selectedModule = decodeURIComponent(selectBox.options[selectBox.selectedIndex].value);
1193

1194
				window.location = QUnit.url({
1195
					module: ( selectedModule === "" ) ? undefined : selectedModule,
1196
					// Remove any existing filters
1197
					filter: undefined,
1198
					testNumber: undefined
1199
				});
1200
			});
1201
			toolbar.appendChild(moduleFilter);
1202
		}
1203
	}
1204

1205
	// `main` initialized at top of scope
1206
	main = id( "qunit-fixture" );
1207
	if ( main ) {
1208
		config.fixture = main.innerHTML;
1209
	}
1210

1211
	if ( config.autostart ) {
1212
		QUnit.start();
1213
	}
1214
};
1215

1216
addEvent( window, "load", QUnit.load );
1217

1218
// `onErrorFnPrev` initialized at top of scope
1219
// Preserve other handlers
1220
onErrorFnPrev = window.onerror;
1221

1222
// Cover uncaught exceptions
1223
// Returning true will suppress the default browser handler,
1224
// returning false will let it run.
1225
window.onerror = function ( error, filePath, linerNr ) {
1226
	var ret = false;
1227
	if ( onErrorFnPrev ) {
1228
		ret = onErrorFnPrev( error, filePath, linerNr );
1229
	}
1230

1231
	// Treat return value as window.onerror itself does,
1232
	// Only do our handling if not suppressed.
1233
	if ( ret !== true ) {
1234
		if ( QUnit.config.current ) {
1235
			if ( QUnit.config.current.ignoreGlobalErrors ) {
1236
				return true;
1237
			}
1238
			QUnit.pushFailure( error, filePath + ":" + linerNr );
1239
		} else {
1240
			QUnit.test( "global failure", extend( function() {
1241
				QUnit.pushFailure( error, filePath + ":" + linerNr );
1242
			}, { validTest: validTest } ) );
1243
		}
1244
		return false;
1245
	}
1246

1247
	return ret;
1248
};
1249

1250
function done() {
1251
	config.autorun = true;
1252

1253
	// Log the last module results
1254
	if ( config.currentModule ) {
1255
		runLoggingCallbacks( "moduleDone", QUnit, {
1256
			name: config.currentModule,
1257
			failed: config.moduleStats.bad,
1258
			passed: config.moduleStats.all - config.moduleStats.bad,
1259
			total: config.moduleStats.all
1260
		});
1261
	}
1262
	delete config.previousModule;
1263

1264
	var i, key,
1265
		banner = id( "qunit-banner" ),
1266
		tests = id( "qunit-tests" ),
1267
		runtime = +new Date() - config.started,
1268
		passed = config.stats.all - config.stats.bad,
1269
		html = [
1270
			"Tests completed in ",
1271
			runtime,
1272
			" milliseconds.<br/>",
1273
			"<span class='passed'>",
1274
			passed,
1275
			"</span> assertions of <span class='total'>",
1276
			config.stats.all,
1277
			"</span> passed, <span class='failed'>",
1278
			config.stats.bad,
1279
			"</span> failed."
1280
		].join( "" );
1281

1282
	if ( banner ) {
1283
		banner.className = ( config.stats.bad ? "qunit-fail" : "qunit-pass" );
1284
	}
1285

1286
	if ( tests ) {
1287
		id( "qunit-testresult" ).innerHTML = html;
1288
	}
1289

1290
	if ( config.altertitle && typeof document !== "undefined" && document.title ) {
1291
		// show ✖ for good, ✔ for bad suite result in title
1292
		// use escape sequences in case file gets loaded with non-utf-8-charset
1293
		document.title = [
1294
			( config.stats.bad ? "\u2716" : "\u2714" ),
1295
			document.title.replace( /^[\u2714\u2716] /i, "" )
1296
		].join( " " );
1297
	}
1298

1299
	// clear own sessionStorage items if all tests passed
1300
	if ( config.reorder && defined.sessionStorage && config.stats.bad === 0 ) {
1301
		// `key` & `i` initialized at top of scope
1302
		for ( i = 0; i < sessionStorage.length; i++ ) {
1303
			key = sessionStorage.key( i++ );
1304
			if ( key.indexOf( "qunit-test-" ) === 0 ) {
1305
				sessionStorage.removeItem( key );
1306
			}
1307
		}
1308
	}
1309

1310
	// scroll back to top to show results
1311
	if ( window.scrollTo ) {
1312
		window.scrollTo(0, 0);
1313
	}
1314

1315
	runLoggingCallbacks( "done", QUnit, {
1316
		failed: config.stats.bad,
1317
		passed: passed,
1318
		total: config.stats.all,
1319
		runtime: runtime
1320
	});
1321
}
1322

1323
/** @return Boolean: true if this test should be ran */
1324
function validTest( test ) {
1325
	var include,
1326
		filter = config.filter && config.filter.toLowerCase(),
1327
		module = config.module && config.module.toLowerCase(),
1328
		fullName = (test.module + ": " + test.testName).toLowerCase();
1329

1330
	// Internally-generated tests are always valid
1331
	if ( test.callback && test.callback.validTest === validTest ) {
1332
		delete test.callback.validTest;
1333
		return true;
1334
	}
1335

1336
	if ( config.testNumber ) {
1337
		return test.testNumber === config.testNumber;
1338
	}
1339

1340
	if ( module && ( !test.module || test.module.toLowerCase() !== module ) ) {
1341
		return false;
1342
	}
1343

1344
	if ( !filter ) {
1345
		return true;
1346
	}
1347

1348
	include = filter.charAt( 0 ) !== "!";
1349
	if ( !include ) {
1350
		filter = filter.slice( 1 );
1351
	}
1352

1353
	// If the filter matches, we need to honour include
1354
	if ( fullName.indexOf( filter ) !== -1 ) {
1355
		return include;
1356
	}
1357

1358
	// Otherwise, do the opposite
1359
	return !include;
1360
}
1361

1362
// so far supports only Firefox, Chrome and Opera (buggy), Safari (for real exceptions)
1363
// Later Safari and IE10 are supposed to support error.stack as well
1364
// See also https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error/Stack
1365
function extractStacktrace( e, offset ) {
1366
	offset = offset === undefined ? 3 : offset;
1367

1368
	var stack, include, i;
1369

1370
	if ( e.stacktrace ) {
1371
		// Opera
1372
		return e.stacktrace.split( "\n" )[ offset + 3 ];
1373
	} else if ( e.stack ) {
1374
		// Firefox, Chrome
1375
		stack = e.stack.split( "\n" );
1376
		if (/^error$/i.test( stack[0] ) ) {
1377
			stack.shift();
1378
		}
1379
		if ( fileName ) {
1380
			include = [];
1381
			for ( i = offset; i < stack.length; i++ ) {
1382
				if ( stack[ i ].indexOf( fileName ) !== -1 ) {
1383
					break;
1384
				}
1385
				include.push( stack[ i ] );
1386
			}
1387
			if ( include.length ) {
1388
				return include.join( "\n" );
1389
			}
1390
		}
1391
		return stack[ offset ];
1392
	} else if ( e.sourceURL ) {
1393
		// Safari, PhantomJS
1394
		// hopefully one day Safari provides actual stacktraces
1395
		// exclude useless self-reference for generated Error objects
1396
		if ( /qunit.js$/.test( e.sourceURL ) ) {
1397
			return;
1398
		}
1399
		// for actual exceptions, this is useful
1400
		return e.sourceURL + ":" + e.line;
1401
	}
1402
}
1403
function sourceFromStacktrace( offset ) {
1404
	try {
1405
		throw new Error();
1406
	} catch ( e ) {
1407
		return extractStacktrace( e, offset );
1408
	}
1409
}
1410

1411
/**
1412
 * Escape text for attribute or text content.
1413
 */
1414
function escapeText( s ) {
1415
	if ( !s ) {
1416
		return "";
1417
	}
1418
	s = s + "";
1419
	// Both single quotes and double quotes (for attributes)
1420
	return s.replace( /['"<>&]/g, function( s ) {
1421
		switch( s ) {
1422
			case "'":
1423
				return "&#039;";
1424
			case "\"":
1425
				return "&quot;";
1426
			case "<":
1427
				return "&lt;";
1428
			case ">":
1429
				return "&gt;";
1430
			case "&":
1431
				return "&amp;";
1432
		}
1433
	});
1434
}
1435

1436
function synchronize( callback, last ) {
1437
	config.queue.push( callback );
1438

1439
	if ( config.autorun && !config.blocking ) {
1440
		process( last );
1441
	}
1442
}
1443

1444
function process( last ) {
1445
	function next() {
1446
		process( last );
1447
	}
1448
	var start = new Date().getTime();
1449
	config.depth = config.depth ? config.depth + 1 : 1;
1450

1451
	while ( config.queue.length && !config.blocking ) {
1452
		if ( !defined.setTimeout || config.updateRate <= 0 || ( ( new Date().getTime() - start ) < config.updateRate ) ) {
1453
			config.queue.shift()();
1454
		} else {
1455
			setTimeout( next, 13 );
1456
			break;
1457
		}
1458
	}
1459
	config.depth--;
1460
	if ( last && !config.blocking && !config.queue.length && config.depth === 0 ) {
1461
		done();
1462
	}
1463
}
1464

1465
function saveGlobal() {
1466
	config.pollution = [];
1467

1468
	if ( config.noglobals ) {
1469
		for ( var key in window ) {
1470
			if ( hasOwn.call( window, key ) ) {
1471
				// in Opera sometimes DOM element ids show up here, ignore them
1472
				if ( /^qunit-test-output/.test( key ) ) {
1473
					continue;
1474
				}
1475
				config.pollution.push( key );
1476
			}
1477
		}
1478
	}
1479
}
1480

1481
function checkPollution() {
1482
	var newGlobals,
1483
		deletedGlobals,
1484
		old = config.pollution;
1485

1486
	saveGlobal();
1487

1488
	newGlobals = diff( config.pollution, old );
1489
	if ( newGlobals.length > 0 ) {
1490
		QUnit.pushFailure( "Introduced global variable(s): " + newGlobals.join(", ") );
1491
	}
1492

1493
	deletedGlobals = diff( old, config.pollution );
1494
	if ( deletedGlobals.length > 0 ) {
1495
		QUnit.pushFailure( "Deleted global variable(s): " + deletedGlobals.join(", ") );
1496
	}
1497
}
1498

1499
// returns a new Array with the elements that are in a but not in b
1500
function diff( a, b ) {
1501
	var i, j,
1502
		result = a.slice();
1503

1504
	for ( i = 0; i < result.length; i++ ) {
1505
		for ( j = 0; j < b.length; j++ ) {
1506
			if ( result[i] === b[j] ) {
1507
				result.splice( i, 1 );
1508
				i--;
1509
				break;
1510
			}
1511
		}
1512
	}
1513
	return result;
1514
}
1515

1516
function extend( a, b ) {
1517
	for ( var prop in b ) {
1518
		if ( hasOwn.call( b, prop ) ) {
1519
			// Avoid "Member not found" error in IE8 caused by messing with window.constructor
1520
			if ( !( prop === "constructor" && a === window ) ) {
1521
				if ( b[ prop ] === undefined ) {
1522
					delete a[ prop ];
1523
				} else {
1524
					a[ prop ] = b[ prop ];
1525
				}
1526
			}
1527
		}
1528
	}
1529

1530
	return a;
1531
}
1532

1533
/**
1534
 * @param {HTMLElement} elem
1535
 * @param {string} type
1536
 * @param {Function} fn
1537
 */
1538
function addEvent( elem, type, fn ) {
1539
	// Standards-based browsers
1540
	if ( elem.addEventListener ) {
1541
		elem.addEventListener( type, fn, false );
1542
	// IE
1543
	} else {
1544
		elem.attachEvent( "on" + type, fn );
1545
	}
1546
}
1547

1548
/**
1549
 * @param {Array|NodeList} elems
1550
 * @param {string} type
1551
 * @param {Function} fn
1552
 */
1553
function addEvents( elems, type, fn ) {
1554
	var i = elems.length;
1555
	while ( i-- ) {
1556
		addEvent( elems[i], type, fn );
1557
	}
1558
}
1559

1560
function hasClass( elem, name ) {
1561
	return (" " + elem.className + " ").indexOf(" " + name + " ") > -1;
1562
}
1563

1564
function addClass( elem, name ) {
1565
	if ( !hasClass( elem, name ) ) {
1566
		elem.className += (elem.className ? " " : "") + name;
1567
	}
1568
}
1569

1570
function removeClass( elem, name ) {
1571
	var set = " " + elem.className + " ";
1572
	// Class name may appear multiple times
1573
	while ( set.indexOf(" " + name + " ") > -1 ) {
1574
		set = set.replace(" " + name + " " , " ");
1575
	}
1576
	// If possible, trim it for prettiness, but not necessarily
1577
	elem.className = typeof set.trim === "function" ? set.trim() : set.replace(/^\s+|\s+$/g, "");
1578
}
1579

1580
function id( name ) {
1581
	return !!( typeof document !== "undefined" && document && document.getElementById ) &&
1582
		document.getElementById( name );
1583
}
1584

1585
function registerLoggingCallback( key ) {
1586
	return function( callback ) {
1587
		config[key].push( callback );
1588
	};
1589
}
1590

1591
// Supports deprecated method of completely overwriting logging callbacks
1592
function runLoggingCallbacks( key, scope, args ) {
1593
	var i, callbacks;
1594
	if ( QUnit.hasOwnProperty( key ) ) {
1595
		QUnit[ key ].call(scope, args );
1596
	} else {
1597
		callbacks = config[ key ];
1598
		for ( i = 0; i < callbacks.length; i++ ) {
1599
			callbacks[ i ].call( scope, args );
1600
		}
1601
	}
1602
}
1603

1604
// Test for equality any JavaScript type.
1605
// Author: Philippe Rathé <[email protected]>
1606
QUnit.equiv = (function() {
1607

1608
	// Call the o related callback with the given arguments.
1609
	function bindCallbacks( o, callbacks, args ) {
1610
		var prop = QUnit.objectType( o );
1611
		if ( prop ) {
1612
			if ( QUnit.objectType( callbacks[ prop ] ) === "function" ) {
1613
				return callbacks[ prop ].apply( callbacks, args );
1614
			} else {
1615
				return callbacks[ prop ]; // or undefined
1616
			}
1617
		}
1618
	}
1619

1620
	// the real equiv function
1621
	var innerEquiv,
1622
		// stack to decide between skip/abort functions
1623
		callers = [],
1624
		// stack to avoiding loops from circular referencing
1625
		parents = [],
1626
		parentsB = [],
1627

1628
		getProto = Object.getPrototypeOf || function ( obj ) {
1629
			/*jshint camelcase:false */
1630
			return obj.__proto__;
1631
		},
1632
		callbacks = (function () {
1633

1634
			// for string, boolean, number and null
1635
			function useStrictEquality( b, a ) {
1636
				/*jshint eqeqeq:false */
1637
				if ( b instanceof a.constructor || a instanceof b.constructor ) {
1638
					// to catch short annotation VS 'new' annotation of a
1639
					// declaration
1640
					// e.g. var i = 1;
1641
					// var j = new Number(1);
1642
					return a == b;
1643
				} else {
1644
					return a === b;
1645
				}
1646
			}
1647

1648
			return {
1649
				"string": useStrictEquality,
1650
				"boolean": useStrictEquality,
1651
				"number": useStrictEquality,
1652
				"null": useStrictEquality,
1653
				"undefined": useStrictEquality,
1654

1655
				"nan": function( b ) {
1656
					return isNaN( b );
1657
				},
1658

1659
				"date": function( b, a ) {
1660
					return QUnit.objectType( b ) === "date" && a.valueOf() === b.valueOf();
1661
				},
1662

1663
				"regexp": function( b, a ) {
1664
					return QUnit.objectType( b ) === "regexp" &&
1665
						// the regex itself
1666
						a.source === b.source &&
1667
						// and its modifiers
1668
						a.global === b.global &&
1669
						// (gmi) ...
1670
						a.ignoreCase === b.ignoreCase &&
1671
						a.multiline === b.multiline &&
1672
						a.sticky === b.sticky;
1673
				},
1674

1675
				// - skip when the property is a method of an instance (OOP)
1676
				// - abort otherwise,
1677
				// initial === would have catch identical references anyway
1678
				"function": function() {
1679
					var caller = callers[callers.length - 1];
1680
					return caller !== Object && typeof caller !== "undefined";
1681
				},
1682

1683
				"array": function( b, a ) {
1684
					var i, j, len, loop, aCircular, bCircular;
1685

1686
					// b could be an object literal here
1687
					if ( QUnit.objectType( b ) !== "array" ) {
1688
						return false;
1689
					}
1690

1691
					len = a.length;
1692
					if ( len !== b.length ) {
1693
						// safe and faster
1694
						return false;
1695
					}
1696

1697
					// track reference to avoid circular references
1698
					parents.push( a );
1699
					parentsB.push( b );
1700
					for ( i = 0; i < len; i++ ) {
1701
						loop = false;
1702
						for ( j = 0; j < parents.length; j++ ) {
1703
							aCircular = parents[j] === a[i];
1704
							bCircular = parentsB[j] === b[i];
1705
							if ( aCircular || bCircular ) {
1706
								if ( a[i] === b[i] || aCircular && bCircular ) {
1707
									loop = true;
1708
								} else {
1709
									parents.pop();
1710
									parentsB.pop();
1711
									return false;
1712
								}
1713
							}
1714
						}
1715
						if ( !loop && !innerEquiv(a[i], b[i]) ) {
1716
							parents.pop();
1717
							parentsB.pop();
1718
							return false;
1719
						}
1720
					}
1721
					parents.pop();
1722
					parentsB.pop();
1723
					return true;
1724
				},
1725

1726
				"object": function( b, a ) {
1727
					/*jshint forin:false */
1728
					var i, j, loop, aCircular, bCircular,
1729
						// Default to true
1730
						eq = true,
1731
						aProperties = [],
1732
						bProperties = [];
1733

1734
					// comparing constructors is more strict than using
1735
					// instanceof
1736
					if ( a.constructor !== b.constructor ) {
1737
						// Allow objects with no prototype to be equivalent to
1738
						// objects with Object as their constructor.
1739
						if ( !(( getProto(a) === null && getProto(b) === Object.prototype ) ||
1740
							( getProto(b) === null && getProto(a) === Object.prototype ) ) ) {
1741
								return false;
1742
						}
1743
					}
1744

1745
					// stack constructor before traversing properties
1746
					callers.push( a.constructor );
1747

1748
					// track reference to avoid circular references
1749
					parents.push( a );
1750
					parentsB.push( b );
1751

1752
					// be strict: don't ensure hasOwnProperty and go deep
1753
					for ( i in a ) {
1754
						loop = false;
1755
						for ( j = 0; j < parents.length; j++ ) {
1756
							aCircular = parents[j] === a[i];
1757
							bCircular = parentsB[j] === b[i];
1758
							if ( aCircular || bCircular ) {
1759
								if ( a[i] === b[i] || aCircular && bCircular ) {
1760
									loop = true;
1761
								} else {
1762
									eq = false;
1763
									break;
1764
								}
1765
							}
1766
						}
1767
						aProperties.push(i);
1768
						if ( !loop && !innerEquiv(a[i], b[i]) ) {
1769
							eq = false;
1770
							break;
1771
						}
1772
					}
1773

1774
					parents.pop();
1775
					parentsB.pop();
1776
					callers.pop(); // unstack, we are done
1777

1778
					for ( i in b ) {
1779
						bProperties.push( i ); // collect b's properties
1780
					}
1781

1782
					// Ensures identical properties name
1783
					return eq && innerEquiv( aProperties.sort(), bProperties.sort() );
1784
				}
1785
			};
1786
		}());
1787

1788
	innerEquiv = function() { // can take multiple arguments
1789
		var args = [].slice.apply( arguments );
1790
		if ( args.length < 2 ) {
1791
			return true; // end transition
1792
		}
1793

1794
		return (function( a, b ) {
1795
			if ( a === b ) {
1796
				return true; // catch the most you can
1797
			} else if ( a === null || b === null || typeof a === "undefined" ||
1798
					typeof b === "undefined" ||
1799
					QUnit.objectType(a) !== QUnit.objectType(b) ) {
1800
				return false; // don't lose time with error prone cases
1801
			} else {
1802
				return bindCallbacks(a, callbacks, [ b, a ]);
1803
			}
1804

1805
			// apply transition with (1..n) arguments
1806
		}( args[0], args[1] ) && innerEquiv.apply( this, args.splice(1, args.length - 1 )) );
1807
	};
1808

1809
	return innerEquiv;
1810
}());
1811

1812
/**
1813
 * jsDump Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com |
1814
 * http://flesler.blogspot.com Licensed under BSD
1815
 * (http://www.opensource.org/licenses/bsd-license.php) Date: 5/15/2008
1816
 *
1817
 * @projectDescription Advanced and extensible data dumping for Javascript.
1818
 * @version 1.0.0
1819
 * @author Ariel Flesler
1820
 * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html}
1821
 */
1822
QUnit.jsDump = (function() {
1823
	function quote( str ) {
1824
		return "\"" + str.toString().replace( /"/g, "\\\"" ) + "\"";
1825
	}
1826
	function literal( o ) {
1827
		return o + "";
1828
	}
1829
	function join( pre, arr, post ) {
1830
		var s = jsDump.separator(),
1831
			base = jsDump.indent(),
1832
			inner = jsDump.indent(1);
1833
		if ( arr.join ) {
1834
			arr = arr.join( "," + s + inner );
1835
		}
1836
		if ( !arr ) {
1837
			return pre + post;
1838
		}
1839
		return [ pre, inner + arr, base + post ].join(s);
1840
	}
1841
	function array( arr, stack ) {
1842
		var i = arr.length, ret = new Array(i);
1843
		this.up();
1844
		while ( i-- ) {
1845
			ret[i] = this.parse( arr[i] , undefined , stack);
1846
		}
1847
		this.down();
1848
		return join( "[", ret, "]" );
1849
	}
1850

1851
	var reName = /^function (\w+)/,
1852
		jsDump = {
1853
			// type is used mostly internally, you can fix a (custom)type in advance
1854
			parse: function( obj, type, stack ) {
1855
				stack = stack || [ ];
1856
				var inStack, res,
1857
					parser = this.parsers[ type || this.typeOf(obj) ];
1858

1859
				type = typeof parser;
1860
				inStack = inArray( obj, stack );
1861

1862
				if ( inStack !== -1 ) {
1863
					return "recursion(" + (inStack - stack.length) + ")";
1864
				}
1865
				if ( type === "function" )  {
1866
					stack.push( obj );
1867
					res = parser.call( this, obj, stack );
1868
					stack.pop();
1869
					return res;
1870
				}
1871
				return ( type === "string" ) ? parser : this.parsers.error;
1872
			},
1873
			typeOf: function( obj ) {
1874
				var type;
1875
				if ( obj === null ) {
1876
					type = "null";
1877
				} else if ( typeof obj === "undefined" ) {
1878
					type = "undefined";
1879
				} else if ( QUnit.is( "regexp", obj) ) {
1880
					type = "regexp";
1881
				} else if ( QUnit.is( "date", obj) ) {
1882
					type = "date";
1883
				} else if ( QUnit.is( "function", obj) ) {
1884
					type = "function";
1885
				} else if ( typeof obj.setInterval !== undefined && typeof obj.document !== "undefined" && typeof obj.nodeType === "undefined" ) {
1886
					type = "window";
1887
				} else if ( obj.nodeType === 9 ) {
1888
					type = "document";
1889
				} else if ( obj.nodeType ) {
1890
					type = "node";
1891
				} else if (
1892
					// native arrays
1893
					toString.call( obj ) === "[object Array]" ||
1894
					// NodeList objects
1895
					( typeof obj.length === "number" && typeof obj.item !== "undefined" && ( obj.length ? obj.item(0) === obj[0] : ( obj.item( 0 ) === null && typeof obj[0] === "undefined" ) ) )
1896
				) {
1897
					type = "array";
1898
				} else if ( obj.constructor === Error.prototype.constructor ) {
1899
					type = "error";
1900
				} else {
1901
					type = typeof obj;
1902
				}
1903
				return type;
1904
			},
1905
			separator: function() {
1906
				return this.multiline ?	this.HTML ? "<br />" : "\n" : this.HTML ? "&nbsp;" : " ";
1907
			},
1908
			// extra can be a number, shortcut for increasing-calling-decreasing
1909
			indent: function( extra ) {
1910
				if ( !this.multiline ) {
1911
					return "";
1912
				}
1913
				var chr = this.indentChar;
1914
				if ( this.HTML ) {
1915
					chr = chr.replace( /\t/g, "   " ).replace( / /g, "&nbsp;" );
1916
				}
1917
				return new Array( this.depth + ( extra || 0 ) ).join(chr);
1918
			},
1919
			up: function( a ) {
1920
				this.depth += a || 1;
1921
			},
1922
			down: function( a ) {
1923
				this.depth -= a || 1;
1924
			},
1925
			setParser: function( name, parser ) {
1926
				this.parsers[name] = parser;
1927
			},
1928
			// The next 3 are exposed so you can use them
1929
			quote: quote,
1930
			literal: literal,
1931
			join: join,
1932
			//
1933
			depth: 1,
1934
			// This is the list of parsers, to modify them, use jsDump.setParser
1935
			parsers: {
1936
				window: "[Window]",
1937
				document: "[Document]",
1938
				error: function(error) {
1939
					return "Error(\"" + error.message + "\")";
1940
				},
1941
				unknown: "[Unknown]",
1942
				"null": "null",
1943
				"undefined": "undefined",
1944
				"function": function( fn ) {
1945
					var ret = "function",
1946
						// functions never have name in IE
1947
						name = "name" in fn ? fn.name : (reName.exec(fn) || [])[1];
1948

1949
					if ( name ) {
1950
						ret += " " + name;
1951
					}
1952
					ret += "( ";
1953

1954
					ret = [ ret, QUnit.jsDump.parse( fn, "functionArgs" ), "){" ].join( "" );
1955
					return join( ret, QUnit.jsDump.parse(fn,"functionCode" ), "}" );
1956
				},
1957
				array: array,
1958
				nodelist: array,
1959
				"arguments": array,
1960
				object: function( map, stack ) {
1961
					/*jshint forin:false */
1962
					var ret = [ ], keys, key, val, i;
1963
					QUnit.jsDump.up();
1964
					keys = [];
1965
					for ( key in map ) {
1966
						keys.push( key );
1967
					}
1968
					keys.sort();
1969
					for ( i = 0; i < keys.length; i++ ) {
1970
						key = keys[ i ];
1971
						val = map[ key ];
1972
						ret.push( QUnit.jsDump.parse( key, "key" ) + ": " + QUnit.jsDump.parse( val, undefined, stack ) );
1973
					}
1974
					QUnit.jsDump.down();
1975
					return join( "{", ret, "}" );
1976
				},
1977
				node: function( node ) {
1978
					var len, i, val,
1979
						open = QUnit.jsDump.HTML ? "&lt;" : "<",
1980
						close = QUnit.jsDump.HTML ? "&gt;" : ">",
1981
						tag = node.nodeName.toLowerCase(),
1982
						ret = open + tag,
1983
						attrs = node.attributes;
1984

1985
					if ( attrs ) {
1986
						for ( i = 0, len = attrs.length; i < len; i++ ) {
1987
							val = attrs[i].nodeValue;
1988
							// IE6 includes all attributes in .attributes, even ones not explicitly set.
1989
							// Those have values like undefined, null, 0, false, "" or "inherit".
1990
							if ( val && val !== "inherit" ) {
1991
								ret += " " + attrs[i].nodeName + "=" + QUnit.jsDump.parse( val, "attribute" );
1992
							}
1993
						}
1994
					}
1995
					ret += close;
1996

1997
					// Show content of TextNode or CDATASection
1998
					if ( node.nodeType === 3 || node.nodeType === 4 ) {
1999
						ret += node.nodeValue;
2000
					}
2001

2002
					return ret + open + "/" + tag + close;
2003
				},
2004
				// function calls it internally, it's the arguments part of the function
2005
				functionArgs: function( fn ) {
2006
					var args,
2007
						l = fn.length;
2008

2009
					if ( !l ) {
2010
						return "";
2011
					}
2012

2013
					args = new Array(l);
2014
					while ( l-- ) {
2015
						// 97 is 'a'
2016
						args[l] = String.fromCharCode(97+l);
2017
					}
2018
					return " " + args.join( ", " ) + " ";
2019
				},
2020
				// object calls it internally, the key part of an item in a map
2021
				key: quote,
2022
				// function calls it internally, it's the content of the function
2023
				functionCode: "[code]",
2024
				// node calls it internally, it's an html attribute value
2025
				attribute: quote,
2026
				string: quote,
2027
				date: quote,
2028
				regexp: literal,
2029
				number: literal,
2030
				"boolean": literal
2031
			},
2032
			// if true, entities are escaped ( <, >, \t, space and \n )
2033
			HTML: false,
2034
			// indentation unit
2035
			indentChar: "  ",
2036
			// if true, items in a collection, are separated by a \n, else just a space.
2037
			multiline: true
2038
		};
2039

2040
	return jsDump;
2041
}());
2042

2043
// from jquery.js
2044
function inArray( elem, array ) {
2045
	if ( array.indexOf ) {
2046
		return array.indexOf( elem );
2047
	}
2048

2049
	for ( var i = 0, length = array.length; i < length; i++ ) {
2050
		if ( array[ i ] === elem ) {
2051
			return i;
2052
		}
2053
	}
2054

2055
	return -1;
2056
}
2057

2058
/*
2059
 * Javascript Diff Algorithm
2060
 *  By John Resig (http://ejohn.org/)
2061
 *  Modified by Chu Alan "sprite"
2062
 *
2063
 * Released under the MIT license.
2064
 *
2065
 * More Info:
2066
 *  http://ejohn.org/projects/javascript-diff-algorithm/
2067
 *
2068
 * Usage: QUnit.diff(expected, actual)
2069
 *
2070
 * 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"
2071
 */
2072
QUnit.diff = (function() {
2073
	/*jshint eqeqeq:false, eqnull:true */
2074
	function diff( o, n ) {
2075
		var i,
2076
			ns = {},
2077
			os = {};
2078

2079
		for ( i = 0; i < n.length; i++ ) {
2080
			if ( !hasOwn.call( ns, n[i] ) ) {
2081
				ns[ n[i] ] = {
2082
					rows: [],
2083
					o: null
2084
				};
2085
			}
2086
			ns[ n[i] ].rows.push( i );
2087
		}
2088

2089
		for ( i = 0; i < o.length; i++ ) {
2090
			if ( !hasOwn.call( os, o[i] ) ) {
2091
				os[ o[i] ] = {
2092
					rows: [],
2093
					n: null
2094
				};
2095
			}
2096
			os[ o[i] ].rows.push( i );
2097
		}
2098

2099
		for ( i in ns ) {
2100
			if ( hasOwn.call( ns, i ) ) {
2101
				if ( ns[i].rows.length === 1 && hasOwn.call( os, i ) && os[i].rows.length === 1 ) {
2102
					n[ ns[i].rows[0] ] = {
2103
						text: n[ ns[i].rows[0] ],
2104
						row: os[i].rows[0]
2105
					};
2106
					o[ os[i].rows[0] ] = {
2107
						text: o[ os[i].rows[0] ],
2108
						row: ns[i].rows[0]
2109
					};
2110
				}
2111
			}
2112
		}
2113

2114
		for ( i = 0; i < n.length - 1; i++ ) {
2115
			if ( n[i].text != null && n[ i + 1 ].text == null && n[i].row + 1 < o.length && o[ n[i].row + 1 ].text == null &&
2116
						n[ i + 1 ] == o[ n[i].row + 1 ] ) {
2117

2118
				n[ i + 1 ] = {
2119
					text: n[ i + 1 ],
2120
					row: n[i].row + 1
2121
				};
2122
				o[ n[i].row + 1 ] = {
2123
					text: o[ n[i].row + 1 ],
2124
					row: i + 1
2125
				};
2126
			}
2127
		}
2128

2129
		for ( i = n.length - 1; i > 0; i-- ) {
2130
			if ( n[i].text != null && n[ i - 1 ].text == null && n[i].row > 0 && o[ n[i].row - 1 ].text == null &&
2131
						n[ i - 1 ] == o[ n[i].row - 1 ]) {
2132

2133
				n[ i - 1 ] = {
2134
					text: n[ i - 1 ],
2135
					row: n[i].row - 1
2136
				};
2137
				o[ n[i].row - 1 ] = {
2138
					text: o[ n[i].row - 1 ],
2139
					row: i - 1
2140
				};
2141
			}
2142
		}
2143

2144
		return {
2145
			o: o,
2146
			n: n
2147
		};
2148
	}
2149

2150
	return function( o, n ) {
2151
		o = o.replace( /\s+$/, "" );
2152
		n = n.replace( /\s+$/, "" );
2153

2154
		var i, pre,
2155
			str = "",
2156
			out = diff( o === "" ? [] : o.split(/\s+/), n === "" ? [] : n.split(/\s+/) ),
2157
			oSpace = o.match(/\s+/g),
2158
			nSpace = n.match(/\s+/g);
2159

2160
		if ( oSpace == null ) {
2161
			oSpace = [ " " ];
2162
		}
2163
		else {
2164
			oSpace.push( " " );
2165
		}
2166

2167
		if ( nSpace == null ) {
2168
			nSpace = [ " " ];
2169
		}
2170
		else {
2171
			nSpace.push( " " );
2172
		}
2173

2174
		if ( out.n.length === 0 ) {
2175
			for ( i = 0; i < out.o.length; i++ ) {
2176
				str += "<del>" + out.o[i] + oSpace[i] + "</del>";
2177
			}
2178
		}
2179
		else {
2180
			if ( out.n[0].text == null ) {
2181
				for ( n = 0; n < out.o.length && out.o[n].text == null; n++ ) {
2182
					str += "<del>" + out.o[n] + oSpace[n] + "</del>";
2183
				}
2184
			}
2185

2186
			for ( i = 0; i < out.n.length; i++ ) {
2187
				if (out.n[i].text == null) {
2188
					str += "<ins>" + out.n[i] + nSpace[i] + "</ins>";
2189
				}
2190
				else {
2191
					// `pre` initialized at top of scope
2192
					pre = "";
2193

2194
					for ( n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++ ) {
2195
						pre += "<del>" + out.o[n] + oSpace[n] + "</del>";
2196
					}
2197
					str += " " + out.n[i].text + nSpace[i] + pre;
2198
				}
2199
			}
2200
		}
2201

2202
		return str;
2203
	};
2204
}());
2205

2206
// for CommonJS environments, export everything
2207
if ( typeof exports !== "undefined" ) {
2208
	extend( exports, QUnit.constructor.prototype );
2209
}
2210

2211
// get at whatever the global object is, like window in browsers
2212
}( (function() {return this;}.call()) ));
2213