Externals: updated QUnit to http://github.com/jquery/qunit commit 67ba5a338d836014c24345dc218ab3c9bb63b06e

The various updates to the unit test suites introduced 0 regressions due to update of QUnit, however the addition of jquery.ui.dialog.css to the dialog test suite did introduce one regression, to the dialog option height tests.
Also removed some old crufty woefully incomplete unused and rotted test harnesses.

5 files changed, 1162 insertions, 1204 deletions

diff --git a/external/jsdiff.js b/external/jsdiff.js
deleted file mode 100644
index 31c3a273e..000000000
--- a/external/jsdiff.js
+++ /dev/null
@@ -1,159 +0,0 @@
-/*
- * Javascript Diff Algorithm
- *  By John Resig (http://ejohn.org/)
- *  Modified by Chu Alan "sprite"
- *
- * More Info:
- *  http://ejohn.org/projects/javascript-diff-algorithm/
- */
-
-function escape(s) {
-    var n = s;
-    n = n.replace(/&/g, "&");
-    n = n.replace(/</g, "&lt;");
-    n = n.replace(/>/g, "&gt;");
-    n = n.replace(/"/g, "&quot;");
-
-    return n;
-}
-
-function diffString( o, n ) {
-  o = o.replace(/\s+$/, '');
-  n = n.replace(/\s+$/, '');
-
-  var out = diff(o == "" ? [] : o.split(/\s+/), n == "" ? [] : n.split(/\s+/) );
-  var str = "";
-
-  var oSpace = o.match(/\s+/g);
-  if (oSpace == null) {
-    oSpace = ["\n"];
-  } else {
-    oSpace.push("\n");
-  }
-  var nSpace = n.match(/\s+/g);
-  if (nSpace == null) {
-    nSpace = ["\n"];
-  } else {
-    nSpace.push("\n");
-  }
-
-  if (out.n.length == 0) {
-      for (var i = 0; i < out.o.length; i++) {
-        str += '<del>' + escape(out.o[i]) + oSpace[i] + "</del>";
-      }
-  } else {
-    if (out.n[0].text == null) {
-      for (n = 0; n < out.o.length && out.o[n].text == null; n++) {
-        str += '<del>' + escape(out.o[n]) + oSpace[n] + "</del>";
-      }
-    }
-
-    for ( var i = 0; i < out.n.length; i++ ) {
-      if (out.n[i].text == null) {
-        str += '<ins>' + escape(out.n[i]) + nSpace[i] + "</ins>";
-      } else {
-        var pre = "";
-
-        for (n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++ ) {
-          pre += '<del>' + escape(out.o[n]) + oSpace[n] + "</del>";
-        }
-        str += " " + out.n[i].text + nSpace[i] + pre;
-      }
-    }
-  }
-  
-  return str;
-}
-
-function randomColor() {
-    return "rgb(" + (Math.random() * 100) + "%, " + 
-                    (Math.random() * 100) + "%, " + 
-                    (Math.random() * 100) + "%)";
-}
-function diffString2( o, n ) {
-  o = o.replace(/\s+$/, '');
-  n = n.replace(/\s+$/, '');
-
-  var out = diff(o == "" ? [] : o.split(/\s+/), n == "" ? [] : n.split(/\s+/) );
-
-  var oSpace = o.match(/\s+/g);
-  if (oSpace == null) {
-    oSpace = ["\n"];
-  } else {
-    oSpace.push("\n");
-  }
-  var nSpace = n.match(/\s+/g);
-  if (nSpace == null) {
-    nSpace = ["\n"];
-  } else {
-    nSpace.push("\n");
-  }
-
-  var os = "";
-  var colors = new Array();
-  for (var i = 0; i < out.o.length; i++) {
-      colors[i] = randomColor();
-
-      if (out.o[i].text != null) {
-          os += '<span style="background-color: ' +colors[i]+ '">' + 
-                escape(out.o[i].text) + oSpace[i] + "</span>";
-      } else {
-          os += "<del>" + escape(out.o[i]) + oSpace[i] + "</del>";
-      }
-  }
-
-  var ns = "";
-  for (var i = 0; i < out.n.length; i++) {
-      if (out.n[i].text != null) {
-          ns += '<span style="background-color: ' +colors[out.n[i].row]+ '">' + 
-                escape(out.n[i].text) + nSpace[i] + "</span>";
-      } else {
-          ns += "<ins>" + escape(out.n[i]) + nSpace[i] + "</ins>";
-      }
-  }
-
-  return { o : os , n : ns };
-}
-
-function diff( o, n ) {
-  var ns = new Object();
-  var os = new Object();
-  
-  for ( var i = 0; i < n.length; i++ ) {
-    if ( ns[ n[i] ] == null )
-      ns[ n[i] ] = { rows: new Array(), o: null };
-    ns[ n[i] ].rows.push( i );
-  }
-  
-  for ( var i = 0; i < o.length; i++ ) {
-    if ( os[ o[i] ] == null )
-      os[ o[i] ] = { rows: new Array(), n: null };
-    os[ o[i] ].rows.push( i );
-  }
-  
-  for ( var i in ns ) {
-    if ( ns[i].rows.length == 1 && typeof(os[i]) != "undefined" && os[i].rows.length == 1 ) {
-      n[ ns[i].rows[0] ] = { text: n[ ns[i].rows[0] ], row: os[i].rows[0] };
-      o[ os[i].rows[0] ] = { text: o[ os[i].rows[0] ], row: ns[i].rows[0] };
-    }
-  }
-  
-  for ( var i = 0; i < n.length - 1; i++ ) {
-    if ( n[i].text != null && n[i+1].text == null && n[i].row + 1 < o.length && o[ n[i].row + 1 ].text == null && 
-         n[i+1] == o[ n[i].row + 1 ] ) {
-      n[i+1] = { text: n[i+1], row: n[i].row + 1 };
-      o[n[i].row+1] = { text: o[n[i].row+1], row: i + 1 };
-    }
-  }
-  
-  for ( var i = n.length - 1; i > 0; i-- ) {
-    if ( n[i].text != null && n[i-1].text == null && n[i].row > 0 && o[ n[i].row - 1 ].text == null && 
-         n[i-1] == o[ n[i].row - 1 ] ) {
-      n[i-1] = { text: n[i-1], row: n[i].row - 1 };
-      o[n[i].row-1] = { text: o[n[i].row-1], row: i - 1 };
-    }
-  }
-  
-  return { o: o, n: n };
-}
-
diff --git a/external/qunit.css b/external/qunit.css
new file mode 100644
index 000000000..5714bf4a5
--- /dev/null
+++ b/external/qunit.css
@@ -0,0 +1,119 @@
+
+ol#qunit-tests {
+	font-family:"Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial;
+	margin:0;
+	padding:0;
+	list-style-position:inside;
+
+	font-size: smaller;
+}
+ol#qunit-tests li{
+	padding:0.4em 0.5em 0.4em 2.5em;
+	border-bottom:1px solid #fff;
+	font-size:small;
+	list-style-position:inside;
+}
+ol#qunit-tests li ol{
+	box-shadow: inset 0px 2px 13px #999;
+	-moz-box-shadow: inset 0px 2px 13px #999;
+	-webkit-box-shadow: inset 0px 2px 13px #999;
+	margin-top:0.5em;
+	margin-left:0;
+	padding:0.5em;
+	background-color:#fff;
+	border-radius:15px;
+	-moz-border-radius: 15px;
+	-webkit-border-radius: 15px;
+}
+ol#qunit-tests li li{
+	border-bottom:none;
+	margin:0.5em;
+	background-color:#fff;
+	list-style-position: inside;
+	padding:0.4em 0.5em 0.4em 0.5em;
+}
+
+ol#qunit-tests li li.pass{
+	border-left:26px solid #C6E746;
+	background-color:#fff;
+	color:#5E740B;
+	}
+ol#qunit-tests li li.fail{
+	border-left:26px solid #EE5757;
+	background-color:#fff;
+	color:#710909;
+}
+ol#qunit-tests li.pass{
+	background-color:#D2E0E6;
+	color:#528CE0;
+}
+ol#qunit-tests li.fail{
+	background-color:#EE5757;
+	color:#000;
+}
+ol#qunit-tests li strong {
+	cursor:pointer;
+}
+h1#qunit-header{
+	background-color:#0d3349;
+	margin:0;
+	padding:0.5em 0 0.5em 1em;
+	color:#fff;
+	font-family:"Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial;
+	border-top-right-radius:15px;
+	border-top-left-radius:15px;
+	-moz-border-radius-topright:15px;
+	-moz-border-radius-topleft:15px;
+	-webkit-border-top-right-radius:15px;
+	-webkit-border-top-left-radius:15px;
+	text-shadow: rgba(0, 0, 0, 0.5) 4px 4px 1px;
+}
+h2#qunit-banner{
+	font-family:"Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial;
+	height:5px;
+	margin:0;
+	padding:0;
+}
+h2#qunit-banner.qunit-pass{
+	background-color:#C6E746;
+}
+h2#qunit-banner.qunit-fail, #qunit-testrunner-toolbar {
+	background-color:#EE5757;
+}
+#qunit-testrunner-toolbar {
+	font-family:"Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial;
+	padding:0;
+	/*width:80%;*/
+	padding:0em 0 0.5em 2em;
+	font-size: small;
+}
+h2#qunit-userAgent {
+	font-family:"Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial;
+	background-color:#2b81af;
+	margin:0;
+	padding:0;
+	color:#fff;
+	font-size: small;
+	padding:0.5em 0 0.5em 2.5em;
+	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
+}
+p#qunit-testresult{
+	font-family:"Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial;
+	margin:0;
+	font-size: small;
+	color:#2b81af;
+	border-bottom-right-radius:15px;
+	border-bottom-left-radius:15px;
+	-moz-border-radius-bottomright:15px;
+	-moz-border-radius-bottomleft:15px;
+	-webkit-border-bottom-right-radius:15px;
+	-webkit-border-bottom-left-radius:15px;
+	background-color:#D2E0E6;
+	padding:0.5em 0.5em 0.5em 2.5em;
+}
+strong b.fail{
+	color:#710909;
+	}
+strong b.pass{
+	color:#5E740B;
+	}
diff --git a/external/qunit.js b/external/qunit.js
new file mode 100644
index 000000000..f2704148e
--- /dev/null
+++ b/external/qunit.js
@@ -0,0 +1,1043 @@
+/*
+ * 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.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 );
+
+		} 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('');
+
+	if ( banner ) {
+		banner.className = (config.stats.bad ? "qunit-fail" : "qunit-pass");
+	}
+
+	if ( tests ) {	
+		var result = id("qunit-testresult");
+
+		if ( !result ) {
+			result = document.createElement("p");
+			result.id = "qunit-testresult";
+			result.className = "result";
+			tests.parentNode.insertBefore( result, tests.nextSibling );
+		}
+
+		result.innerHTML = html;
+	}
+
+	QUnit.done( config.stats.bad, config.stats.all );
+}
+
+function validTest( name ) {
+	var i = config.filters.length,
+		run = false;
+
+	if ( !i ) {
+		return true;
+	}
+	
+	while ( i-- ) {
+		var filter = config.filters[i],
+			not = filter.charAt(0) == '!';
+
+		if ( not ) {
+			filter = filter.slice(1);
+		}
+
+		if ( name.indexOf(filter) !== -1 ) {
+			return !not;
+		}
+
+		if ( not ) {
+			run = true;
+		}
+	}
+
+	return run;
+}
+
+function push(result, actual, expected, message) {
+	message = message || (result ? "okay" : "failed");
+	QUnit.ok( result, result ? message + ": " + expected : message + ", expected: " + QUnit.jsDump.parse(expected) + " result: " + QUnit.jsDump.parse(actual) );
+}
+
+function synchronize( callback ) {
+	config.queue.push( callback );
+
+	if ( config.autorun && !config.blocking ) {
+		process();
+	}
+}
+
+function process() {
+	while ( config.queue.length && !config.blocking ) {
+		config.queue.shift()();
+	}
+}
+
+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( old, config.pollution );
+	if ( newGlobals.length > 0 ) {
+		ok( false, "Introduced global variable(s): " + newGlobals.join(", ") );
+		config.expected++;
+	}
+
+	var deletedGlobals = diff( config.pollution, old );
+	if ( deletedGlobals.length > 0 ) {
+		ok( false, "Deleted global variable(s): " + deletedGlobals.join(", ") );
+		config.expected++;
+	}
+}
+
+// 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 ) {
+		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
+
+
+    // Determine what is o.
+    function hoozit(o) {
+        if (QUnit.is("String", o)) {
+            return "string";
+            
+        } else if (QUnit.is("Boolean", o)) {
+            return "boolean";
+
+        } else if (QUnit.is("Number", o)) {
+
+            if (isNaN(o)) {
+                return "nan";
+            } else {
+                return "number";
+            }
+
+        } else if (typeof o === "undefined") {
+            return "undefined";
+
+        // consider: typeof null === object
+        } else if (o === null) {
+            return "null";
+
+        // consider: typeof [] === object
+        } else if (QUnit.is( "Array", o)) {
+            return "array";
+        
+        // consider: typeof new Date() === object
+        } else if (QUnit.is( "Date", o)) {
+            return "date";
+
+        // consider: /./ instanceof Object;
+        //           /./ instanceof RegExp;
+        //          typeof /./ === "function"; // => false in IE and Opera,
+        //                                          true in FF and Safari
+        } else if (QUnit.is( "RegExp", o)) {
+            return "regexp";
+
+        } else if (typeof o === "object") {
+            return "object";
+
+        } else if (QUnit.is( "Function", o)) {
+            return "function";
+        } else {
+            return undefined;
+        }
+    }
+
+    // Call the o related callback with the given arguments.
+    function bindCallbacks(o, callbacks, args) {
+        var prop = hoozit(o);
+        if (prop) {
+            if (hoozit(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 hoozit(b) === "date" && a.valueOf() === b.valueOf();
+            },
+
+            "regexp": function (b, a) {
+                return hoozit(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;
+                var len;
+
+                // b could be an object literal here
+                if ( ! (hoozit(b) === "array")) {
+                    return false;
+                }
+
+                len = a.length;
+                if (len !== b.length) { // safe and faster
+                    return false;
+                }
+                for (i = 0; i < len; i++) {
+                    if ( ! innerEquiv(a[i], b[i])) {
+                        return false;
+                    }
+                }
+                return true;
+            },
+
+            "object": function (b, a) {
+                var i;
+                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);
+
+                for (i in a) { // be strict: don't ensures hasOwnProperty and go deep
+
+                    aProperties.push(i); // collect a's properties
+
+                    if ( ! innerEquiv(a[i], b[i])) {
+                        eq = false;
+                        break;
+                    }
+                }
+
+                callers.pop(); // unstack, we are done
+
+                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" || typeof b === "undefined" || hoozit(a) !== hoozit(b)) {
+                return false; // don't lose time with error prone cases
+            } else {
+                return bindCallbacks(a, callbacks, [b, a]);
+            }
+
+        // apply transition with (1..n) arguments
+        })(args[0], args[1]) && arguments.callee.apply(this, args.splice(1, args.length -1));
+    };
+
+    return innerEquiv;
+
+}();
+
+/**
+ * jsDump
+ * Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com
+ * Licensed under BSD (http://www.opensource.org/licenses/bsd-license.php)
+ * Date: 5/15/2008
+ * @projectDescription Advanced and extensible data dumping for Javascript.
+ * @version 1.0.0
+ * @author Ariel Flesler
+ * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html}
+ */
+QUnit.jsDump = (function() {
+	function quote( str ) {
+		return '"' + str.toString().replace(/"/g, '\\"') + '"';
+	};
+	function literal( o ) {
+		return o + '';	
+	};
+	function join( pre, arr, post ) {
+		var s = jsDump.separator(),
+			base = jsDump.indent(),
+			inner = jsDump.indent(1);
+		if ( arr.join )
+			arr = arr.join( ',' + s + inner );
+		if ( !arr )
+			return pre + post;
+		return [ pre, inner + arr, base + post ].join(s);
+	};
+	function array( arr ) {
+		var i = arr.length,	ret = Array(i);					
+		this.up();
+		while ( i-- )
+			ret[i] = this.parse( arr[i] );				
+		this.down();
+		return join( '[', ret, ']' );
+	};
+	
+	var reName = /^function (\w+)/;
+	
+	var jsDump = {
+		parse:function( obj, type ) { //type is used mostly internally, you can fix a (custom)type in advance
+			var	parser = this.parsers[ type || this.typeOf(obj) ];
+			type = typeof parser;			
+			
+			return type == 'function' ? parser.call( this, obj ) :
+				   type == 'string' ? parser :
+				   this.parsers.error;
+		},
+		typeOf:function( obj ) {
+			var type;
+			if ( obj === null ) {
+				type = "null";
+			} else if (typeof obj === "undefined") {
+				type = "undefined";
+			} else if (QUnit.is("RegExp", obj)) {
+				type = "regexp";
+			} else if (QUnit.is("Date", obj)) {
+				type = "date";
+			} else if (QUnit.is("Function", obj)) {
+				type = "function";
+			} else if (QUnit.is("Array", obj)) {
+				type = "array";
+			} else if (QUnit.is("Window", obj) || QUnit.is("global", obj)) {
+				type = "window";
+			} else if (QUnit.is("HTMLDocument", obj)) {
+				type = "document";
+			} else if (QUnit.is("HTMLCollection", obj) || QUnit.is("NodeList", obj)) {
+				type = "nodelist";
+			} else if (/^\[object HTML/.test(Object.prototype.toString.call( obj ))) {
+				type = "node";
+			} else {
+				type = typeof obj;
+			}
+			return type;
+		},
+		separator:function() {
+			return this.multiline ?	this.HTML ? '<br />' : '\n' : this.HTML ? '&nbsp;' : ' ';
+		},
+		indent:function( extra ) {// extra can be a number, shortcut for increasing-calling-decreasing
+			if ( !this.multiline )
+				return '';
+			var chr = this.indentChar;
+			if ( this.HTML )
+				chr = chr.replace(/\t/g,'   ').replace(/ /g,'&nbsp;');
+			return Array( this._depth_ + (extra||0) ).join(chr);
+		},
+		up:function( a ) {
+			this._depth_ += a || 1;
+		},
+		down:function( a ) {
+			this._depth_ -= a || 1;
+		},
+		setParser:function( name, parser ) {
+			this.parsers[name] = parser;
+		},
+		// The next 3 are exposed so you can use them
+		quote:quote, 
+		literal:literal,
+		join:join,
+		//
+		_depth_: 1,
+		// This is the list of parsers, to modify them, use jsDump.setParser
+		parsers:{
+			window: '[Window]',
+			document: '[Document]',
+			error:'[ERROR]', //when no parser is found, shouldn't happen
+			unknown: '[Unknown]',
+			'null':'null',
+			undefined:'undefined',
+			'function':function( fn ) {
+				var ret = 'function',
+					name = 'name' in fn ? fn.name : (reName.exec(fn)||[])[1];//functions never have name in IE
+				if ( name )
+					ret += ' ' + name;
+				ret += '(';
+				
+				ret = [ ret, this.parse( fn, 'functionArgs' ), '){'].join('');
+				return join( ret, this.parse(fn,'functionCode'), '}' );
+			},
+			array: array,
+			nodelist: array,
+			arguments: array,
+			object:function( map ) {
+				var ret = [ ];
+				this.up();
+				for ( var key in map )
+					ret.push( this.parse(key,'key') + ': ' + this.parse(map[key]) );
+				this.down();
+				return join( '{', ret, '}' );
+			},
+			node:function( node ) {
+				var open = this.HTML ? '&lt;' : '<',
+					close = this.HTML ? '&gt;' : '>';
+					
+				var tag = node.nodeName.toLowerCase(),
+					ret = open + tag;
+					
+				for ( var a in this.DOMAttrs ) {
+					var val = node[this.DOMAttrs[a]];
+					if ( val )
+						ret += ' ' + a + '=' + this.parse( val, 'attribute' );
+				}
+				return ret + close + open + '/' + tag + close;
+			},
+			functionArgs:function( fn ) {//function calls it internally, it's the arguments part of the function
+				var l = fn.length;
+				if ( !l ) return '';				
+				
+				var args = Array(l);
+				while ( l-- )
+					args[l] = String.fromCharCode(97+l);//97 is 'a'
+				return ' ' + args.join(', ') + ' ';
+			},
+			key:quote, //object calls it internally, the key part of an item in a map
+			functionCode:'[code]', //function calls it internally, it's the content of the function
+			attribute:quote, //node calls it internally, it's an html attribute value
+			string:quote,
+			date:quote,
+			regexp:literal, //regex
+			number:literal,
+			'boolean':literal
+		},
+		DOMAttrs:{//attributes to dump from nodes, name=>realName
+			id:'id',
+			name:'name',
+			'class':'className'
+		},
+		HTML:true,//if true, entities are escaped ( <, >, \t, space and \n )
+		indentChar:'   ',//indentation unit
+		multiline:true //if true, items in a collection, are separated by a \n, else just a space.
+	};
+
+	return jsDump;
+})();
+
+})(this);
diff --git a/external/testrunner-r6588.js b/external/testrunner-r6588.js
deleted file mode 100644
index 1a1b763b7..000000000
--- a/external/testrunner-r6588.js
+++ /dev/null
@@ -1,925 +0,0 @@
-/*

- * QUnit - jQuery unit testrunner

- * 

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

- *

- * $Id: testrunner.js 6588 2009-09-29 00:07:51Z jeresig $

- */

