Mercurial > hg > ismi-richfaces

comparison src/main/webapp/imageServer/resources/js/jquery-ui-1.10.4/external/qunit.js @ 7:764f47286679

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