peteshow 0.7.5

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