-

-(function() {

-

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

-var equiv = function () {

-

-    var innerEquiv; // the real equiv function

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

-

-

-    // Determine what is o.

-    function hoozit(o) {

-        if (o.constructor === String) {

-            return "string";

-            

-        } else if (o.constructor === Boolean) {

-            return "boolean";

-

-        } else if (o.constructor === Number) {

-

-            if (isNaN(o)) {

-                return "nan";

-            } else {

-                return "number";

-            }

-

-        } else if (typeof o === "undefined") {

-            return "undefined";

-

-        // consider: typeof null === object

-        } else if (o === null) {

-            return "null";

-

-        // consider: typeof [] === object

-        } else if (o instanceof Array) {

-            return "array";

-        

-        // consider: typeof new Date() === object

-        } else if (o instanceof Date) {

-            return "date";

-

-        // consider: /./ instanceof Object;

-        //           /./ instanceof RegExp;

-        //          typeof /./ === "function"; // => false in IE and Opera,

-        //                                          true in FF and Safari

-        } else if (o instanceof RegExp) {

-            return "regexp";

-

-        } else if (typeof o === "object") {

-            return "object";

-

-        } else if (o instanceof Function) {

-            return "function";

-        } else {

-            return undefined;

-        }

-    }

-

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

-    function bindCallbacks(o, callbacks, args) {

-        var prop = hoozit(o);

-        if (prop) {

-            if (hoozit(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 hoozit(b) === "date" && a.valueOf() === b.valueOf();

-            },

-

-            "regexp": function (b, a) {

-                return hoozit(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;

-                var len;

-

-                // b could be an object literal here

-                if ( ! (hoozit(b) === "array")) {

-                    return false;

-                }

-

-                len = a.length;

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

-                    return false;

-                }

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

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

-                        return false;

-                    }

-                }

-                return true;

-            },

-

-            "object": function (b, a) {

-                var i;

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

-

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

-

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

-

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

-                        eq = false;

-                    }

-                }

-

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

-

-                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" || typeof b === "undefined" || hoozit(a) !== hoozit(b)) {

-                return false; // don't lose time with error prone cases

-            } else {

-                return bindCallbacks(a, callbacks, [b, a]);

-            }

-

-        // apply transition with (1..n) arguments

-        })(args[0], args[1]) && arguments.callee.apply(this, args.splice(1, args.length -1));

