/*

 * 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,

			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.innerHTML = 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 );

		} else if ( elem.fireEvent ) {

			elem.fireEvent("on"+type);

		}

	},

	// Safe object type checking

	is: function( type, obj ) {

		return Object.prototype.toString.call( obj ) === "[object "+ type +"]";

	},

	// Logging callbacks

	done: function(failures, total) {},

	log: function(result, message) {},

	testStart: function(name) {},

	testDone: function(name, failures, total) {},

	moduleStart: function(name, testEnvironment) {},

	moduleDone: function(name, failures, total) {}

};

// 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

};

// Load paramaters

(function() {

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

		GETParams = location.search.slice(1).split('&');

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

		GETParams[i] = decodeURIComponent( GETParams[i] );

		if ( GETParams[i] === "noglobals" ) {

			GETParams.splice( i, 1 );

			i--;

			config.noglobals = true;

		} else if ( GETParams[i].search('=') > -1 ) {

			GETParams.splice( i, 1 );

			i--;

		}

	}

	// restrict modules/tests by get parameters

	config.filters = GETParams;

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

}

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

	config.autorun = true;

}

addEvent(window, "load", function() {

	// Initialize the config, saving the execution queue

	var oldconfig = extend({}, config);

	QUnit.init();

	extend(config, oldconfig);

	config.blocking = false;

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

	if ( userAgent ) {

		userAgent.innerHTML = navigator.userAgent;

	}

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

	if ( toolbar ) {

		toolbar.style.display = "none";

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

		filter.type = "checkbox";

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

		filter.disabled = true;

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

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

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

				if ( li[i].className.indexOf("pass") > -1 ) {

					li[i].style.display = filter.checked ? "none" : "";

				}

			}

		});

		toolbar.appendChild( filter );

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

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

		label.innerHTML = "Hide passed tests";

		toolbar.appendChild( label );

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

		missing.type = "checkbox";

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

		missing.disabled = true;

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

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

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

				if ( li[i].className.indexOf("fail") > -1 && li[i].innerHTML.indexOf('missing test - untested code is broken code') > - 1 ) {

					li[i].parentNode.parentNode.style.display = missing.checked ? "none" : "block";

				}

			}

		});

		toolbar.appendChild( missing );

		label = document.createElement("label");

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

		label.innerHTML = "Hide missing tests (untested code is broken code)";

		toolbar.appendChild( label );

	}

	var main = id('main');

	if ( main ) {

		config.fixture = main.innerHTML;

	}

	if ( window.jQuery ) {

		config.ajaxSettings = window.jQuery.ajaxSettings;

	}

	QUnit.start();

});

function done() {

	if ( config.doneTimer && window.clearTimeout ) {

		window.clearTimeout( config.doneTimer );

		config.doneTimer = null;

	}

	if ( config.queue.length ) {

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

			if ( !config.queue.length ) {

				done();

			} else {

				synchronize( done );

			}

		}, 13);

		return;

	}

	config.autorun = true;

	// Log the last module results

	if ( config.currentModule ) {

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

	}

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

		tests = id("qunit-tests"),

		html = ['Tests completed in ',

		+new Date - config.started, ' milliseconds.<br/>',

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