/*

 * QUnit - A JavaScript Unit Testing Framework

 * 

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

 *

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

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

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

 */

(function(window) {

var QUnit = {

	// Initialize the configuration options

	init: function() {

		config = {

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

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

			started: +new Date,

			updateRate: 1000,

			blocking: false,

			autorun: false,

			assertions: [],

			filters: [],

			queue: []

		};

		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 );

		}

	},

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

	module: function(name, testEnvironment) {

		config.currentModule = name;

		synchronize(function() {

			if ( config.currentModule ) {

				QUnit.moduleDone( config.currentModule, config.moduleStats.bad, config.moduleStats.all );

			}

			config.currentModule = name;

			config.moduleTestEnvironment = testEnvironment;

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

			QUnit.moduleStart( name, 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 = testName, testEnvironment, 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 = config.currentModule + " module: " + name;

		}

		if ( !validTest(name) ) {

			return;

		}

		synchronize(function() {

			QUnit.testStart( testName );

			testEnvironment = extend({

				setup: function() {},

				teardown: function() {}

			}, config.moduleTestEnvironment);

			if (testEnvironmentArg) {

				extend(testEnvironment,testEnvironmentArg);

			}

			// allow utility functions to access the current test environment

			QUnit.current_testEnvironment = testEnvironment;

			config.assertions = [];

			config.expected = expected;

			try {

				if ( !config.pollution ) {

					saveGlobal();

				}

				testEnvironment.setup.call(testEnvironment);

			} catch(e) {

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

			}

			if ( async ) {

				QUnit.stop();

			}

			try {

				callback.call(testEnvironment);

			} catch(e) {

				fail("Test " + name + " died, exception and test follows", e, callback);

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

				// else next test will carry the responsibility

				saveGlobal();

				// Restart the tests if they're blocking

				if ( config.blocking ) {

					start();

				}

			}

		});

		synchronize(function() {

			try {

				checkPollution();

				testEnvironment.teardown.call(testEnvironment);

			} catch(e) {

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

			}

			try {

				QUnit.reset();

			} catch(e) {

				fail("reset() failed, following Test " + name + ", exception and reset fn follows", e, reset);

			}

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

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

			}

			var good = 0, bad = 0,

				tests = id("qunit-tests");

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

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

			if ( tests ) {

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

				ol.style.display = "none";

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

					var assertion = config.assertions[i];

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

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

					li.appendChild(document.createTextNode(assertion.message || "(no message)"));

					ol.appendChild( li );

					if ( assertion.result ) {

						good++;

					} else {

						bad++;

						config.stats.bad++;

						config.moduleStats.bad++;

					}

				}

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

				b.innerHTML = name + " <b style='color:black;'>(<b class='fail'>" + bad + "</b>, <b class='pass'>" + good + "</b>, " + config.assertions.length + ")</b>";

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

					var next = b.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() === "strong" ) {

						var text = "", node = target.firstChild;

						while ( node.nodeType === 3 ) {

							text += node.nodeValue;

							node = node.nextSibling;

						}

						text = text.replace(/(^\s*|\s*$)/g, "");

						if ( window.location ) {

							window.location.href = window.location.href.match(/^(.+?)(\?.*)?$/)[1] + "?" + encodeURIComponent(text);

						}

					}

				});

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

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

				li.appendChild( b );

				li.appendChild( ol );

				tests.appendChild( li );

				if ( bad ) {

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

					if ( toolbar ) {

						toolbar.style.display = "block";

						id("qunit-filter-pass").disabled = null;

						id("qunit-filter-missing").disabled = null;

					}

				}

			} else {

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

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

						bad++;

						config.stats.bad++;

						config.moduleStats.bad++;

					}

				}

			}

			QUnit.testDone( testName, bad, config.assertions.length );

			if ( !window.setTimeout && !config.queue.length ) {

				done();

			}

		});

		if ( window.setTimeout && !config.doneTimer ) {

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

				if ( !config.queue.length ) {

					done();

				} else {

					synchronize( done );

				}

			}, 13);

		}

	},

	/**

	 * 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.expected = asserts;

	},

	/**

	 * Asserts true.

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

	 */

	ok: function(a, msg) {

		QUnit.log(a, msg);

		config.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) {

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

	},

	notEqual: function(actual, expected, message) {

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

	},

	deepEqual: function(a, b, message) {

		push(QUnit.equiv(a, b), a, b, message);

	},

	notDeepEqual: function(a, b, message) {

		push(!QUnit.equiv(a, b), a, b, message);

	},

	strictEqual: function(actual, expected, message) {

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

	},

	notStrictEqual: function(actual, expected, message) {

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

	},

	start: function() {

		// A slight delay, to avoid any current callbacks

		if ( window.setTimeout ) {

			window.setTimeout(function() {

				if ( config.timeout ) {

					clearTimeout(config.timeout);

				}

				config.blocking = false;

				process();

			}, 13);

		} else {

			config.blocking = false;

			process();

		}

	},

	stop: function(timeout) {

		config.blocking = true;

		if ( timeout && window.setTimeout ) {

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

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

				QUnit.start();

			}, timeout);

		}

	},

	/**

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

	 */

	reset: function() {

		if ( window.jQuery ) {

			jQuery("#main").html( config.fixture );

			jQuery.event.global = {};

			jQuery.ajaxSettings = extend({}, config.ajaxSettings);

		}

	},

	/**

	 * 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 );