-    };

-

-    return innerEquiv;

-

-}();

-

-var GETParams = location.search.slice(1).split('&'), ngindex = -1;

-

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

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

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

-		ngindex = i;

-	}

-}

-

-var noglobals = ngindex !== -1;

-

-if ( noglobals ) {

-	GETParams.splice( ngindex, 1 );

-}

-	

-var config = {

-	stats: {

-		all: 0,

-		bad: 0

-	},

-	queue: [],

-	// block until document ready

-	blocking: true,

-	//restrict modules/tests by get parameters

-	filters: GETParams,

-	isLocal: !!(window.location.protocol == 'file:')

-};

-

-// public API as global methods

-extend(window, {

-	test: test,

-	module: module,

-	expect: expect,

-	ok: ok,

-	equals: equals,

-	start: start,

-	stop: stop,

-	reset: reset,

-	isLocal: config.isLocal,

-	same: function(a, b, message) {

-		push(equiv(a, b), a, b, message);

-	},

-	QUnit: {

-		equiv: equiv,

-		ok: ok,

-		done: function(failures, total){},

-		log: function(result, message){}

-	},

-	// legacy methods below

-	isSet: isSet,

-	isObj: isObj,

-	compare: function() {

-		throw "compare is deprecated - use same() instead";

-	},

-	compare2: function() {

-		throw "compare2 is deprecated - use same() instead";

-	},

-	serialArray: function() {

-		throw "serialArray is deprecated - use jsDump.parse() instead";

-	},

-	q: q,

-	t: t,

-	url: url,

-	triggerEvent: triggerEvent

-});

