/**

  * QUnit - A JavaScript Unit Testing Framework

  *

  * http://docs.jquery.com/QUnit

  *

  * Copyright (c) 2012 John Resig, Jörn Zaefferer

  * Dual licensed under the MIT (MIT-LICENSE.txt)

  * or GPL (GPL-LICENSE.txt) licenses.

  */

 (function(window) {

 var defined = {

 	setTimeout: typeof window.setTimeout !== "undefined",

 	sessionStorage: (function() {

 		try {

 			return !!sessionStorage.getItem;

 		} catch(e) {

 			return false;

 		}

 	})()

 };

 var testId = 0;

 var Test = function(name, testName, expected, testEnvironmentArg, async, callback) {

 	this.name = name;

 	this.testName = testName;

 	this.expected = expected;

 	this.testEnvironmentArg = testEnvironmentArg;

 	this.async = async;

 	this.callback = callback;

 	this.assertions = [];

 };

 Test.prototype = {

 	init: function() {

 		var tests = id("qunit-tests");

 		if (tests) {

 			var b = document.createElement("strong");

 				b.innerHTML = "Running " + this.name;

 			var li = document.createElement("li");

 				li.appendChild( b );

 				li.className = "running";

 				li.id = this.id = "test-output" + testId++;

 			tests.appendChild( li );

 		}

 	},

 	setup: function() {

 		if (this.module != config.previousModule) {

 			if ( config.previousModule ) {

 				QUnit.moduleDone( {

 					name: config.previousModule,

 					failed: config.moduleStats.bad,

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

 					total: config.moduleStats.all

 				} );

 			}

 			config.previousModule = this.module;

 			config.moduleStats = { all: 0, bad: 0 };

 			QUnit.moduleStart( {

 				name: this.module

 			} );

 		}

 		config.current = this;

 		this.testEnvironment = extend({

 			setup: function() {},

 			teardown: function() {}

 		}, this.moduleTestEnvironment);

 		if (this.testEnvironmentArg) {

 			extend(this.testEnvironment, this.testEnvironmentArg);

 		}

 		QUnit.testStart( {

 			name: this.testName

 		} );

 		// allow utility functions to access the current test environment

 		// TODO why??

 		QUnit.current_testEnvironment = this.testEnvironment;

 		try {

 			if ( !config.pollution ) {

 				saveGlobal();

 			}

 			this.testEnvironment.setup.call(this.testEnvironment);

 		} catch(e) {

 			QUnit.ok( false, "Setup failed on " + this.testName + ": " + e.message );

 		}

 	},

 	run: function() {

 		if ( this.async ) {

 			QUnit.stop();

 		}

 		if ( config.notrycatch ) {

 			this.callback.call(this.testEnvironment);

 			return;

 		}

 		try {

 			this.callback.call(this.testEnvironment);

 		} catch(e) {

 			fail("Test " + this.testName + " died, exception and test follows", e, this.callback);

 			QUnit.ok( false, "Died on test #" + (this.assertions.length + 1) + ": " + e.message + " - " + QUnit.jsDump.parse(e) );

 			// else next test will carry the responsibility

 			saveGlobal();

 			// Restart the tests if they're blocking

 			if ( config.blocking ) {

 				start();

 			}

 		}

 	},

 	teardown: function() {

 		try {

 			this.testEnvironment.teardown.call(this.testEnvironment);

 			checkPollution();

 		} catch(e) {

 			QUnit.ok( false, "Teardown failed on " + this.testName + ": " + e.message );

 		}

 	},

 	finish: function() {

 		if ( this.expected && this.expected != this.assertions.length ) {

 			QUnit.ok( false, "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run" );

 		}

 		var good = 0, bad = 0,

 			tests = id("qunit-tests");

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

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

 		if ( tests ) {

 			var ol = document.createElement("ol");

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

 				var assertion = this.assertions[i];

 				var li = document.createElement("li");

 				li.className = assertion.result ? "pass" : "fail";

 				li.innerHTML = assertion.message || (assertion.result ? "okay" : "failed");

 				ol.appendChild( li );

 				if ( assertion.result ) {

 					good++;

 				} else {

 					bad++;

 					config.stats.bad++;

 					config.moduleStats.bad++;

 				}

 			}

 			// store result when possible

 			if ( QUnit.config.reorder && defined.sessionStorage ) {

 				if (bad) {

 					sessionStorage.setItem("qunit-" + this.module + "-" + this.testName, bad);

 				} else {

 					sessionStorage.removeItem("qunit-" + this.module + "-" + this.testName);

 				}

 			}

 			if (bad == 0) {

 				ol.style.display = "none";

 			}

 			var b = document.createElement("strong");

 			b.innerHTML = this.name + " <b class='counts'>(<b class='failed'>" + bad + "</b>, <b class='passed'>" + good + "</b>, " + this.assertions.length + ")</b>";

 			var a = document.createElement("a");

 			a.innerHTML = "Rerun";

 			a.href = QUnit.url({ filter: getText([b]).replace(/\([^)]+\)$/, "").replace(/(^\s*|\s*$)/g, "") });

 			addEvent(b, "click", function() {

 				var next = b.nextSibling.nextSibling,

 					display = next.style.display;

 				next.style.display = display === "none" ? "block" : "none";

 			});

 			addEvent(b, "dblclick", function(e) {

 				var target = e && e.target ? e.target : window.event.srcElement;

 				if ( target.nodeName.toLowerCase() == "span" || target.nodeName.toLowerCase() == "b" ) {

 					target = target.parentNode;

 				}

 				if ( window.location && target.nodeName.toLowerCase() === "strong" ) {

 					window.location = QUnit.url({ filter: getText([target]).replace(/\([^)]+\)$/, "").replace(/(^\s*|\s*$)/g, "") });

 				}

 			});

 			var li = id(this.id);

 			li.className = bad ? "fail" : "pass";

 			li.removeChild( li.firstChild );

 			li.appendChild( b );

 			li.appendChild( a );

 			li.appendChild( ol );

 		} else {

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

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

 					bad++;

 					config.stats.bad++;

 					config.moduleStats.bad++;

 				}

 			}

 		}

 		try {

 			QUnit.reset();

 		} catch(e) {

 			fail("reset() failed, following Test " + this.testName + ", exception and reset fn follows", e, QUnit.reset);

 		}

 		QUnit.testDone( {

 			name: this.testName,

 			failed: bad,

 			passed: this.assertions.length - bad,

 			total: this.assertions.length

 		} );

 	},

 	queue: function() {

 		var test = this;

 		synchronize(function() {

 			test.init();

 		});

 		function run() {

 			// each of these can by async

 			synchronize(function() {

 				test.setup();

 			});

 			synchronize(function() {

 				test.run();

 			});

 			synchronize(function() {

 				test.teardown();

 			});

 			synchronize(function() {

 				test.finish();

 			});

 		}

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

 		var bad = QUnit.config.reorder && defined.sessionStorage && +sessionStorage.getItem("qunit-" + this.module + "-" + this.testName);

 		if (bad) {

 			run();

 		} else {

 			synchronize(run);

 		};

 	}

 };

 var QUnit = {

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

 	module: function(name, testEnvironment) {

 		config.currentModule = name;

 		config.currentModuleTestEnviroment = testEnvironment;

 	},

 	asyncTest: function(testName, expected, callback) {

 		if ( arguments.length === 2 ) {

 			callback = expected;

 			expected = 0;

 		}

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

 	},

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

 		var name = '<span class="test-name">' + testName + '</span>', testEnvironmentArg;

 		if ( arguments.length === 2 ) {

 			callback = expected;

 			expected = null;

 		}

 		// is 2nd argument a testEnvironment?

 		if ( expected && typeof expected === 'object') {

 			testEnvironmentArg = expected;

 			expected = null;

 		}

 		if ( config.currentModule ) {

 			name = '<span class="module-name">' + config.currentModule + "</span>: " + name;

 		}

 		if ( !validTest(config.currentModule + ": " + testName) ) {

 			return;

 		}

 		var test = new Test(name, testName, expected, testEnvironmentArg, async, callback);

 		test.module = config.currentModule;

 		test.moduleTestEnvironment = config.currentModuleTestEnviroment;

 		test.queue();

 	},

 	/**

 	 * Specify the number of expected assertions to gurantee that failed test (no assertions are run at all) don't slip through.

 	 */

 	expect: function(asserts) {

 		config.current.expected = asserts;

 	},

 	/**

 	 * Asserts true.

 	 * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" );

 	 */

 	ok: function(a, msg) {

 		a = !!a;

 		var details = {

 			result: a,

 			message: msg

 		};

 		msg = escapeHtml(msg);

 		QUnit.log(details);

 		config.current.assertions.push({

 			result: a,

 			message: msg

 		});

 	},

 	/**

 	 * Checks that the first two arguments are equal, with an optional message.

 	 * Prints out both actual and expected values.

 	 *

 	 * Prefered to ok( actual == expected, message )

 	 *

 	 * @example equal( format("Received {0} bytes.", 2), "Received 2 bytes." );

 	 *

 	 * @param Object actual

 	 * @param Object expected

 	 * @param String message (optional)

 	 */

 	equal: function(actual, expected, message) {

 		QUnit.push(expected == actual, actual, expected, message);

 	},

 	notEqual: function(actual, expected, message) {

 		QUnit.push(expected != actual, actual, expected, message);

 	},

 	deepEqual: function(actual, expected, message) {

 		QUnit.push(QUnit.equiv(actual, expected), actual, expected, message);

 	},

 	notDeepEqual: function(actual, expected, message) {

 		QUnit.push(!QUnit.equiv(actual, expected), actual, expected, message);

 	},

 	strictEqual: function(actual, expected, message) {

 		QUnit.push(expected === actual, actual, expected, message);

 	},

 	notStrictEqual: function(actual, expected, message) {

 		QUnit.push(expected !== actual, actual, expected, message);

 	},

 	raises: function(block, expected, message) {

 		var actual, ok = false;

 		if (typeof expected === 'string') {

 			message = expected;

 			expected = null;

 		}

 		try {

 			block();

 		} catch (e) {

 			actual = e;

 		}

 		if (actual) {

 			// we don't want to validate thrown error

 			if (!expected) {

 				ok = true;

 			// expected is a regexp

 			} else if (QUnit.objectType(expected) === "regexp") {

 				ok = expected.test(actual);

 			// expected is a constructor

 			} else if (actual instanceof expected) {

 				ok = true;

 			// expected is a validation function which returns true is validation passed

 			} else if (expected.call({}, actual) === true) {

 				ok = true;

 			}

 		}

 		QUnit.ok(ok, message);

 	},

 	start: function() {

 		config.semaphore--;

 		if (config.semaphore > 0) {

 			// don't start until equal number of stop-calls

 			return;

 		}

 		if (config.semaphore < 0) {

 			// ignore if start is called more often then stop

 			config.semaphore = 0;

 		}

 		// A slight delay, to avoid any current callbacks

 		if ( defined.setTimeout ) {

 			window.setTimeout(function() {

 				if (config.semaphore > 0) {

 					return;

 				}

 				if ( config.timeout ) {

 					clearTimeout(config.timeout);

 				}

 				config.blocking = false;

 				process();

 			}, 13);

 		} else {

 			config.blocking = false;

 			process();

 		}

 	},

 	stop: function(timeout) {

 		config.semaphore++;

 		config.blocking = true;

 		if ( timeout && defined.setTimeout ) {

 			clearTimeout(config.timeout);

 			config.timeout = window.setTimeout(function() {

 				QUnit.ok( false, "Test timed out" );

 				QUnit.start();

 			}, timeout);

 		}

 	}

 };

 // Backwards compatibility, deprecated

 QUnit.equals = QUnit.equal;

 QUnit.same = QUnit.deepEqual;

 // Maintain internal state

 var config = {

 	// The queue of tests to run

 	queue: [],

 	// block until document ready

 	blocking: true,

 	// when enabled, show only failing tests

 	// gets persisted through sessionStorage and can be changed in UI via checkbox

 	hidepassed: false,

 	// by default, run previously failed tests first

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

 	reorder: true,

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

 	altertitle: true,

 	urlConfig: ['noglobals', 'notrycatch']

 };

 // Load paramaters

 (function() {

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

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

 		length = params.length,

 		urlParams = {},

 		current;

 	if ( params[ 0 ] ) {

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

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

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

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

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

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

 		}

 	}

 	QUnit.urlParams = urlParams;

 	config.filter = urlParams.filter;

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

 	QUnit.isLocal = !!(location.protocol === 'file:');

 })();

 // Expose the API as global variables, unless an 'exports'

 // object exists, in that case we assume we're in CommonJS

 if ( typeof exports === "undefined" || typeof require === "undefined" ) {

 	extend(window, QUnit);

 	window.QUnit = QUnit;

 } else {

 	extend(exports, QUnit);

 	exports.QUnit = QUnit;

 }

 // define these after exposing globals to keep them in these QUnit namespace only

 extend(QUnit, {

 	config: config,

 	// Initialize the configuration options

 	init: function() {

 		extend(config, {

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

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

 			started: +new Date,

 			updateRate: 1000,

 			blocking: false,

 			autostart: true,

 			autorun: false,

 			filter: "",

 			queue: [],

 			semaphore: 0

 		});

 		var tests = id( "qunit-tests" ),

 			banner = id( "qunit-banner" ),

 			result = id( "qunit-testresult" );

 		if ( tests ) {

 			tests.innerHTML = "";

 		}

 		if ( banner ) {

 			banner.className = "";

 		}

 		if ( result ) {

 			result.parentNode.removeChild( result );

 		}

 		if ( tests ) {

 			result = document.createElement( "p" );

 			result.id = "qunit-testresult";

 			result.className = "result";

 			tests.parentNode.insertBefore( result, tests );

 			result.innerHTML = 'Running...<br/>&nbsp;';

 		}

 	},

 	/**

 	 * Resets the test setup. Useful for tests that modify the DOM.

 	 *

 	 * If jQuery is available, uses jQuery's html(), otherwise just innerHTML.

 	 */

 	reset: function() {

 		if ( window.jQuery ) {

 			jQuery( "#qunit-fixture" ).html( config.fixture );

 		} else {

 			var main = id( 'qunit-fixture' );

 			if ( main ) {

 				main.innerHTML = config.fixture;

 			}

 		}

 	},

 	/**

 	 * Trigger an event on an element.

 	 *

 	 * @example triggerEvent( document.body, "click" );

 	 *

 	 * @param DOMElement elem

 	 * @param String type

 	 */

 	triggerEvent: function( elem, type, event ) {

 		if ( document.createEvent ) {

 			event = document.createEvent("MouseEvents");

 			event.initMouseEvent(type, true, true, elem.ownerDocument.defaultView,

 				0, 0, 0, 0, 0, false, false, false, false, 0, null);

 			elem.dispatchEvent( event );

 		} else if ( elem.fireEvent ) {

 			elem.fireEvent("on"+type);

 		}

 	},

 	// Safe object type checking

 	is: function( type, obj ) {

 		return QUnit.objectType( obj ) == type;

 	},

 	objectType: function( obj ) {

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

 				return "undefined";

 		// consider: typeof null === object

 		}

 		if (obj === null) {

 				return "null";

 		}

 		var type = Object.prototype.toString.call( obj )

 			.match(/^\[object\s(.*)\]$/)[1] || '';

 		switch (type) {

 				case 'Number':

 						if (isNaN(obj)) {

 								return "nan";

 						} else {

 								return "number";

 						}

 				case 'String':

 				case 'Boolean':

 				case 'Array':

 				case 'Date':

 				case 'RegExp':

 				case 'Function':

 						return type.toLowerCase();

 		}

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

 				return "object";

 		}

 		return undefined;

 	},

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

 		var details = {

 			result: result,

 			message: message,

 			actual: actual,

 			expected: expected

 		};

 		message = escapeHtml(message) || (result ? "okay" : "failed");

 		message = '<span class="test-message">' + message + "</span>";

 		expected = escapeHtml(QUnit.jsDump.parse(expected));

 		actual = escapeHtml(QUnit.jsDump.parse(actual));

 		var output = message + '<table><tr class="test-expected"><th>Expected: </th><td><pre>' + expected + '</pre></td></tr>';

 		if (actual != expected) {

 			output += '<tr class="test-actual"><th>Result: </th><td><pre>' + actual + '</pre></td></tr>';

 			output += '<tr class="test-diff"><th>Diff: </th><td><pre>' + QUnit.diff(expected, actual) +'</pre></td></tr>';

 		}

 		if (!result) {

 			var source = sourceFromStacktrace();

 			if (source) {

 				details.source = source;

 				output += '<tr class="test-source"><th>Source: </th><td><pre>' + escapeHtml(source) + '</pre></td></tr>';

 			}

 		}

 		output += "</table>";

 		QUnit.log(details);

 		config.current.assertions.push({

 			result: !!result,

 			message: output

 		});

 	},

 	url: function( params ) {

 		params = extend( extend( {}, QUnit.urlParams ), params );

 		var querystring = "?",

 			key;

 		for ( key in params ) {

 			querystring += encodeURIComponent( key ) + "=" +

 				encodeURIComponent( params[ key ] ) + "&";

 		}

 		return window.location.pathname + querystring.slice( 0, -1 );

 	},

 	extend: extend,

 	id: id,

 	addEvent: addEvent,

 	// Logging callbacks; all receive a single argument with the listed properties

 	// run test/logs.html for any related changes

 	begin: function() {},

 	// done: { failed, passed, total, runtime }

 	done: function() {},

 	// log: { result, actual, expected, message }

 	log: function() {},

 	// testStart: { name }

 	testStart: function() {},

 	// testDone: { name, failed, passed, total }

 	testDone: function() {},

 	// moduleStart: { name }

 	moduleStart: function() {},

 	// moduleDone: { name, failed, passed, total }

 	moduleDone: function() {}

 });

 if ( typeof document === "undefined" || document.readyState === "complete" ) {

 	config.autorun = true;

 }

 QUnit.load = function() {

 	QUnit.begin({});

 	// Initialize the config, saving the execution queue

 	var oldconfig = extend({}, config);

 	QUnit.init();

 	extend(config, oldconfig);

 	config.blocking = false;

 	var urlConfigHtml = '', len = config.urlConfig.length;

 	for ( var i = 0, val; i < len, val = config.urlConfig[i]; i++ ) {

 		config[val] = QUnit.urlParams[val];

 		urlConfigHtml += '<label><input name="' + val + '" type="checkbox"' + ( config[val] ? ' checked="checked"' : '' ) + '>' + val + '</label>';

 	}

 	var userAgent = id("qunit-userAgent");

 	if ( userAgent ) {

 		userAgent.innerHTML = navigator.userAgent;

 	}

 	var banner = id("qunit-header");

 	if ( banner ) {

 		banner.innerHTML = '<a href="' + QUnit.url({ filter: undefined }) + '"> ' + banner.innerHTML + '</a> ' + urlConfigHtml;

 		addEvent( banner, "change", function( event ) {

 			var params = {};

 			params[ event.target.name ] = event.target.checked ? true : undefined;

 			window.location = QUnit.url( params );

 		});

 	}

 	var toolbar = id("qunit-testrunner-toolbar");

 	if ( toolbar ) {

 		var filter = document.createElement("input");

 		filter.type = "checkbox";

 		filter.id = "qunit-filter-pass";

 		addEvent( filter, "click", function() {

 			var ol = document.getElementById("qunit-tests");

 			if ( filter.checked ) {

 				ol.className = ol.className + " hidepass";

 			} else {

 				var tmp = " " + ol.className.replace( /[\n\t\r]/g, " " ) + " ";

 				ol.className = tmp.replace(/ hidepass /, " ");

 			}

 			if ( defined.sessionStorage ) {

 				if (filter.checked) {

 					sessionStorage.setItem("qunit-filter-passed-tests", "true");

 				} else {

 					sessionStorage.removeItem("qunit-filter-passed-tests");

 				}

 			}

 		});

 		if ( config.hidepassed || defined.sessionStorage && sessionStorage.getItem("qunit-filter-passed-tests") ) {

 			filter.checked = true;

 			var ol = document.getElementById("qunit-tests");

 			ol.className = ol.className + " hidepass";

 		}

 		toolbar.appendChild( filter );

 		var label = document.createElement("label");

 		label.setAttribute("for", "qunit-filter-pass");

 		label.innerHTML = "Hide passed tests";

 		toolbar.appendChild( label );

 	}

 	var main = id('qunit-fixture');

 	if ( main ) {

 		config.fixture = main.innerHTML;

 	}

 	if (config.autostart) {

 		QUnit.start();

 	}

 };

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

 function done() {

 	config.autorun = true;

 	// Log the last module results

 	if ( config.currentModule ) {

 		QUnit.moduleDone( {

 			name: config.currentModule,

 			failed: config.moduleStats.bad,

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

 			total: config.moduleStats.all

 		} );

 	}

 	var banner = id("qunit-banner"),

 		tests = id("qunit-tests"),

 		runtime = +new Date - config.started,

 		passed = config.stats.all - config.stats.bad,

 		html = [

 			'Tests completed in ',

 			runtime,

 			' milliseconds.<br/>',

 			'<span class="passed">',

 			passed,

 			'</span> tests of <span class="total">',

 			config.stats.all,

 			'</span> passed, <span class="failed">',

 			config.stats.bad,

 			'</span> failed.'

 		].join('');

 	if ( banner ) {

 		banner.className = (config.stats.bad ? "qunit-fail" : "qunit-pass");

 	}

 	if ( tests ) {

 		id( "qunit-testresult" ).innerHTML = html;

 	}

 	if ( config.altertitle && typeof document !== "undefined" && document.title ) {

 		// show ✖ for good, ✔ for bad suite result in title

 		// use escape sequences in case file gets loaded with non-utf-8-charset

 		document.title = [

 			(config.stats.bad ? "\u2716" : "\u2714"),

 			document.title.replace(/^[\u2714\u2716] /i, "")

 		].join(" ");

 	}

 	QUnit.done( {

 		failed: config.stats.bad,

 		passed: passed,

 		total: config.stats.all,

 		runtime: runtime

 	} );

 }

 function validTest( name ) {

 	var filter = config.filter,

 		run = false;

 	if ( !filter ) {

 		return true;

 	}

 	var not = filter.charAt( 0 ) === "!";

 	if ( not ) {

 		filter = filter.slice( 1 );

 	}

 	if ( name.indexOf( filter ) !== -1 ) {

 		return !not;

 	}

 	if ( not ) {

 		run = true;

 	}

 	return run;

 }

 // so far supports only Firefox, Chrome and Opera (buggy)

 // could be extended in the future to use something like https://github.com/csnover/TraceKit

 function sourceFromStacktrace() {

 	try {

 		throw new Error();

 	} catch ( e ) {

 		if (e.stacktrace) {

 			// Opera

 			return e.stacktrace.split("\n")[6];

 		} else if (e.stack) {

 			// Firefox, Chrome

 			return e.stack.split("\n")[4];

 		} else if (e.sourceURL) {

 			// Safari, PhantomJS

 			// TODO sourceURL points at the 'throw new Error' line above, useless

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

 		}

 	}

 }

 function escapeHtml(s) {

 	if (!s) {

 		return "";

 	}

 	s = s + "";

 	return s.replace(/[\&"<>\\]/g, function(s) {

 		switch(s) {

 			case "&": return "&";

 			case "\\": return "\\\\";

 			case '"': return '\"';

 			case "<": return "&lt;";

 			case ">": return ">";

 			default: return s;

 		}

 	});

 }

 function synchronize( callback ) {

 	config.queue.push( callback );

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

 		process();

 	}

 }

 function process() {

 	var start = (new Date()).getTime();

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

 		if ( config.updateRate <= 0 || (((new Date()).getTime() - start) < config.updateRate) ) {

 			config.queue.shift()();

 		} else {

 			window.setTimeout( process, 13 );

 			break;

 		}

 	}

 	if (!config.blocking && !config.queue.length) {

 		done();

 	}

 }

 function saveGlobal() {

 	config.pollution = [];

 	if ( config.noglobals ) {

 		for ( var key in window ) {

 			config.pollution.push( key );

 		}

 	}

 }

 function checkPollution( name ) {

 	var old = config.pollution;

 	saveGlobal();

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

 	if ( newGlobals.length > 0 ) {

 		ok( false, "Introduced global variable(s): " + newGlobals.join(", ") );

 	}

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

 	if ( deletedGlobals.length > 0 ) {

 		ok( false, "Deleted global variable(s): " + deletedGlobals.join(", ") );

 	}

 }

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

 function diff( a, b ) {

 	var result = a.slice();

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

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

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

 				result.splice(i, 1);

 				i--;

 				break;

 			}

 		}

 	}

 	return result;

 }

 function fail(message, exception, callback) {

 	if ( typeof console !== "undefined" && console.error && console.warn ) {

 		console.error(message);

 		console.error(exception);

 		console.warn(callback.toString());

 	} else if ( window.opera && opera.postError ) {

 		opera.postError(message, exception, callback.toString);

 	}

 }

 function extend(a, b) {

 	for ( var prop in b ) {

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

 			delete a[prop];

 		} else {

 			a[prop] = b[prop];

 		}

 	}

 	return a;

 }

 function addEvent(elem, type, fn) {

 	if ( elem.addEventListener ) {

 		elem.addEventListener( type, fn, false );

 	} else if ( elem.attachEvent ) {

 		elem.attachEvent( "on" + type, fn );

 	} else {

 		fn();

 	}

 }

 function id(name) {

 	return !!(typeof document !== "undefined" && document && document.getElementById) &&

 		document.getElementById( name );

 }

 // Test for equality any JavaScript type.

 // Discussions and reference: http://philrathe.com/articles/equiv

 // Test suites: http://philrathe.com/tests/equiv

 // Author: Philippe Rathé <prathe@gmail.com>

 QUnit.equiv = function () {

 	var innerEquiv; // the real equiv function

 	var callers = []; // stack to decide between skip/abort functions

 	var parents = []; // stack to avoiding loops from circular referencing

 	// Call the o related callback with the given arguments.

 	function bindCallbacks(o, callbacks, args) {

 		var prop = QUnit.objectType(o);

 		if (prop) {

 			if (QUnit.objectType(callbacks[prop]) === "function") {

 				return callbacks[prop].apply(callbacks, args);

 			} else {

 				return callbacks[prop]; // or undefined

 			}

 		}

 	}

 	var callbacks = function () {

 		// for string, boolean, number and null

 		function useStrictEquality(b, a) {

 			if (b instanceof a.constructor || a instanceof b.constructor) {

 				// to catch short annotaion VS 'new' annotation of a

 				// declaration

 				// e.g. var i = 1;

 				// var j = new Number(1);

 				return a == b;

 			} else {

 				return a === b;

 			}

 		}

 		return {

 			"string" : useStrictEquality,

 			"boolean" : useStrictEquality,

 			"number" : useStrictEquality,

 			"null" : useStrictEquality,

 			"undefined" : useStrictEquality,

 			"nan" : function(b) {

 				return isNaN(b);

 			},

 			"date" : function(b, a) {

 				return QUnit.objectType(b) === "date"

 						&& a.valueOf() === b.valueOf();

 			},

 			"regexp" : function(b, a) {

 				return QUnit.objectType(b) === "regexp"

 						&& a.source === b.source && // the regex itself

 						a.global === b.global && // and its modifers

 													// (gmi) ...

 						a.ignoreCase === b.ignoreCase

 						&& a.multiline === b.multiline;

 			},

 			// - skip when the property is a method of an instance (OOP)

 			// - abort otherwise,

 			// initial === would have catch identical references anyway

 			"function" : function() {

 				var caller = callers[callers.length - 1];

 				return caller !== Object && typeof caller !== "undefined";

 			},

 			"array" : function(b, a) {

 				var i, j, loop;

 				var len;

 				// b could be an object literal here

 				if (!(QUnit.objectType(b) === "array")) {

 					return false;

 				}

 				len = a.length;

 				if (len !== b.length) { // safe and faster

 					return false;

 				}

 				// track reference to avoid circular references

 				parents.push(a);

 				for (i = 0; i < len; i++) {

 					loop = false;

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

 						if (parents[j] === a[i]) {

 							loop = true;// dont rewalk array

 						}

 					}

 					if (!loop && !innerEquiv(a[i], b[i])) {

 						parents.pop();

 						return false;

 					}

 				}

 				parents.pop();

 				return true;

 			},

 			"object" : function(b, a) {

 				var i, j, loop;

 				var eq = true; // unless we can proove it

 				var aProperties = [], bProperties = []; // collection of

 														// strings

 				// comparing constructors is more strict than using

 				// instanceof

 				if (a.constructor !== b.constructor) {

 					return false;

 				}

 				// stack constructor before traversing properties

 				callers.push(a.constructor);

 				// track reference to avoid circular references

 				parents.push(a);

 				for (i in a) { // be strict: don't ensures hasOwnProperty

 								// and go deep

 					loop = false;

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

 						if (parents[j] === a[i])

 							loop = true; // don't go down the same path

 											// twice

 					}

 					aProperties.push(i); // collect a's properties

 					if (!loop && !innerEquiv(a[i], b[i])) {

 						eq = false;

 						break;

 					}

 				}

 				callers.pop(); // unstack, we are done

 				parents.pop();

 				for (i in b) {

 					bProperties.push(i); // collect b's properties

 				}

 				// Ensures identical properties name

 				return eq

 						&& innerEquiv(aProperties.sort(), bProperties

 								.sort());

 			}

 		};

 	}();

 	innerEquiv = function() { // can take multiple arguments

 		var args = Array.prototype.slice.apply(arguments);

 		if (args.length < 2) {

 			return true; // end transition

 		}

 		return (function(a, b) {

 			if (a === b) {

 				return true; // catch the most you can

 			} else if (a === null || b === null || typeof a === "undefined"