Subversion Repositories Sites.obs-saisons.fr

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
40 aurelien 1
/*
2
 * QUnit - A JavaScript Unit Testing Framework
3
 *
4
 * http://docs.jquery.com/QUnit
5
 *
6
 * Copyright (c) 2009 John Resig, Jörn Zaefferer
7
 * Dual licensed under the MIT (MIT-LICENSE.txt)
8
 * and GPL (GPL-LICENSE.txt) licenses.
9
 */
10
 
11
(function(window) {
12
 
13
var QUnit = {
14
 
15
	// call on start of module test to prepend name to all tests
16
	module: function(name, testEnvironment) {
17
		config.currentModule = name;
18
 
19
		synchronize(function() {
20
			if ( config.currentModule ) {
21
				QUnit.moduleDone( config.currentModule, config.moduleStats.bad, config.moduleStats.all );
22
			}
23
 
24
			config.currentModule = name;
25
			config.moduleTestEnvironment = testEnvironment;
26
			config.moduleStats = { all: 0, bad: 0 };
27
 
28
			QUnit.moduleStart( name, testEnvironment );
29
		});
30
	},
31
 
32
	asyncTest: function(testName, expected, callback) {
33
		if ( arguments.length === 2 ) {
34
			callback = expected;
35
			expected = 0;
36
		}
37
 
38
		QUnit.test(testName, expected, callback, true);
39
	},
40
 
41
	test: function(testName, expected, callback, async) {
42
		var name = '<span class="test-name">' + testName + '</span>', testEnvironment, testEnvironmentArg;
43
 
44
		if ( arguments.length === 2 ) {
45
			callback = expected;
46
			expected = null;
47
		}
48
		// is 2nd argument a testEnvironment?
49
		if ( expected && typeof expected === 'object') {
50
			testEnvironmentArg =  expected;
51
			expected = null;
52
		}
53
 
54
		if ( config.currentModule ) {
55
			name = '<span class="module-name">' + config.currentModule + "</span>: " + name;
56
		}
57
 
58
		if ( !validTest(config.currentModule + ": " + testName) ) {
59
			return;
60
		}
61
 
62
		synchronize(function() {
63
 
64
			testEnvironment = extend({
65
				setup: function() {},
66
				teardown: function() {}
67
			}, config.moduleTestEnvironment);
68
			if (testEnvironmentArg) {
69
				extend(testEnvironment,testEnvironmentArg);
70
			}
71
 
72
			QUnit.testStart( testName, testEnvironment );
73
 
74
			// allow utility functions to access the current test environment
75
			QUnit.current_testEnvironment = testEnvironment;
76
 
77
			config.assertions = [];
78
			config.expected = expected;
79
 
80
			var tests = id("qunit-tests");
81
			if (tests) {
82
				var b = document.createElement("strong");
83
					b.innerHTML = "Running " + name;
84
				var li = document.createElement("li");
85
					li.appendChild( b );
86
					li.id = "current-test-output";
87
				tests.appendChild( li )
88
			}
89
 
90
			try {
91
				if ( !config.pollution ) {
92
					saveGlobal();
93
				}
94
 
95
				testEnvironment.setup.call(testEnvironment);
96
			} catch(e) {
97
				QUnit.ok( false, "Setup failed on " + name + ": " + e.message );
98
			}
99
	    });
100
 
101
	    synchronize(function() {
102
			if ( async ) {
103
				QUnit.stop();
104
			}
105
 
106
			try {
107
				callback.call(testEnvironment);
108
			} catch(e) {
109
				fail("Test " + name + " died, exception and test follows", e, callback);
110
				QUnit.ok( false, "Died on test #" + (config.assertions.length + 1) + ": " + e.message );
111
				// else next test will carry the responsibility
112
				saveGlobal();
113
 
114
				// Restart the tests if they're blocking
115
				if ( config.blocking ) {
116
					start();
117
				}
118
			}
119
		});
120
 
121
		synchronize(function() {
122
			try {
123
				checkPollution();
124
				testEnvironment.teardown.call(testEnvironment);
125
			} catch(e) {
126
				QUnit.ok( false, "Teardown failed on " + name + ": " + e.message );
127
			}
128
	    });
129
 
130
	    synchronize(function() {
131
			try {
132
				QUnit.reset();
133
			} catch(e) {
134
				fail("reset() failed, following Test " + name + ", exception and reset fn follows", e, reset);
135
			}
136
 
137
			if ( config.expected && config.expected != config.assertions.length ) {
138
				QUnit.ok( false, "Expected " + config.expected + " assertions, but " + config.assertions.length + " were run" );
139
			}
140
 
141
			var good = 0, bad = 0,
142
				tests = id("qunit-tests");
143
 
144
			config.stats.all += config.assertions.length;
145
			config.moduleStats.all += config.assertions.length;
146
 
147
			if ( tests ) {
148
				var ol  = document.createElement("ol");
149
 
150
				for ( var i = 0; i < config.assertions.length; i++ ) {
151
					var assertion = config.assertions[i];
152
 
153
					var li = document.createElement("li");
154
					li.className = assertion.result ? "pass" : "fail";
155
					li.innerHTML = assertion.message || "(no message)";
156
					ol.appendChild( li );
157
 
158
					if ( assertion.result ) {
159
						good++;
160
					} else {
161
						bad++;
162
						config.stats.bad++;
163
						config.moduleStats.bad++;
164
					}
165
				}
166
				if (bad == 0) {
167
					ol.style.display = "none";
168
				}
169
 
170
				var b = document.createElement("strong");
171
				b.innerHTML = name + " <b style='color:black;'>(<b class='fail'>" + bad + "</b>, <b class='pass'>" + good + "</b>, " + config.assertions.length + ")</b>";
172
 
173
				addEvent(b, "click", function() {
174
					var next = b.nextSibling, display = next.style.display;
175
					next.style.display = display === "none" ? "block" : "none";
176
				});
177
 
178
				addEvent(b, "dblclick", function(e) {
179
					var target = e && e.target ? e.target : window.event.srcElement;
180
					if ( target.nodeName.toLowerCase() == "span" || target.nodeName.toLowerCase() == "b" ) {
181
						target = target.parentNode;
182
					}
183
					if ( window.location && target.nodeName.toLowerCase() === "strong" ) {
184
						window.location.search = "?" + encodeURIComponent(getText([target]).replace(/\(.+\)$/, "").replace(/(^\s*|\s*$)/g, ""));
185
					}
186
				});
187
 
188
				var li = id("current-test-output");
189
				li.id = "";
190
				li.className = bad ? "fail" : "pass";
191
				li.removeChild( li.firstChild );
192
				li.appendChild( b );
193
				li.appendChild( ol );
194
 
195
				if ( bad ) {
196
					var toolbar = id("qunit-testrunner-toolbar");
197
					if ( toolbar ) {
198
						toolbar.style.display = "block";
199
						id("qunit-filter-pass").disabled = null;
200
						id("qunit-filter-missing").disabled = null;
201
					}
202
				}
203
 
204
			} else {
205
				for ( var i = 0; i < config.assertions.length; i++ ) {
206
					if ( !config.assertions[i].result ) {
207
						bad++;
208
						config.stats.bad++;
209
						config.moduleStats.bad++;
210
					}
211
				}
212
			}
213
 
214
			QUnit.testDone( testName, bad, config.assertions.length );
215
 
216
			if ( !window.setTimeout && !config.queue.length ) {
217
				done();
218
			}
219
		});
220
 
221
		synchronize( done );
222
	},
223
 
224
	/**
225
	 * Specify the number of expected assertions to gurantee that failed test (no assertions are run at all) don't slip through.
226
	 */
227
	expect: function(asserts) {
228
		config.expected = asserts;
229
	},
230
 
231
	/**
232
	 * Asserts true.
233
	 * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" );
234
	 */
235
	ok: function(a, msg) {
236
		msg = escapeHtml(msg);
237
		QUnit.log(a, msg);
238
 
239
		config.assertions.push({
240
			result: !!a,
241
			message: msg
242
		});
243
	},
244
 
245
	/**
246
	 * Checks that the first two arguments are equal, with an optional message.
247
	 * Prints out both actual and expected values.
248
	 *
249
	 * Prefered to ok( actual == expected, message )
250
	 *
251
	 * @example equal( format("Received {0} bytes.", 2), "Received 2 bytes." );
252
	 *
253
	 * @param Object actual
254
	 * @param Object expected
255
	 * @param String message (optional)
256
	 */
257
	equal: function(actual, expected, message) {
258
		push(expected == actual, actual, expected, message);
259
	},
260
 
261
	notEqual: function(actual, expected, message) {
262
		push(expected != actual, actual, expected, message);
263
	},
264
 
265
	deepEqual: function(actual, expected, message) {
266
		push(QUnit.equiv(actual, expected), actual, expected, message);
267
	},
268
 
269
	notDeepEqual: function(actual, expected, message) {
270
		push(!QUnit.equiv(actual, expected), actual, expected, message);
271
	},
272
 
273
	strictEqual: function(actual, expected, message) {
274
		push(expected === actual, actual, expected, message);
275
	},
276
 
277
	notStrictEqual: function(actual, expected, message) {
278
		push(expected !== actual, actual, expected, message);
279
	},
280
 
281
	raises: function(fn,  message) {
282
		try {
283
			fn();
284
			ok( false, message );
285
		}
286
		catch (e) {
287
			ok( true, message );
288
		}
289
	},
290
 
291
	start: function() {
292
		// A slight delay, to avoid any current callbacks
293
		if ( window.setTimeout ) {
294
			window.setTimeout(function() {
295
				if ( config.timeout ) {
296
					clearTimeout(config.timeout);
297
				}
298
 
299
				config.blocking = false;
300
				process();
301
			}, 13);
302
		} else {
303
			config.blocking = false;
304
			process();
305
		}
306
	},
307
 
308
	stop: function(timeout) {
309
		config.blocking = true;
310
 
311
		if ( timeout && window.setTimeout ) {
312
			config.timeout = window.setTimeout(function() {
313
				QUnit.ok( false, "Test timed out" );
314
				QUnit.start();
315
			}, timeout);
316
		}
317
	}
318
 
319
};
320
 
321
// Backwards compatibility, deprecated
322
QUnit.equals = QUnit.equal;
323
QUnit.same = QUnit.deepEqual;
324
 
325
// Maintain internal state
326
var config = {
327
	// The queue of tests to run
328
	queue: [],
329
 
330
	// block until document ready
331
	blocking: true
332
};
333
 
334
// Load paramaters
335
(function() {
336
	var location = window.location || { search: "", protocol: "file:" },
337
		GETParams = location.search.slice(1).split('&');
338
 
339
	for ( var i = 0; i < GETParams.length; i++ ) {
340
		GETParams[i] = decodeURIComponent( GETParams[i] );
341
		if ( GETParams[i] === "noglobals" ) {
342
			GETParams.splice( i, 1 );
343
			i--;
344
			config.noglobals = true;
345
		} else if ( GETParams[i].search('=') > -1 ) {
346
			GETParams.splice( i, 1 );
347
			i--;
348
		}
349
	}
350
 
351
	// restrict modules/tests by get parameters
352
	config.filters = GETParams;
353
 
354
	// Figure out if we're running the tests from a server or not
355
	QUnit.isLocal = !!(location.protocol === 'file:');
356
})();
357
 
358
// Expose the API as global variables, unless an 'exports'
359
// object exists, in that case we assume we're in CommonJS
360
if ( typeof exports === "undefined" || typeof require === "undefined" ) {
361
	extend(window, QUnit);
362
	window.QUnit = QUnit;
363
} else {
364
	extend(exports, QUnit);
365
	exports.QUnit = QUnit;
366
}
367
 
368
// define these after exposing globals to keep them in these QUnit namespace only
369
extend(QUnit, {
370
	config: config,
371
 
372
	// Initialize the configuration options
373
	init: function() {
374
		extend(config, {
375
			stats: { all: 0, bad: 0 },
376
			moduleStats: { all: 0, bad: 0 },
377
			started: +new Date,
378
			updateRate: 1000,
379
			blocking: false,
380
			autostart: true,
381
			autorun: false,
382
			assertions: [],
383
			filters: [],
384
			queue: []
385
		});
386
 
387
		var tests = id("qunit-tests"),
388
			banner = id("qunit-banner"),
389
			result = id("qunit-testresult");
390
 
391
		if ( tests ) {
392
			tests.innerHTML = "";
393
		}
394
 
395
		if ( banner ) {
396
			banner.className = "";
397
		}
398
 
399
		if ( result ) {
400
			result.parentNode.removeChild( result );
401
		}
402
	},
403
 
404
	/**
405
	 * Resets the test setup. Useful for tests that modify the DOM.
406
	 */
407
	reset: function() {
408
		if ( window.jQuery ) {
409
			jQuery("#main, #qunit-fixture").html( config.fixture );
410
		}
411
	},
412
 
413
	/**
414
	 * Trigger an event on an element.
415
	 *
416
	 * @example triggerEvent( document.body, "click" );
417
	 *
418
	 * @param DOMElement elem
419
	 * @param String type
420
	 */
421
	triggerEvent: function( elem, type, event ) {
422
		if ( document.createEvent ) {
423
			event = document.createEvent("MouseEvents");
424
			event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView,
425
				0, 0, 0, 0, 0, false, false, false, false, 0, null);
426
			elem.dispatchEvent( event );
427
 
428
		} else if ( elem.fireEvent ) {
429
			elem.fireEvent("on"+type);
430
		}
431
	},
432
 
433
	// Safe object type checking
434
	is: function( type, obj ) {
435
		return QUnit.objectType( obj ) == type;
436
	},
437
 
438
	objectType: function( obj ) {
439
		if (typeof obj === "undefined") {
440
				return "undefined";
441
 
442
		// consider: typeof null === object
443
		}
444
		if (obj === null) {
445
				return "null";
446
		}
447
 
448
		var type = Object.prototype.toString.call( obj )
449
			.match(/^\[object\s(.*)\]$/)[1] || '';
450
 
451
		switch (type) {
452
				case 'Number':
453
						if (isNaN(obj)) {
454
								return "nan";
455
						} else {
456
								return "number";
457
						}
458
				case 'String':
459
				case 'Boolean':
460
				case 'Array':
461
				case 'Date':
462
				case 'RegExp':
463
				case 'Function':
464
						return type.toLowerCase();
465
		}
466
		if (typeof obj === "object") {
467
				return "object";
468
		}
469
		return undefined;
470
	},
471
 
472
	// Logging callbacks
473
	begin: function() {},
474
	done: function(failures, total) {},
475
	log: function(result, message) {},
476
	testStart: function(name, testEnvironment) {},
477
	testDone: function(name, failures, total) {},
478
	moduleStart: function(name, testEnvironment) {},
479
	moduleDone: function(name, failures, total) {}
480
});
481
 
482
if ( typeof document === "undefined" || document.readyState === "complete" ) {
483
	config.autorun = true;
484
}
485
 
486
addEvent(window, "load", function() {
487
	QUnit.begin();
488
 
489
	// Initialize the config, saving the execution queue
490
	var oldconfig = extend({}, config);
491
	QUnit.init();
492
	extend(config, oldconfig);
493
 
494
	config.blocking = false;
495
 
496
	var userAgent = id("qunit-userAgent");
497
	if ( userAgent ) {
498
		userAgent.innerHTML = navigator.userAgent;
499
	}
500
	var banner = id("qunit-header");
501
	if ( banner ) {
502
		banner.innerHTML = '<a href="' + location.href + '">' + banner.innerHTML + '</a>';
503
	}
504
 
505
	var toolbar = id("qunit-testrunner-toolbar");
506
	if ( toolbar ) {
507
		toolbar.style.display = "none";
508
 
509
		var filter = document.createElement("input");
510
		filter.type = "checkbox";
511
		filter.id = "qunit-filter-pass";
512
		filter.disabled = true;
513
		addEvent( filter, "click", function() {
514
			var li = document.getElementsByTagName("li");
515
			for ( var i = 0; i < li.length; i++ ) {
516
				if ( li[i].className.indexOf("pass") > -1 ) {
517
					li[i].style.display = filter.checked ? "none" : "";
518
				}
519
			}
520
		});
521
		toolbar.appendChild( filter );
522
 
523
		var label = document.createElement("label");
524
		label.setAttribute("for", "qunit-filter-pass");
525
		label.innerHTML = "Hide passed tests";
526
		toolbar.appendChild( label );
527
 
528
		var missing = document.createElement("input");
529
		missing.type = "checkbox";
530
		missing.id = "qunit-filter-missing";
531
		missing.disabled = true;
532
		addEvent( missing, "click", function() {
533
			var li = document.getElementsByTagName("li");
534
			for ( var i = 0; i < li.length; i++ ) {
535
				if ( li[i].className.indexOf("fail") > -1 && li[i].innerHTML.indexOf('missing test - untested code is broken code') > - 1 ) {
536
					li[i].parentNode.parentNode.style.display = missing.checked ? "none" : "block";
537
				}
538
			}
539
		});
540
		toolbar.appendChild( missing );
541
 
542
		label = document.createElement("label");
543
		label.setAttribute("for", "qunit-filter-missing");
544
		label.innerHTML = "Hide missing tests (untested code is broken code)";
545
		toolbar.appendChild( label );
546
	}
547
 
548
	var main = id('main') || id('qunit-fixture');
549
	if ( main ) {
550
		config.fixture = main.innerHTML;
551
	}
552
 
553
	if (config.autostart) {
554
		QUnit.start();
555
	}
556
});
557
 
558
function done() {
559
	if ( config.doneTimer && window.clearTimeout ) {
560
		window.clearTimeout( config.doneTimer );
561
		config.doneTimer = null;
562
	}
563
 
564
	if ( config.queue.length ) {
565
		config.doneTimer = window.setTimeout(function(){
566
			if ( !config.queue.length ) {
567
				done();
568
			} else {
569
				synchronize( done );
570
			}
571
		}, 13);
572
 
573
		return;
574
	}
575
 
576
	config.autorun = true;
577
 
578
	// Log the last module results
579
	if ( config.currentModule ) {
580
		QUnit.moduleDone( config.currentModule, config.moduleStats.bad, config.moduleStats.all );
581
	}
582
 
583
	var banner = id("qunit-banner"),
584
		tests = id("qunit-tests"),
585
		html = ['Tests completed in ',
586
		+new Date - config.started, ' milliseconds.<br/>',
587
		'<span class="passed">', config.stats.all - config.stats.bad, '</span> tests of <span class="total">', config.stats.all, '</span> passed, <span class="failed">', config.stats.bad,'</span> failed.'].join('');
588
 
589
	if ( banner ) {
590
		banner.className = (config.stats.bad ? "qunit-fail" : "qunit-pass");
591
	}
592
 
593
	if ( tests ) {
594
		var result = id("qunit-testresult");
595
 
596
		if ( !result ) {
597
			result = document.createElement("p");
598
			result.id = "qunit-testresult";
599
			result.className = "result";
600
			tests.parentNode.insertBefore( result, tests.nextSibling );
601
		}
602
 
603
		result.innerHTML = html;
604
	}
605
 
606
	QUnit.done( config.stats.bad, config.stats.all );
607
}
608
 
609
function validTest( name ) {
610
	var i = config.filters.length,
611
		run = false;
612
 
613
	if ( !i ) {
614
		return true;
615
	}
616
 
617
	while ( i-- ) {
618
		var filter = config.filters[i],
619
			not = filter.charAt(0) == '!';
620
 
621
		if ( not ) {
622
			filter = filter.slice(1);
623
		}
624
 
625
		if ( name.indexOf(filter) !== -1 ) {
626
			return !not;
627
		}
628
 
629
		if ( not ) {
630
			run = true;
631
		}
632
	}
633
 
634
	return run;
635
}
636
 
637
function escapeHtml(s) {
638
	s = s === null ? "" : s + "";
639
	return s.replace(/[\&"<>\\]/g, function(s) {
640
		switch(s) {
641
			case "&": return "&amp;";
642
			case "\\": return "\\\\";
643
			case '"': return '\"';
644
			case "<": return "&lt;";
645
			case ">": return "&gt;";
646
			default: return s;
647
		}
648
	});
649
}
650
 
651
function push(result, actual, expected, message) {
652
	message = escapeHtml(message) || (result ? "okay" : "failed");
653
	message = '<span class="test-message">' + message + "</span>";
654
	expected = escapeHtml(QUnit.jsDump.parse(expected));
655
	actual = escapeHtml(QUnit.jsDump.parse(actual));
656
	var output = message + ', expected: <span class="test-expected">' + expected + '</span>';
657
	if (actual != expected) {
658
		output += ' result: <span class="test-actual">' + actual + '</span>, diff: ' + QUnit.diff(expected, actual);
659
	}
660
 
661
	// can't use ok, as that would double-escape messages
662
	QUnit.log(result, output);
663
	config.assertions.push({
664
		result: !!result,
665
		message: output
666
	});
667
}
668
 
669
function synchronize( callback ) {
670
	config.queue.push( callback );
671
 
672
	if ( config.autorun && !config.blocking ) {
673
		process();
674
	}
675
}
676
 
677
function process() {
678
	var start = (new Date()).getTime();
679
 
680
	while ( config.queue.length && !config.blocking ) {
681
		if ( config.updateRate <= 0 || (((new Date()).getTime() - start) < config.updateRate) ) {
682
			config.queue.shift()();
683
 
684
		} else {
685
			setTimeout( process, 13 );
686
			break;
687
		}
688
	}
689
}
690
 
691
function saveGlobal() {
692
	config.pollution = [];
693
 
694
	if ( config.noglobals ) {
695
		for ( var key in window ) {
696
			config.pollution.push( key );
697
		}
698
	}
699
}
700
 
701
function checkPollution( name ) {
702
	var old = config.pollution;
703
	saveGlobal();
704
 
705
	var newGlobals = diff( old, config.pollution );
706
	if ( newGlobals.length > 0 ) {
707
		ok( false, "Introduced global variable(s): " + newGlobals.join(", ") );
708
		config.expected++;
709
	}
710
 
711
	var deletedGlobals = diff( config.pollution, old );
712
	if ( deletedGlobals.length > 0 ) {
713
		ok( false, "Deleted global variable(s): " + deletedGlobals.join(", ") );
714
		config.expected++;
715
	}
716
}
717
 
718
// returns a new Array with the elements that are in a but not in b
719
function diff( a, b ) {
720
	var result = a.slice();
721
	for ( var i = 0; i < result.length; i++ ) {
722
		for ( var j = 0; j < b.length; j++ ) {
723
			if ( result[i] === b[j] ) {
724
				result.splice(i, 1);
725
				i--;
726
				break;
727
			}
728
		}
729
	}
730
	return result;
731
}
732
 
733
function fail(message, exception, callback) {
734
	if ( typeof console !== "undefined" && console.error && console.warn ) {
735
		console.error(message);
736
		console.error(exception);
737
		console.warn(callback.toString());
738
 
739
	} else if ( window.opera && opera.postError ) {
740
		opera.postError(message, exception, callback.toString);
741
	}
742
}
743
 
744
function extend(a, b) {
745
	for ( var prop in b ) {
746
		a[prop] = b[prop];
747
	}
748
 
749
	return a;
750
}
751
 
752
function addEvent(elem, type, fn) {
753
	if ( elem.addEventListener ) {
754
		elem.addEventListener( type, fn, false );
755
	} else if ( elem.attachEvent ) {
756
		elem.attachEvent( "on" + type, fn );
757
	} else {
758
		fn();
759
	}
760
}
761
 
762
function id(name) {
763
	return !!(typeof document !== "undefined" && document && document.getElementById) &&
764
		document.getElementById( name );
765
}
766
 
767
// Test for equality any JavaScript type.
768
// Discussions and reference: http://philrathe.com/articles/equiv
769
// Test suites: http://philrathe.com/tests/equiv
770
// Author: Philippe Rathé <prathe@gmail.com>
771
QUnit.equiv = function () {
772
 
773
    var innerEquiv; // the real equiv function
774
    var callers = []; // stack to decide between skip/abort functions
775
    var parents = []; // stack to avoiding loops from circular referencing
776
 
777
    // Call the o related callback with the given arguments.
778
    function bindCallbacks(o, callbacks, args) {
779
        var prop = QUnit.objectType(o);
780
        if (prop) {
781
            if (QUnit.objectType(callbacks[prop]) === "function") {
782
                return callbacks[prop].apply(callbacks, args);
783
            } else {
784
                return callbacks[prop]; // or undefined
785
            }
786
        }
787
    }
788
 
789
    var callbacks = function () {
790
 
791
        // for string, boolean, number and null
792
        function useStrictEquality(b, a) {
793
            if (b instanceof a.constructor || a instanceof b.constructor) {
794
                // to catch short annotaion VS 'new' annotation of a declaration
795
                // e.g. var i = 1;
796
                //      var j = new Number(1);
797
                return a == b;
798
            } else {
799
                return a === b;
800
            }
801
        }
802
 
803
        return {
804
            "string": useStrictEquality,
805
            "boolean": useStrictEquality,
806
            "number": useStrictEquality,
807
            "null": useStrictEquality,
808
            "undefined": useStrictEquality,
809
 
810
            "nan": function (b) {
811
                return isNaN(b);
812
            },
813
 
814
            "date": function (b, a) {
815
                return QUnit.objectType(b) === "date" && a.valueOf() === b.valueOf();
816
            },
817
 
818
            "regexp": function (b, a) {
819
                return QUnit.objectType(b) === "regexp" &&
820
                    a.source === b.source && // the regex itself
821
                    a.global === b.global && // and its modifers (gmi) ...
822
                    a.ignoreCase === b.ignoreCase &&
823
                    a.multiline === b.multiline;
824
            },
825
 
826
            // - skip when the property is a method of an instance (OOP)
827
            // - abort otherwise,
828
            //   initial === would have catch identical references anyway
829
            "function": function () {
830
                var caller = callers[callers.length - 1];
831
                return caller !== Object &&
832
                        typeof caller !== "undefined";
833
            },
834
 
835
            "array": function (b, a) {
836
                var i, j, loop;
837
                var len;
838
 
839
                // b could be an object literal here
840
                if ( ! (QUnit.objectType(b) === "array")) {
841
                    return false;
842
                }
843
 
844
                len = a.length;
845
                if (len !== b.length) { // safe and faster
846
                    return false;
847
                }
848
 
849
                //track reference to avoid circular references
850
                parents.push(a);
851
                for (i = 0; i < len; i++) {
852
                    loop = false;
853
                    for(j=0;j<parents.length;j++){
854
                        if(parents[j] === a[i]){
855
                            loop = true;//dont rewalk array
856
                        }
857
                    }
858
                    if (!loop && ! innerEquiv(a[i], b[i])) {
859
                        parents.pop();
860
                        return false;
861
                    }
862
                }
863
                parents.pop();
864
                return true;
865
            },
866
 
867
            "object": function (b, a) {
868
                var i, j, loop;
869
                var eq = true; // unless we can proove it
870
                var aProperties = [], bProperties = []; // collection of strings
871
 
872
                // comparing constructors is more strict than using instanceof
873
                if ( a.constructor !== b.constructor) {
874
                    return false;
875
                }
876
 
877
                // stack constructor before traversing properties
878
                callers.push(a.constructor);
879
                //track reference to avoid circular references
880
                parents.push(a);
881
 
882
                for (i in a) { // be strict: don't ensures hasOwnProperty and go deep
883
                    loop = false;
884
                    for(j=0;j<parents.length;j++){
885
                        if(parents[j] === a[i])
886
                            loop = true; //don't go down the same path twice
887
                    }
888
                    aProperties.push(i); // collect a's properties
889
 
890
                    if (!loop && ! innerEquiv(a[i], b[i])) {
891
                        eq = false;
892
                        break;
893
                    }
894
                }
895
 
896
                callers.pop(); // unstack, we are done
897
                parents.pop();
898
 
899
                for (i in b) {
900
                    bProperties.push(i); // collect b's properties
901
                }
902
 
903
                // Ensures identical properties name
904
                return eq && innerEquiv(aProperties.sort(), bProperties.sort());
905
            }
906
        };
907
    }();
908
 
909
    innerEquiv = function () { // can take multiple arguments
910
        var args = Array.prototype.slice.apply(arguments);
911
        if (args.length < 2) {
912
            return true; // end transition
913
        }
914
 
915
        return (function (a, b) {
916
            if (a === b) {
917
                return true; // catch the most you can
918
            } else if (a === null || b === null || typeof a === "undefined" || typeof b === "undefined" || QUnit.objectType(a) !== QUnit.objectType(b)) {
919
                return false; // don't lose time with error prone cases
920
            } else {
921
                return bindCallbacks(a, callbacks, [b, a]);
922
            }
923
 
924
        // apply transition with (1..n) arguments
925
        })(args[0], args[1]) && arguments.callee.apply(this, args.splice(1, args.length -1));
926
    };
927
 
928
    return innerEquiv;
929
 
930
}();
931
 
932
/**
933
 * jsDump
934
 * Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com
935
 * Licensed under BSD (http://www.opensource.org/licenses/bsd-license.php)
936
 * Date: 5/15/2008
937
 * @projectDescription Advanced and extensible data dumping for Javascript.
938
 * @version 1.0.0
939
 * @author Ariel Flesler
940
 * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html}
941
 */
942
QUnit.jsDump = (function() {
943
	function quote( str ) {
944
		return '"' + str.toString().replace(/"/g, '\\"') + '"';
945
	};
946
	function literal( o ) {
947
		return o + '';
948
	};
949
	function join( pre, arr, post ) {
950
		var s = jsDump.separator(),
951
			base = jsDump.indent(),
952
			inner = jsDump.indent(1);
953
		if ( arr.join )
954
			arr = arr.join( ',' + s + inner );
955
		if ( !arr )
956
			return pre + post;
957
		return [ pre, inner + arr, base + post ].join(s);
958
	};
959
	function array( arr ) {
960
		var i = arr.length,	ret = Array(i);
961
		this.up();
962
		while ( i-- )
963
			ret[i] = this.parse( arr[i] );
964
		this.down();
965
		return join( '[', ret, ']' );
966
	};
967
 
968
	var reName = /^function (\w+)/;
969
 
970
	var jsDump = {
971
		parse:function( obj, type ) { //type is used mostly internally, you can fix a (custom)type in advance
972
			var	parser = this.parsers[ type || this.typeOf(obj) ];
973
			type = typeof parser;
974
 
975
			return type == 'function' ? parser.call( this, obj ) :
976
				   type == 'string' ? parser :
977
				   this.parsers.error;
978
		},
979
		typeOf:function( obj ) {
980
			var type;
981
			if ( obj === null ) {
982
				type = "null";
983
			} else if (typeof obj === "undefined") {
984
				type = "undefined";
985
			} else if (QUnit.is("RegExp", obj)) {
986
				type = "regexp";
987
			} else if (QUnit.is("Date", obj)) {
988
				type = "date";
989
			} else if (QUnit.is("Function", obj)) {
990
				type = "function";
991
			} else if (obj.setInterval && obj.document && !obj.nodeType) {
992
				type = "window";
993
			} else if (obj.nodeType === 9) {
994
				type = "document";
995
			} else if (obj.nodeType) {
996
				type = "node";
997
			} else if (typeof obj === "object" && typeof obj.length === "number" && obj.length >= 0) {
998
				type = "array";
999
			} else {
1000
				type = typeof obj;
1001
			}
1002
			return type;
1003
		},
1004
		separator:function() {
1005
			return this.multiline ?	this.HTML ? '<br />' : '\n' : this.HTML ? '&nbsp;' : ' ';
1006
		},
1007
		indent:function( extra ) {// extra can be a number, shortcut for increasing-calling-decreasing
1008
			if ( !this.multiline )
1009
				return '';
1010
			var chr = this.indentChar;
1011
			if ( this.HTML )
1012
				chr = chr.replace(/\t/g,'   ').replace(/ /g,'&nbsp;');
1013
			return Array( this._depth_ + (extra||0) ).join(chr);
1014
		},
1015
		up:function( a ) {
1016
			this._depth_ += a || 1;
1017
		},
1018
		down:function( a ) {
1019
			this._depth_ -= a || 1;
1020
		},
1021
		setParser:function( name, parser ) {
1022
			this.parsers[name] = parser;
1023
		},
1024
		// The next 3 are exposed so you can use them
1025
		quote:quote,
1026
		literal:literal,
1027
		join:join,
1028
		//
1029
		_depth_: 1,
1030
		// This is the list of parsers, to modify them, use jsDump.setParser
1031
		parsers:{
1032
			window: '[Window]',
1033
			document: '[Document]',
1034
			error:'[ERROR]', //when no parser is found, shouldn't happen
1035
			unknown: '[Unknown]',
1036
			'null':'null',
1037
			undefined:'undefined',
1038
			'function':function( fn ) {
1039
				var ret = 'function',
1040
					name = 'name' in fn ? fn.name : (reName.exec(fn)||[])[1];//functions never have name in IE
1041
				if ( name )
1042
					ret += ' ' + name;
1043
				ret += '(';
1044
 
1045
				ret = [ ret, this.parse( fn, 'functionArgs' ), '){'].join('');
1046
				return join( ret, this.parse(fn,'functionCode'), '}' );
1047
			},
1048
			array: array,
1049
			nodelist: array,
1050
			arguments: array,
1051
			object:function( map ) {
1052
				var ret = [ ];
1053
				this.up();
1054
				for ( var key in map )
1055
					ret.push( this.parse(key,'key') + ': ' + this.parse(map[key]) );
1056
				this.down();
1057
				return join( '{', ret, '}' );
1058
			},
1059
			node:function( node ) {
1060
				var open = this.HTML ? '&lt;' : '<',
1061
					close = this.HTML ? '&gt;' : '>';
1062
 
1063
				var tag = node.nodeName.toLowerCase(),
1064
					ret = open + tag;
1065
 
1066
				for ( var a in this.DOMAttrs ) {
1067
					var val = node[this.DOMAttrs[a]];
1068
					if ( val )
1069
						ret += ' ' + a + '=' + this.parse( val, 'attribute' );
1070
				}
1071
				return ret + close + open + '/' + tag + close;
1072
			},
1073
			functionArgs:function( fn ) {//function calls it internally, it's the arguments part of the function
1074
				var l = fn.length;
1075
				if ( !l ) return '';
1076
 
1077
				var args = Array(l);
1078
				while ( l-- )
1079
					args[l] = String.fromCharCode(97+l);//97 is 'a'
1080
				return ' ' + args.join(', ') + ' ';
1081
			},
1082
			key:quote, //object calls it internally, the key part of an item in a map
1083
			functionCode:'[code]', //function calls it internally, it's the content of the function
1084
			attribute:quote, //node calls it internally, it's an html attribute value
1085
			string:quote,
1086
			date:quote,
1087
			regexp:literal, //regex
1088
			number:literal,
1089
			'boolean':literal
1090
		},
1091
		DOMAttrs:{//attributes to dump from nodes, name=>realName
1092
			id:'id',
1093
			name:'name',
1094
			'class':'className'
1095
		},
1096
		HTML:false,//if true, entities are escaped ( <, >, \t, space and \n )
1097
		indentChar:'   ',//indentation unit
1098
		multiline:false //if true, items in a collection, are separated by a \n, else just a space.
1099
	};
1100
 
1101
	return jsDump;
1102
})();
1103
 
1104
// from Sizzle.js
1105
function getText( elems ) {
1106
	var ret = "", elem;
1107
 
1108
	for ( var i = 0; elems[i]; i++ ) {
1109
		elem = elems[i];
1110
 
1111
		// Get the text from text nodes and CDATA nodes
1112
		if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
1113
			ret += elem.nodeValue;
1114
 
1115
		// Traverse everything else, except comment nodes
1116
		} else if ( elem.nodeType !== 8 ) {
1117
			ret += getText( elem.childNodes );
1118
		}
1119
	}
1120
 
1121
	return ret;
1122
};
1123
 
1124
/*
1125
 * Javascript Diff Algorithm
1126
 *  By John Resig (http://ejohn.org/)
1127
 *  Modified by Chu Alan "sprite"
1128
 *
1129
 * Released under the MIT license.
1130
 *
1131
 * More Info:
1132
 *  http://ejohn.org/projects/javascript-diff-algorithm/
1133
 *
1134
 * Usage: QUnit.diff(expected, actual)
1135
 *
1136
 * 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"
1137
 */
1138
QUnit.diff = (function() {
1139
	function diff(o, n){
1140
		var ns = new Object();
1141
		var os = new Object();
1142
 
1143
		for (var i = 0; i < n.length; i++) {
1144
			if (ns[n[i]] == null)
1145
				ns[n[i]] = {
1146
					rows: new Array(),
1147
					o: null
1148
				};
1149
			ns[n[i]].rows.push(i);
1150
		}
1151
 
1152
		for (var i = 0; i < o.length; i++) {
1153
			if (os[o[i]] == null)
1154
				os[o[i]] = {
1155
					rows: new Array(),
1156
					n: null
1157
				};
1158
			os[o[i]].rows.push(i);
1159
		}
1160
 
1161
		for (var i in ns) {
1162
			if (ns[i].rows.length == 1 && typeof(os[i]) != "undefined" && os[i].rows.length == 1) {
1163
				n[ns[i].rows[0]] = {
1164
					text: n[ns[i].rows[0]],
1165
					row: os[i].rows[0]
1166
				};
1167
				o[os[i].rows[0]] = {
1168
					text: o[os[i].rows[0]],
1169
					row: ns[i].rows[0]
1170
				};
1171
			}
1172
		}
1173
 
1174
		for (var i = 0; i < n.length - 1; i++) {
1175
			if (n[i].text != null && n[i + 1].text == null && n[i].row + 1 < o.length && o[n[i].row + 1].text == null &&
1176
			n[i + 1] == o[n[i].row + 1]) {
1177
				n[i + 1] = {
1178
					text: n[i + 1],
1179
					row: n[i].row + 1
1180
				};
1181
				o[n[i].row + 1] = {
1182
					text: o[n[i].row + 1],
1183
					row: i + 1
1184
				};
1185
			}
1186
		}
1187
 
1188
		for (var i = n.length - 1; i > 0; i--) {
1189
			if (n[i].text != null && n[i - 1].text == null && n[i].row > 0 && o[n[i].row - 1].text == null &&
1190
			n[i - 1] == o[n[i].row - 1]) {
1191
				n[i - 1] = {
1192
					text: n[i - 1],
1193
					row: n[i].row - 1
1194
				};
1195
				o[n[i].row - 1] = {
1196
					text: o[n[i].row - 1],
1197
					row: i - 1
1198
				};
1199
			}
1200
		}
1201
 
1202
		return {
1203
			o: o,
1204
			n: n
1205
		};
1206
	}
1207
 
1208
	return function(o, n){
1209
		o = o.replace(/\s+$/, '');
1210
		n = n.replace(/\s+$/, '');
1211
		var out = diff(o == "" ? [] : o.split(/\s+/), n == "" ? [] : n.split(/\s+/));
1212
 
1213
		var str = "";
1214
 
1215
		var oSpace = o.match(/\s+/g);
1216
		if (oSpace == null) {
1217
			oSpace = [" "];
1218
		}
1219
		else {
1220
			oSpace.push(" ");
1221
		}
1222
		var nSpace = n.match(/\s+/g);
1223
		if (nSpace == null) {
1224
			nSpace = [" "];
1225
		}
1226
		else {
1227
			nSpace.push(" ");
1228
		}
1229
 
1230
		if (out.n.length == 0) {
1231
			for (var i = 0; i < out.o.length; i++) {
1232
				str += '<del>' + out.o[i] + oSpace[i] + "</del>";
1233
			}
1234
		}
1235
		else {
1236
			if (out.n[0].text == null) {
1237
				for (n = 0; n < out.o.length && out.o[n].text == null; n++) {
1238
					str += '<del>' + out.o[n] + oSpace[n] + "</del>";
1239
				}
1240
			}
1241
 
1242
			for (var i = 0; i < out.n.length; i++) {
1243
				if (out.n[i].text == null) {
1244
					str += '<ins>' + out.n[i] + nSpace[i] + "</ins>";
1245
				}
1246
				else {
1247
					var pre = "";
1248
 
1249
					for (n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++) {
1250
						pre += '<del>' + out.o[n] + oSpace[n] + "</del>";
1251
					}
1252
					str += " " + out.n[i].text + nSpace[i] + pre;
1253
				}
1254
			}
1255
		}
1256
 
1257
		return str;
1258
	}
1259
})();
1260
 
1261
})(this);