-

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

-	

-	if ( !document.getElementById("header") ) {

-		var header = document.createElement("h1");

-		header.id = "header";

-		header.innerHTML = document.title;

-

-		var banner = document.createElement("h2");

-		banner.id = "banner";

-

-		var userAgent = document.createElement("h2");

-		userAgent.id = "userAgent";

-

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

-		ol.id = "tests";

-

-		document.body.insertBefore( ol, document.body.firstChild );

-		document.body.insertBefore( userAgent, document.body.firstChild );

-		document.body.insertBefore( banner, document.body.firstChild );

-		document.body.insertBefore( header, document.body.firstChild );

-	}

-

-	var userAgent = document.getElementById("userAgent");

-	if ( userAgent ) {

-		userAgent.innerHTML = navigator.userAgent;

-

-		var toolbar = document.createElement("div");

-		toolbar.className = "testrunner-toolbar";

-		userAgent.parentNode.insertBefore( toolbar, userAgent );

-

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

-		filter.type = "checkbox";

-		filter.id = "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" : "block";

-				}

-			}

-		});

-		toolbar.appendChild( filter );

-

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

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

-		label.innerHTML = "Hide passed tests";

-		toolbar.appendChild( label );

-

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

-		missing.type = "checkbox";

-		missing.id = "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", "filter-missing");

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

-		toolbar.appendChild( label );

-	}

-

-	runTest();	

-});

-

-function synchronize(callback) {

-	config.queue.push(callback);

-	if(!config.blocking) {

-		process();

-	}

-}

-

-function process() {

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

-		config.queue.shift()();

-	}

-}

-

-function stop(timeout) {

-	config.blocking = true;

-	if (timeout)

-		config.timeout = setTimeout(function() {

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

-			start();

-		}, timeout);

-}

-function start() {

-	// A slight delay, to avoid any current callbacks

-	setTimeout(function() {

-		if(config.timeout)

-			clearTimeout(config.timeout);

-		config.blocking = false;

-		process();

-	}, 13);

-}

-

-function validTest( name ) {

-	var i = config.filters.length,

-		run = false;

-

-	if( !i )

-		return true;

-	

-	while( i-- ){

-		var filter = config.filters[i],

-			not = filter.charAt(0) == '!';

-		if( not ) 

-			filter = filter.slice(1);

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

-			return !not;

-		if( not )

-			run = true;

-	}

-	return run;

-}

-

-function runTest() {

-	config.blocking = false;

-	var started = +new Date;

-	config.fixture = document.getElementById('main').innerHTML;

-

-	if ( window.jQuery ) {

-		config.ajaxSettings = window.jQuery.ajaxSettings;

-	}

-

-	synchronize(function() {

-		var html = ['Tests completed in ',

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

-			'<span class="bad">', config.stats.all - config.stats.bad, '</span> tests of <span class="all">', config.stats.all, '</span> passed, ', config.stats.bad,' failed.'].join('');

-

-		var result = document.createElement("p");

-		result.id = "testresult";

-		result.className = "result";

-		result.innerHTML = html;

-		document.body.appendChild( result );

-

-		document.getElementById("banner").className +=

-			" " + (config.stats.bad ? "fail" : "pass");

-

-		QUnit.done( config.stats.bad, config.stats.all );

-	});

-}

-

-var pollution;

-

-function saveGlobal(){

-	pollution = [ ];

-	

-	if ( noglobals ) {

-		for ( var key in window ) {

-			pollution.push(key);

-		}

-	}

-}

-

-function checkPollution( name ){

-	var old = pollution;

-	saveGlobal();

-	

-	if ( pollution.length > old.length ){

-		ok( false, "Introduced global variable(s): " + diff(old, pollution).join(", ") );

-		config.expected++;

-	}

-}

-

-function diff( clean, dirty ){

-	var results = [];

-

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

-		for ( var c = 0; c < clean.length; c++ ) {

-			if ( clean[c] === dirty[i] ) {

-				results.push( clean[c] );

-			}

-		}

-	}

-

-	return results;

-}

-

-function test(name, callback) {

-	if ( config.currentModule ) {

-		name = config.currentModule + " module: " + name;

-	}

-

-	var lifecycle = extend({

-		setup: function() {},

-		teardown: function() {}

-	}, config.moduleLifecycle);

-	

-	if ( !validTest(name) ) {

-		return;

-	}

-		

-	var testEnvironment = {};

-	

-	synchronize(function() {

-		config.assertions = [];

-		config.expected = null;

-		try {

-			if ( !pollution ) {

-				saveGlobal();

-			}

-

-			lifecycle.setup.call(testEnvironment);

-		} catch(e) {

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

-		}

-	});

-	synchronize(function() {

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

-		}

-	});

-	synchronize(function() {

-		try {

-			checkPollution();

-			lifecycle.teardown.call(testEnvironment);

-		} catch(e) {

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

-		}

-	});

-	synchronize(function() {

-		try {

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

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

-		ol.style.display = "none";

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

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

-			assertion.result ? good++ : bad++;

-		}

-		config.stats.bad += 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 || window.event).target;

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

-

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

-			}

-		});

-

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

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

-		li.appendChild( b );

-		li.appendChild( ol );

-		document.getElementById("tests").appendChild( li );

-

-		if(bad) {

-			document.getElementById("filter-pass").disabled = null;

-			document.getElementById("filter-missing").disabled = null;

-		}

-	});

-}

-

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

-	}

-}

-

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

-function module(name, lifecycle) {

-	config.currentModule = name;

-	config.moduleLifecycle = lifecycle;

-}

-

-/**

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

- */

-function expect(asserts) {

-	config.expected = asserts;

-}

-

-/**

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

- */

-function reset() {

-	if ( window.jQuery ) {

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

-		jQuery.event.global = {};

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

-	} else {

-		document.getElementById("main").innerHTML = config.fixture;

-	}

-}

-

-/**

- * Asserts true.

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

- */

-function ok(a, msg) {

-	QUnit.log(a, msg);

-

-	config.assertions.push({

-		result: !!a,

-		message: msg

-	});

-}

-

-/**

- * Asserts that two arrays are the same

- */

-function isSet(a, b, msg) {

-	function serialArray( a ) {

-		var r = [];

-		

-		if ( a && a.length )

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

-	            var str = a[i].nodeName;

-	            if ( str ) {

-	                str = str.toLowerCase();

-	                if ( a[i].id )

-	                    str += "#" + a[i].id;

-	            } else

-	                str = a[i];

-	            r.push( str );

-	        }

-	

-		return "[ " + r.join(", ") + " ]";

-	}

-	var ret = true;

-	if ( a && b && a.length != undefined && a.length == b.length ) {

-		for ( var i = 0; i < a.length; i++ )

-			if ( a[i] != b[i] )

-				ret = false;

-	} else

-		ret = false;

-	QUnit.ok( ret, !ret ? (msg + " expected: " + serialArray(b) + " result: " + serialArray(a)) : msg );

-}

-

-/**

- * Asserts that two objects are equivalent

- */

-function isObj(a, b, msg) {

-	var ret = true;

-	

-	if ( a && b ) {

-		for ( var i in a )

-			if ( a[i] != b[i] )

-				ret = false;

-

-		for ( i in b )

-			if ( a[i] != b[i] )

-				ret = false;

-	} else

-		ret = false;

-

-    QUnit.ok( ret, msg );

-}

-

-/**

- * Returns an array of elements with the given IDs, eg.

- * @example q("main", "foo", "bar")

- * @result [<div id="main">, <span id="foo">, <input id="bar">]

- */

-function q() {

-	var r = [];

-	for ( var i = 0; i < arguments.length; i++ )

-		r.push( document.getElementById( arguments[i] ) );

-	return r;

-}

-

-/**

- * Asserts that a select matches the given IDs

- * @example t("Check for something", "//[a]", ["foo", "baar"]);

- * @result returns true if "//[a]" return two elements with the IDs 'foo' and 'baar'

- */

-function t(a,b,c) {

-	var f = jQuery(b);

-	var s = "";

-	for ( var i = 0; i < f.length; i++ )

-		s += (s && ",") + '"' + f[i].id + '"';

-	isSet(f, q.apply(q,c), a + " (" + b + ")");

-}

-

-/**

- * Add random number to url to stop IE from caching

- *

- * @example url("data/test.html")

- * @result "data/test.html?10538358428943"

- *

- * @example url("data/test.php?foo=bar")

- * @result "data/test.php?foo=bar&10538358345554"

- */

-function url(value) {

-	return value + (/\?/.test(value) ? "&" : "?") + new Date().getTime() + "" + parseInt(Math.random()*100000);

-}

-

-/**

- * 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 equals( format("Received {0} bytes.", 2), "Received 2 bytes." );

- *

- * @param Object actual

- * @param Object expected

- * @param String message (optional)

- */

-function equals(actual, expected, message) {

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

-}

-

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

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

-	QUnit.ok( result, result ? message + ": " + expected : message + ", expected: " + jsDump.parse(expected) + " result: " + jsDump.parse(actual) );

-}

-

-/**

- * Trigger an event on an element.

- *

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

- *

- * @param DOMElement elem

- * @param String type

- */

-function triggerEvent( 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);

-	}

-}

-

-function extend(a, b){

-	for ( var prop in b ) {

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

-	}

-}

-

-})();

-

-/**

- * jsDump

- * Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com | http://flesler.blogspot.com

- * Licensed under BSD (http://www.opensource.org/licenses/bsd-license.php)

- * Date: 5/15/2008

- * @projectDescription Advanced and extensible data dumping for Javascript.

- * @version 1.0.0

- * @author Ariel Flesler

- * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html}

- */

-(function(){

-	function quote( str ){

-		return '"' + str.toString().replace(/"/g, '\\"') + '"';

-	};

-	function literal( o ){

-		return o + '';	

-	};

-	function join( pre, arr, post ){

-		var s = jsDump.separator(),

-			base = jsDump.indent(),

-			inner = jsDump.indent(1);

-		if( arr.join )

-			arr = arr.join( ',' + s + inner );

-		if( !arr )

-			return pre + post;

-		return [ pre, inner + arr, base + post ].join(s);

-	};

-	function array( arr ){

-		var i = arr.length,	ret = Array(i);					

-		this.up();

-		while( i-- )

-			ret[i] = this.parse( arr[i] );				

-		this.down();

-		return join( '[', ret, ']' );

-	};

-	

-	var reName = /^function (\w+)/;

-	

-	var jsDump = window.jsDump = {

-		parse:function( obj, type ){//type is used mostly internally, you can fix a (custom)type in advance

-			var	parser = this.parsers[ type || this.typeOf(obj) ];

-			type = typeof parser;			

-			

-			return type == 'function' ? parser.call( this, obj ) :

-				   type == 'string' ? parser :

-				   this.parsers.error;

-		},

-		typeOf:function( obj ){

-			var type = typeof obj,

-				f = 'function';//we'll use it 3 times, save it

-			return type != 'object' && type != f ? type :

-				!obj ? 'null' :

-				obj.exec ? 'regexp' :// some browsers (FF) consider regexps functions

-				obj.getHours ? 'date' :

-				obj.scrollBy ?  'window' :

-				obj.nodeName == '#document' ? 'document' :

-				obj.nodeName ? 'node' :

-				obj.item ? 'nodelist' : // Safari reports nodelists as functions

-				obj.callee ? 'arguments' :

-				obj.call || obj.constructor != Array && //an array would also fall on this hack

-					(obj+'').indexOf(f) != -1 ? f : //IE reports functions like alert, as objects

-				'length' in obj ? 'array' :

-				type;

-		},

-		separator:function(){

-			return this.multiline ?	this.HTML ? '<br />' : '\n' : this.HTML ? '&nbsp;' : ' ';

-		},

-		indent:function( extra ){// extra can be a number, shortcut for increasing-calling-decreasing

-			if( !this.multiline )

-				return '';

-			var chr = this.indentChar;

-			if( this.HTML )

-				chr = chr.replace(/\t/g,'   ').replace(/ /g,'&nbsp;');

-			return Array( this._depth_ + (extra||0) ).join(chr);

-		},

-		up:function( a ){

-			this._depth_ += a || 1;

-		},

-		down:function( a ){

-			this._depth_ -= a || 1;

-		},

-		setParser:function( name, parser ){

-			this.parsers[name] = parser;

-		},

-		// The next 3 are exposed so you can use them

-		quote:quote, 

-		literal:literal,

-		join:join,

-		//

-		_depth_: 1,

-		// This is the list of parsers, to modify them, use jsDump.setParser

-		parsers:{

-			window: '[Window]',

-			document: '[Document]',

-			error:'[ERROR]', //when no parser is found, shouldn't happen

-			unknown: '[Unknown]',

-			'null':'null',

-			undefined:'undefined',

-			'function':function( fn ){

-				var ret = 'function',

-					name = 'name' in fn ? fn.name : (reName.exec(fn)||[])[1];//functions never have name in IE

-				if( name )

-					ret += ' ' + name;

-				ret += '(';

-				

-				ret = [ ret, this.parse( fn, 'functionArgs' ), '){'].join('');

-				return join( ret, this.parse(fn,'functionCode'), '}' );

-			},

-			array: array,

-			nodelist: array,

-			arguments: array,

-			object:function( map ){

-				var ret = [ ];

-				this.up();

-				for( var key in map )

-					ret.push( this.parse(key,'key') + ': ' + this.parse(map[key]) );

-				this.down();

-				return join( '{', ret, '}' );

-			},

-			node:function( node ){

-				var open = this.HTML ? '&lt;' : '<',

-					close = this.HTML ? '&gt;' : '>';

-					

-				var tag = node.nodeName.toLowerCase(),

-					ret = open + tag;

-					

-				for( var a in this.DOMAttrs ){

-					var val = node[this.DOMAttrs[a]];

-					if( val )

-						ret += ' ' + a + '=' + this.parse( val, 'attribute' );

-				}

-				return ret + close + open + '/' + tag + close;

-			},

-			functionArgs:function( fn ){//function calls it internally, it's the arguments part of the function

-				var l = fn.length;

-				if( !l ) return '';				

-				

-				var args = Array(l);

-				while( l-- )

-					args[l] = String.fromCharCode(97+l);//97 is 'a'

-				return ' ' + args.join(', ') + ' ';

-			},

-			key:quote, //object calls it internally, the key part of an item in a map

-			functionCode:'[code]', //function calls it internally, it's the content of the function

-			attribute:quote, //node calls it internally, it's an html attribute value

-			string:quote,

-			date:quote,

-			regexp:literal, //regex

-			number:literal,

-			'boolean':literal

-		},

-		DOMAttrs:{//attributes to dump from nodes, name=>realName

-			id:'id',

-			name:'name',

-			'class':'className'

-		},

-		HTML:false,//if true, entities are escaped ( <, >, \t, space and \n )

-		indentChar:'   ',//indentation unit

-		multiline:true //if true, items in a collection, are separated by a \n, else just a space.

-	};

-

-})();

diff --git a/external/testsuite-r6565.css b/external/testsuite-r6565.css
deleted file mode 100644
index 520d8e6af..000000000
--- a/external/testsuite-r6565.css
+++ /dev/null
@@ -1,120 +0,0 @@
-body, div, h1 { font-family: 'trebuchet ms', verdana, arial; margin: 0; padding: 0 }
-body {font-size: 10pt; }
-h1 { padding: 15px; font-size: large; background-color: #06b; color: white; }
-h1 a { color: white; }
-h2 { padding: 10px; background-color: #eee; color: black; margin: 0; font-size: small; font-weight: normal }
-
-.pass { color: green; } 
-.fail { color: red; } 
-p.result { margin-left: 1em; }
-
-#banner { height: 2em; border-bottom: 1px solid white; }
-h2.pass { background-color: green; }
-h2.fail { background-color: red; }
-
-div.testrunner-toolbar { background: #eee; border-top: 1px solid black; padding: 10px; }
-
-ol#tests li strong { cursor:pointer; }
-
-div#fx-tests h4 {
-	background: red;
-}
-
-div#fx-tests h4.pass {
-	background: green;
-}
-
-div#fx-tests div.box {
-	background: red url(data/cow.jpg) no-repeat;
-	overflow: hidden;
-	border: 2px solid #000;
-}
-
-div#fx-tests div.overflow {
-	overflow: visible;
-}
-
-div.inline {
-	display: inline;
-}
-
-div.autoheight {
-	height: auto;
-}
-
-div.autowidth {
-	width: auto;
-}
-
-div.autoopacity {
-	opacity: auto;
-}
-
-div.largewidth {
-	width: 100px;
-}
-
-div.largeheight {
-	height: 100px;
-}
-
-div.largeopacity {
-	filter: progid:DXImageTransform.Microsoft.Alpha(opacity=100);
-}
-
-div.medwidth {
-	width: 50px;
-}
-
-div.medheight {
-	height: 50px;
-}
-
-div.medopacity {
-	opacity: 0.5;
-	filter: progid:DXImageTransform.Microsoft.Alpha(opacity=50);
-}
-
-div.nowidth {
-	width: 0px;
-}
-
-div.noheight {
-	height: 0px;
-}
-
-div.noopacity {
-	opacity: 0;
-	filter: progid:DXImageTransform.Microsoft.Alpha(opacity=0);
-}
-
-div.hidden {
-	display: none;
-}
-
-div#fx-tests div.widewidth {
-	background-repeat: repeat-x;
-}
-
-div#fx-tests div.wideheight {
-	background-repeat: repeat-y;
-}
-
-div#fx-tests div.widewidth.wideheight {
-	background-repeat: repeat;
-}
-
-div#fx-tests div.noback {
-	background-image: none;
-}
-
-div.chain, div.chain div { width: 100px; height: 20px; position: relative; float: left; }
-div.chain div { position: absolute; top: 0px; left: 0px; }
-
-div.chain.test { background: red; }
-div.chain.test div { background: green; }
-
-div.chain.out { background: green; }
-div.chain.out div { background: red; display: none; }
-
-div#show-tests * { display: none; }