Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/.DS_Store
===================================================================
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

Property changes on: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/.DS_Store
___________________________________________________________________
Name: svn:mime-type
   + application/octet-stream

Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/css/tests.css
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/css/tests.css	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/css/tests.css	(revision 0)
@@ -0,0 +1,42 @@
+body{
+    height: 100%;
+    margin: 0;
+    padding: 0;
+}
+
+html{
+    height: 100%;
+}
+
+.activate {
+    height:3%;
+}
+
+#testFrame{
+    height: 100%;
+    width: 100%;
+    margin: 0;
+    padding: 0;
+    border: none;
+    display: block;
+    overflow: auto;
+}
+
+button{
+    height: auto;
+    width: auto;
+    margin: 0 auto;
+    display: block;
+}
+
+/* These widths are slightly brittle in that if the width of an individual 
+   thumbnail is changed in Lightbox.css these will need to be updated. */
+.width-6-thumbs {
+    width: 1050px !important;
+}
+
+.tabs-min-width {
+    min-width:425px;
+}
+
+
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/_browserRunner.js
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/_browserRunner.js	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/_browserRunner.js	(revision 0)
@@ -0,0 +1,546 @@
+if(window["dojo"]){
+	dojo.provide("doh._browserRunner");
+}
+
+// FIXME: need to add prompting for monkey-do testing
+// FIXME: need to implement progress bar
+// FIXME: need to implement errors in progress bar
+
+(function(){
+	if(window.parent == window){
+		// we're the top-dog window.
+
+		// borrowed from Dojo, etc.
+		var byId = function(id){
+			return document.getElementById(id);
+		};
+
+		var _addOnEvt = function(	type,		// string
+									refOrName,	// function or string
+									scope){		// object, defaults is window
+
+			if(!scope){ scope = window; }
+
+			var funcRef = refOrName;
+			if(typeof refOrName == "string"){
+				funcRef = scope[refOrName];
+			}
+			var enclosedFunc = function(){ return funcRef.apply(scope, arguments); };
+
+			if((window["dojo"])&&(type == "load")){
+				dojo.addOnLoad(enclosedFunc);
+			}else{
+				if(window["attachEvent"]){
+					window.attachEvent("on"+type, enclosedFunc);
+				}else if(window["addEventListener"]){
+					window.addEventListener(type, enclosedFunc, false);
+				}else if(document["addEventListener"]){
+					document.addEventListener(type, enclosedFunc, false);
+				}
+			}
+		};
+
+		//
+		// Over-ride or implement base runner.js-provided methods
+		//
+		var escapeXml = function(str){
+			//summary:
+			//		Adds escape sequences for special characters in XML: &<>"'
+			//		Optionally skips escapes for single quotes
+			return str.replace(/&/gm, "&amp;").replace(/</gm, "&lt;").replace(/>/gm, "&gt;").replace(/"/gm, "&quot;"); // string
+		};
+
+		var _logBacklog = [];
+		var sendToLogPane = function(args, skip){
+			var msg = "";
+			for(var x=0; x<args.length; x++){
+				msg += " "+args[x];
+			}
+
+			msg = escapeXml(msg);
+
+			// workarounds for IE. Wheeee!!!
+			msg = msg.replace("\t", "&nbsp;&nbsp;&nbsp;&nbsp;")
+				.replace(" ", "&nbsp;")
+				.replace("\n", "<br>&nbsp;");
+			if(!byId("logBody")){
+				_logBacklog.push(msg);
+				return;
+			}else if(_logBacklog.length && !skip){
+				var tm;
+				while((tm=_logBacklog.shift())){
+					sendToLogPane(tm, true);
+				}
+			}
+			var tn = document.createElement("div");
+			tn.innerHTML = msg;
+			byId("logBody").appendChild(tn);
+		}
+
+		doh._init = (function(oi){
+			return function(){
+				var lb = byId("logBody");
+				if(lb){
+					// clear the console before each run
+					while(lb.firstChild){
+						lb.removeChild(lb.firstChild);
+					}
+				}
+				this._suiteCount = 0;
+				oi.apply(doh, arguments);
+			}
+		})(doh._init);
+
+		if(this["opera"] && opera.postError){
+			doh.debug = function(){
+				var msg = "";
+				for(var x=0; x<arguments.length; x++){
+					msg += " "+arguments[x];
+				}
+				sendToLogPane([msg]);
+				opera.postError("DEBUG:"+msg);
+			}
+		}else if(window["console"]){
+			if(console.debug){
+				doh.debug = function(){
+					sendToLogPane.call(window, arguments);
+					console.debug.apply(console, arguments);
+				};
+			}else if(console.info){
+				doh.debug = function(){
+					sendToLogPane.call(window, arguments);
+					console.info.apply(console, arguments);
+				};
+			}else{
+				doh.debug = function(){
+					var msg = "";
+					for(var x=0; x<arguments.length; x++){
+						msg += " "+arguments[x];
+					}
+					sendToLogPane([msg]);
+					console.log("DEBUG:"+msg);
+				};
+			}
+		}else{
+			doh.debug = function(){
+				sendToLogPane.call(window, arguments);
+			}
+		}
+
+		var loaded = false;
+		var groupTemplate = null;
+		var testTemplate = null;
+
+		var groupNodes = {};
+
+		var _groupTogglers = {};
+
+		var _getGroupToggler = function(group, toggle){
+			if(_groupTogglers[group]){ return _groupTogglers[group]; }
+			var rolledUp = true;
+			return (_groupTogglers[group] = function(evt, forceOpen){
+				var nodes = groupNodes[group].__items;
+				var x;
+				if(rolledUp||forceOpen){
+					rolledUp = false;
+					for(x=0; x<nodes.length; x++){
+						nodes[x].style.display = "";
+					}
+					toggle.innerHTML = "&#054;";
+				}else{
+					rolledUp = true;
+					for(x=0; x<nodes.length; x++){
+						nodes[x].style.display = "none";
+					}
+					toggle.innerHTML = "&#052;";
+				}
+			});
+		};
+
+		var addGroupToList = function(group){
+			if(!byId("testList")){ return; }
+			var tb = byId("testList").tBodies[0];
+			var tg = groupTemplate.cloneNode(true);
+			var tds = tg.getElementsByTagName("td");
+			var toggle = tds[0];
+			toggle.onclick = _getGroupToggler(group, toggle);
+			var cb = tds[1].getElementsByTagName("input")[0];
+			cb.group = group;
+			cb.onclick = function(evt){
+				doh._groups[group].skip = (!this.checked);
+			}
+			tds[2].innerHTML = "<div class='testGroupName'>"+group+"</div><div style='width:0;'>&nbsp;</div>";
+			tds[3].innerHTML = "";
+
+			tb.appendChild(tg);
+			return tg;
+		}
+
+		var addFixtureToList = function(group, fixture){
+			if(!testTemplate){ return; }
+			var cgn = groupNodes[group];
+			if(!cgn["__items"]){ cgn.__items = []; }
+			var tn = testTemplate.cloneNode(true);
+			var tds = tn.getElementsByTagName("td");
+
+			tds[2].innerHTML = fixture.name;
+			tds[3].innerHTML = "";
+
+			var nn = (cgn.__lastFixture||cgn.__groupNode).nextSibling;
+			if(nn){
+				nn.parentNode.insertBefore(tn, nn);
+			}else{
+				cgn.__groupNode.parentNode.appendChild(tn);
+			}
+			// FIXME: need to make group display toggleable!!
+			tn.style.display = "none";
+			cgn.__items.push(tn);
+			return (cgn.__lastFixture = tn);
+		}
+
+		var getFixtureNode = function(group, fixture){
+			if(groupNodes[group]){
+				return groupNodes[group][fixture.name];
+			}
+			return null;
+		}
+
+		var getGroupNode = function(group){
+			if(groupNodes[group]){
+				return groupNodes[group].__groupNode;
+			}
+			return null;
+		}
+
+		var updateBacklog = [];
+		doh._updateTestList = function(group, fixture, unwindingBacklog){
+			if(!loaded){
+				if(group && fixture){
+					updateBacklog.push([group, fixture]);
+				}
+				return;
+			}else if(updateBacklog.length && !unwindingBacklog){
+				var tr;
+				while((tr=updateBacklog.shift())){
+					doh._updateTestList(tr[0], tr[1], true);
+				}
+			}
+			if(group && fixture){
+				if(!groupNodes[group]){
+					groupNodes[group] = {
+						"__groupNode": addGroupToList(group)
+					};
+				}
+				if(!groupNodes[group][fixture.name]){
+					groupNodes[group][fixture.name] = addFixtureToList(group, fixture)
+				}
+			}
+		}
+
+		doh._testRegistered = doh._updateTestList;
+
+		doh._groupStarted = function(group){
+			if(this._suiteCount == 0){
+				this._runedSuite = 0;
+				this._currentGlobalProgressBarWidth = 0;
+				this._suiteCount = this._testCount;
+			}
+			this._runedSuite++;
+			// console.debug("_groupStarted", group);
+			if(doh._inGroup != group){
+				doh._totalTime = 0;
+				doh._runed = 0;
+				doh._inGroup = group;
+			}
+			var gn = getGroupNode(group);
+			if(gn){
+				gn.className = "inProgress";
+			}
+		}
+
+		doh._groupFinished = function(group, success){
+			// console.debug("_groupFinished", group);
+			var gn = getGroupNode(group);
+			if(gn && doh._inGroup == group){
+				gn.className = (success) ? "success" : "failure";
+				gn.getElementsByTagName("td")[3].innerHTML = doh._totalTime+"ms";
+				gn.getElementsByTagName("td")[2].lastChild.className = "";
+				doh._inGroup = null;
+				//doh._runedSuite++;
+				doh._updateGlobalProgressBar(this._runedSuite/this._suiteCount,success);
+				//doh._runedSuite--;
+				doh._currentGlobalProgressBarWidth = parseInt(this._runedSuite/this._suiteCount*10000)/100;
+				//byId("progressOuter").style.width = parseInt(this._runedSuite/this._suiteCount*100)+"%";
+			}
+			if(doh._inGroup == group){
+				this.debug("Total time for GROUP \"",group,"\" is ",doh._totalTime,"ms");
+			}
+		}
+
+		doh._testStarted = function(group, fixture){
+			// console.debug("_testStarted", group, fixture.name);
+			var fn = getFixtureNode(group, fixture);
+			if(fn){
+				fn.className = "inProgress";
+			}
+		}
+
+		var _nameTimes = {};
+		var _playSound = function(name){
+			if(byId("hiddenAudio") && byId("audio") && byId("audio").checked){
+				// console.debug("playing:", name);
+				var nt = _nameTimes[name];
+				// only play sounds once every second or so
+				if((!nt)||(((new Date)-nt) > 700)){
+					_nameTimes[name] = new Date();
+					var tc = document.createElement("span");
+					byId("hiddenAudio").appendChild(tc);
+					tc.innerHTML = '<embed src="_sounds/'+name+'.wav" autostart="true" loop="false" hidden="true" width="1" height="1"></embed>';
+				}
+			}
+		}
+
+		doh._updateGlobalProgressBar = function(p,success){
+			var outerContainer=byId("progressOuter");
+					
+			var gdiv=outerContainer.childNodes[doh._runedSuite-1];
+			if(!gdiv){
+				gdiv=document.createElement('div');
+				outerContainer.appendChild(gdiv);
+				gdiv.className='success';
+			}
+			if(!success){
+				gdiv._failure=true;
+				gdiv.className='failure';
+			}
+			var tp=parseInt(p*10000)/100;
+			gdiv.style.width = (tp-doh._currentGlobalProgressBarWidth)+"%";
+			return gdiv._failure;
+		}
+		doh._testFinished = function(group, fixture, success){
+			var fn = getFixtureNode(group, fixture);
+			var elapsed = fixture.endTime-fixture.startTime;
+			if(fn){
+				fn.getElementsByTagName("td")[3].innerHTML = elapsed+"ms";
+				fn.className = (success) ? "success" : "failure";
+
+				if(!success){
+					_playSound("doh");
+					var gn = getGroupNode(group);
+					if(gn){
+						gn.className = "failure";
+						_getGroupToggler(group)(null, true);
+					}
+				}
+			}
+			if(doh._inGroup == group){
+				var gn = getGroupNode(group);
+				doh._runed++;
+				if(gn && doh._curTestCount){
+					var p = doh._runed/doh._curTestCount;
+					var groupfail = this._updateGlobalProgressBar((doh._runedSuite+p-1)/doh._suiteCount,success);
+					
+					var pbar = gn.getElementsByTagName("td")[2].lastChild;
+					pbar.className = groupfail?"failure":"success";
+					pbar.style.width = parseInt(p*100)+"%";
+					gn.getElementsByTagName("td")[3].innerHTML = parseInt(p*10000)/100+"%";
+				}
+			}
+			this._totalTime += elapsed;
+			this.debug((success ? "PASSED" : "FAILED"), "test:", fixture.name, elapsed, 'ms');
+		}
+
+		// FIXME: move implementation to _browserRunner?
+		doh.registerUrl = function(	/*String*/ group, 
+										/*String*/ url, 
+										/*Integer*/ timeout){
+			var tg = new String(group);
+			this.register(group, {
+				name: url,
+				setUp: function(){
+					doh.currentGroupName = tg;
+					doh.currentGroup = this;
+					doh.currentUrl = url;
+					this.d = new doh.Deferred();
+					doh.currentTestDeferred = this.d;
+					showTestPage();
+					byId("testBody").src = url;
+				},
+				timeout: timeout||10000, // 10s
+				// timeout: timeout||1000, // 10s
+				runTest: function(){
+					// FIXME: implement calling into the url's groups here!!
+					return this.d;
+				},
+				tearDown: function(){
+					doh.currentGroupName = null;
+					doh.currentGroup = null;
+					doh.currentTestDeferred = null;
+					doh.currentUrl = null;
+					// this.d.errback(false);
+					// byId("testBody").src = "about:blank";
+					showLogPage();
+				}
+			});
+		}
+
+		// 
+		// Utility code for runner.html
+		//
+		// var isSafari = navigator.appVersion.indexOf("Safari") >= 0;
+		var tabzidx = 1;
+		var _showTab = function(toShow, toHide){
+			// FIXME: I don't like hiding things this way.
+			byId(toHide).style.display = "none";
+			with(byId(toShow).style){
+				display = "";
+				zIndex = ++tabzidx;
+			}
+		}
+
+		showTestPage = function(){
+			_showTab("testBody", "logBody");
+		}
+
+		showLogPage = function(){
+			_showTab("logBody", "testBody");
+		}
+
+		var runAll = true;
+		toggleRunAll = function(){
+			// would be easier w/ query...sigh
+			runAll = !runAll;
+			if(!byId("testList")){ return; }
+			var tb = byId("testList").tBodies[0];
+			var inputs = tb.getElementsByTagName("input");
+			var x=0; var tn;
+			while((tn=inputs[x++])){
+				tn.checked = runAll;
+				doh._groups[tn.group].skip = (!runAll);
+			}
+		}
+
+		var listHeightTimer = null;
+		var setListHeight = function(){
+			if(listHeightTimer){
+				clearTimeout(listHeightTimer);
+			}
+			var tl = byId("testList");
+			if(!tl){ return; }
+			listHeightTimer = setTimeout(function(){
+				tl.style.display = "none";
+				tl.style.display = "";
+
+			}, 10);
+		}
+
+		_addOnEvt("resize", setListHeight);
+		_addOnEvt("load", setListHeight);
+		_addOnEvt("load", function(){
+			if(loaded){ return; }
+			loaded = true;
+			groupTemplate = byId("groupTemplate");
+			if(!groupTemplate){ 
+				// make sure we've got an ammenable DOM structure
+				return;
+			}
+			groupTemplate.parentNode.removeChild(groupTemplate);
+			groupTemplate.style.display = "";
+			testTemplate = byId("testTemplate");
+			testTemplate.parentNode.removeChild(testTemplate);
+			testTemplate.style.display = "";
+			doh._updateTestList();
+		});
+
+		_addOnEvt("load", 
+			function(){
+				// let robot code run if it gets to this first
+				var __onEnd = doh._onEnd;
+				doh._onEnd = function(){
+					__onEnd.apply(doh, arguments);
+					if(doh._failureCount == 0){
+						doh.debug("WOOHOO!!");
+						_playSound("woohoo");
+					}else{
+						console.debug("doh._failureCount:", doh._failureCount);
+					}
+					if(byId("play")){
+						toggleRunning();
+					}
+				}
+				if(!byId("play")){ 
+					// make sure we've got an amenable DOM structure
+					return;
+				}
+				var isRunning = false;
+				var toggleRunning = function(){
+					// ugg, this would be so much better w/ dojo.query()
+					if(isRunning){
+						byId("play").style.display = byId("pausedMsg").style.display = "";
+						byId("playingMsg").style.display = byId("pause").style.display = "none";
+						isRunning = false;
+					}else{
+						byId("play").style.display = byId("pausedMsg").style.display = "none";
+						byId("playingMsg").style.display = byId("pause").style.display = "";
+						isRunning = true;
+					}
+				}
+				doh.run = (function(oldRun){
+					return function(){
+						if(!doh._currentGroup){
+							toggleRunning();
+						}
+						return oldRun.apply(doh, arguments);
+					}
+				})(doh.run);
+				var btns = byId("toggleButtons").getElementsByTagName("span");
+				var node; var idx=0;
+				while((node=btns[idx++])){
+					node.onclick = toggleRunning;
+				}
+			}
+		);
+	}else{
+		// we're in an iframe environment. Time to mix it up a bit.
+
+		_doh = window.parent.doh;
+		var _thisGroup = _doh.currentGroupName;
+		var _thisUrl = _doh.currentUrl;
+		if(_thisGroup){
+			doh._testRegistered = function(group, tObj){
+				_doh._updateTestList(_thisGroup, tObj);
+			}
+			doh._onEnd = function(){
+				_doh._errorCount += doh._errorCount;
+				_doh._failureCount += doh._failureCount;
+				_doh._testCount += doh._testCount;
+				// should we be really adding raw group counts?
+				_doh._groupCount += doh._groupCount;
+				_doh.currentTestDeferred.callback(true);
+			}
+			var otr = doh._getTestObj;
+			doh._getTestObj = function(){
+				var tObj = otr.apply(doh, arguments);
+				tObj.name = _thisUrl+"::"+arguments[0]+"::"+tObj.name;
+				return tObj;
+			}
+			doh.debug = doh.hitch(_doh, "debug");
+			doh.registerUrl = doh.hitch(_doh, "registerUrl");
+			doh._testStarted = function(group, fixture){
+				_doh._testStarted(_thisGroup, fixture);
+			}
+			doh._testFinished = function(g, f, s){
+				_doh._testFinished(_thisGroup, f, s);
+			}
+			doh._groupStarted = function(g){
+				if(!this._setParent){
+					_doh._curTestCount = this._testCount;
+					_doh._curGroupCount = this._groupCount;
+					this._setParent = true;
+				}
+			}
+			doh._report = function(){};
+		}
+	}
+
+})();
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/_rhinoRunner.js
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/_rhinoRunner.js	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/_rhinoRunner.js	(revision 0)
@@ -0,0 +1,17 @@
+if(this["dojo"]){
+	dojo.provide("doh._rhinoRunner");
+}
+
+doh.debug = print;
+
+// Override the doh._report method to make it quit with an 
+// appropriate exit code in case of test failures.
+(function(){
+	var oldReport = doh._report;
+	doh._report = function(){
+		oldReport.apply(doh, arguments);
+		if(this._failureCount > 0 || this._errorCount > 0){
+			quit(1);
+		}
+	}
+})();
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/LICENSE
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/LICENSE	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/LICENSE	(revision 0)
@@ -0,0 +1,195 @@
+Dojo is available under *either* the terms of the modified BSD license *or* the
+Academic Free License version 2.1. As a recipient of Dojo, you may choose which
+license to receive this code under (except as noted in per-module LICENSE
+files). Some modules may not be the copyright of the Dojo Foundation. These
+modules contain explicit declarations of copyright in both the LICENSE files in
+the directories in which they reside and in the code itself. No external
+contributions are allowed under licenses which are fundamentally incompatible
+with the AFL or BSD licenses that Dojo is distributed under.
+
+The text of the AFL and BSD licenses is reproduced below. 
+
+-------------------------------------------------------------------------------
+The "New" BSD License:
+**********************
+
+Copyright (c) 2005-2008, The Dojo Foundation
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+  * Redistributions of source code must retain the above copyright notice, this
+    list of conditions and the following disclaimer.
+  * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+  * Neither the name of the Dojo Foundation nor the names of its contributors
+    may be used to endorse or promote products derived from this software
+    without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+-------------------------------------------------------------------------------
+The Academic Free License, v. 2.1:
+**********************************
+
+This Academic Free License (the "License") applies to any original work of
+authorship (the "Original Work") whose owner (the "Licensor") has placed the
+following notice immediately following the copyright notice for the Original
+Work:
+
+Licensed under the Academic Free License version 2.1
+
+1) Grant of Copyright License. Licensor hereby grants You a world-wide,
+royalty-free, non-exclusive, perpetual, sublicenseable license to do the
+following:
+
+a) to reproduce the Original Work in copies;
+
+b) to prepare derivative works ("Derivative Works") based upon the Original
+Work;
+
+c) to distribute copies of the Original Work and Derivative Works to the
+public;
+
+d) to perform the Original Work publicly; and
+
+e) to display the Original Work publicly.
+
+2) Grant of Patent License. Licensor hereby grants You a world-wide,
+royalty-free, non-exclusive, perpetual, sublicenseable license, under patent
+claims owned or controlled by the Licensor that are embodied in the Original
+Work as furnished by the Licensor, to make, use, sell and offer for sale the
+Original Work and Derivative Works.
+
+3) Grant of Source Code License. The term "Source Code" means the preferred
+form of the Original Work for making modifications to it and all available
+documentation describing how to modify the Original Work. Licensor hereby
+agrees to provide a machine-readable copy of the Source Code of the Original
+Work along with each copy of the Original Work that Licensor distributes.
+Licensor reserves the right to satisfy this obligation by placing a
+machine-readable copy of the Source Code in an information repository
+reasonably calculated to permit inexpensive and convenient access by You for as
+long as Licensor continues to distribute the Original Work, and by publishing
+the address of that information repository in a notice immediately following
+the copyright notice that applies to the Original Work.
+
+4) Exclusions From License Grant. Neither the names of Licensor, nor the names
+of any contributors to the Original Work, nor any of their trademarks or
+service marks, may be used to endorse or promote products derived from this
+Original Work without express prior written permission of the Licensor. Nothing
+in this License shall be deemed to grant any rights to trademarks, copyrights,
+patents, trade secrets or any other intellectual property of Licensor except as
+expressly stated herein. No patent license is granted to make, use, sell or
+offer to sell embodiments of any patent claims other than the licensed claims
+defined in Section 2. No right is granted to the trademarks of Licensor even if
+such marks are included in the Original Work. Nothing in this License shall be
+interpreted to prohibit Licensor from licensing under different terms from this
+License any Original Work that Licensor otherwise would have a right to
+license.
+
+5) This section intentionally omitted.
+
+6) Attribution Rights. You must retain, in the Source Code of any Derivative
+Works that You create, all copyright, patent or trademark notices from the
+Source Code of the Original Work, as well as any notices of licensing and any
+descriptive text identified therein as an "Attribution Notice." You must cause
+the Source Code for any Derivative Works that You create to carry a prominent
+Attribution Notice reasonably calculated to inform recipients that You have
+modified the Original Work.
+
+7) Warranty of Provenance and Disclaimer of Warranty. Licensor warrants that
+the copyright in and to the Original Work and the patent rights granted herein
+by Licensor are owned by the Licensor or are sublicensed to You under the terms
+of this License with the permission of the contributor(s) of those copyrights
+and patent rights. Except as expressly stated in the immediately proceeding
+sentence, the Original Work is provided under this License on an "AS IS" BASIS
+and WITHOUT WARRANTY, either express or implied, including, without limitation,
+the warranties of NON-INFRINGEMENT, MERCHANTABILITY or FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY OF THE ORIGINAL WORK IS WITH YOU.
+This DISCLAIMER OF WARRANTY constitutes an essential part of this License. No
+license to Original Work is granted hereunder except under this disclaimer.
+
+8) Limitation of Liability. Under no circumstances and under no legal theory,
+whether in tort (including negligence), contract, or otherwise, shall the
+Licensor be liable to any person for any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License
+or the use of the Original Work including, without limitation, damages for loss
+of goodwill, work stoppage, computer failure or malfunction, or any and all
+other commercial damages or losses. This limitation of liability shall not
+apply to liability for death or personal injury resulting from Licensor's
+negligence to the extent applicable law prohibits such limitation. Some
+jurisdictions do not allow the exclusion or limitation of incidental or
+consequential damages, so this exclusion and limitation may not apply to You.
+
+9) Acceptance and Termination. If You distribute copies of the Original Work or
+a Derivative Work, You must make a reasonable effort under the circumstances to
+obtain the express assent of recipients to the terms of this License. Nothing
+else but this License (or another written agreement between Licensor and You)
+grants You permission to create Derivative Works based upon the Original Work
+or to exercise any of the rights granted in Section 1 herein, and any attempt
+to do so except under the terms of this License (or another written agreement
+between Licensor and You) is expressly prohibited by U.S. copyright law, the
+equivalent laws of other countries, and by international treaty. Therefore, by
+exercising any of the rights granted to You in Section 1 herein, You indicate
+Your acceptance of this License and all of its terms and conditions.
+
+10) Termination for Patent Action. This License shall terminate automatically
+and You may no longer exercise any of the rights granted to You by this License
+as of the date You commence an action, including a cross-claim or counterclaim,
+against Licensor or any licensee alleging that the Original Work infringes a
+patent. This termination provision shall not apply for an action alleging
+patent infringement by combinations of the Original Work with other software or
+hardware.
+
+11) Jurisdiction, Venue and Governing Law. Any action or suit relating to this
+License may be brought only in the courts of a jurisdiction wherein the
+Licensor resides or in which Licensor conducts its primary business, and under
+the laws of that jurisdiction excluding its conflict-of-law provisions. The
+application of the United Nations Convention on Contracts for the International
+Sale of Goods is expressly excluded. Any use of the Original Work outside the
+scope of this License or after its termination shall be subject to the
+requirements and penalties of the U.S. Copyright Act, 17 U.S.C. § 101 et
+seq., the equivalent laws of other countries, and international treaty. This
+section shall survive the termination of this License.
+
+12) Attorneys Fees. In any action to enforce the terms of this License or
+seeking damages relating thereto, the prevailing party shall be entitled to
+recover its costs and expenses, including, without limitation, reasonable
+attorneys' fees and costs incurred in connection with such action, including
+any appeal of such action. This section shall survive the termination of this
+License.
+
+13) Miscellaneous. This License represents the complete agreement concerning
+the subject matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent necessary to
+make it enforceable.
+
+14) Definition of "You" in This License. "You" throughout this License, whether
+in upper or lower case, means an individual or a legal entity exercising rights
+under, and complying with all of the terms of, this License. For legal
+entities, "You" includes any entity that controls, is controlled by, or is
+under common control with you. For purposes of this definition, "control" means
+(i) the power, direct or indirect, to cause the direction or management of such
+entity, whether by contract or otherwise, or (ii) ownership of fifty percent
+(50%) or more of the outstanding shares, or (iii) beneficial ownership of such
+entity.
+
+15) Right to Use. You may use the Original Work in all ways not otherwise
+restricted or conditioned by this License or by law, and Licensor promises not
+to interfere with or be responsible for such uses by You.
+
+This license is Copyright (C) 2003-2004 Lawrence E. Rosen. All rights reserved.
+Permission is hereby granted to copy and distribute this license without
+modification. This license may not be modified without the express written
+permission of its copyright owner.
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/README
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/README	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/README	(revision 0)
@@ -0,0 +1,12 @@
+DOH may be run standalone by issuing a command like the following:
+
+java -jar ../shrinksafe/custom_rhino.jar runner.js testModule=tests.colors
+
+where the testModule argument is optional and custom_rhino.jar is just a
+convenient copy of the Rhino JavaScript engine -- the custom patch is not
+required.
+
+Optional arguments include:
+ * dojoUrl - specifies the location of dojo.js
+ * testUrl - specifies a Javascript file to load with initialization code
+ * testModule - specifies a test module in the dojo package namespace
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/Robot.html
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/Robot.html	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/Robot.html	(revision 0)
@@ -0,0 +1,141 @@
+<html style="margin:0px; padding:0px;">
+<body style="margin:0px; padding:0px; border:0px none;background-color:transparent;" onload="init()">
+<script>
+	// find doh
+	var doc = window.frameElement.ownerDocument;
+	var w = doc.parentWindow || doc.defaultView || top;
+	doh = w.doh;
+
+	function init(){
+		var applet = document.getElementsByTagName('applet')[0];
+
+		doh.robot._killApplet = function(){
+			document.body.removeChild(applet);
+			applet = null;
+		};
+	}
+
+	// the box that the applet writes into to test the user's keyboard capabilities
+	var _robotField = null;
+
+	function _onfocus(robotField){
+		_robotField = robotField;
+		doh.robot._initWheel();
+	}
+
+	function _onblur(e){
+		setTimeout(function(){
+        	        document.body.removeChild(_robotField);
+		},0);
+	}
+
+	function _onmousedown(e){
+		e = e||window.event;
+		if(e.screenX == 0||e.clientX == 0){ return; }
+		var docScreenX = e.screenX-e.clientX;
+		var docScreenY = e.screenY-e.clientY;
+		doh.robot._setDocumentBounds(docScreenX, docScreenY);
+	}
+
+	function _onmousewheel(e){
+		e = e||window.event;
+		doh.robot.mouseWheelSize = e.detail ? (e.detail * -1) : (e.wheelDelta / 120);
+		if(e.preventDefault){ e.preventDefault(); }
+		else { e.returnValue = false; }
+		doh.robot._initKeyboard();
+		return false;
+	}
+
+	var charCode = 32;
+	var keystring = "";
+	var expectedlength = 0;
+
+	doh.robot._nextKeyGroup = function(size){
+		// called from Robot
+		// moves to the next group of keys to press; shift, alt-graph etc.
+		expectedlength = size;
+		keystring = "";
+	};
+
+	function _onkeypress(e){
+		e = e||window.event;
+		var c = e.charCode ? e.charCode :
+                   (e.keyCode ? e.keyCode :
+                   (e.which ? e.which : 0)); // opera
+		if(c == 32){
+			keystring += String.fromCharCode(charCode);
+			charCode = 32;
+			if(keystring.length >= expectedlength){
+				doh.robot._notified(keystring);
+			}
+		}
+		else if(c > 32){ // printable
+			charCode = c;
+		}
+		// keyboard discovery misbehaves on Safari/Mac
+		// prevent default action if possible
+		if(e.preventDefault){ e.preventDefault(); }
+		else { e.returnValue = false; }
+		return false;
+	}
+
+	doh.robot._onKeyboard = function(){
+	 	// called from Robot
+        	// Robot calls _onKeyboard after it finishes discovering the keyboard
+        	// need to untie from Java thread with setTimeout
+        	setTimeout(function(){
+        	        var rf = document.getElementsByTagName('input')[0];
+        	        rf.style.visibility = "hidden";
+			doh.robot._run(window.frameElement);
+        	}, 0);
+	};
+</script>
+<input type="text" tabIndex="-1" style="border:0px none;margin:0px;padding:0px;position:absolute;left:0px;top:0px;width:200px;height:42px;background-color:white;z-index:9999;opacity:0;filter:alpha(opacity=0);cursor:default;"
+	onmousewheel="_onmousewheel(arguments[0])"
+	onmousedown="_onmousedown(arguments[0])"
+	onkeypress="_onkeypress(arguments[0])"
+	onfocus="_onfocus(this)"
+	onblur="_onblur(arguments[0])">
+<script>
+	if(document.getElementsByTagName('input')[0].addEventListener){
+		document.getElementsByTagName('input')[0].addEventListener('DOMMouseScroll', _onmousewheel, false);
+	}
+</script>
+<applet width="1" height="1" code="DOHRobot.class" archive="robot/DOHRobot.jar" MAYSCRIPT style="position:absolute;left:0px;top:22px;"><param name="mayscript" value="true"><param name="scriptable" value="true"><param name="initial_focus" value="false"></applet>
+<script>
+	// if no Java, the applet is officially dead
+	if(/MSIE/.test(navigator.appVersion)){
+		// navigator.javaEnabled() not known for its reliability in IE6
+		try{
+			// applet loads synchronously in IE6
+			document.applets[0].isActive();
+		}catch(e){
+			doh.robot._appletDead=true;
+			// IE skips the dojo.robot XHR test below in the else
+			// since the no java behavior is the same as no applet behavior in IE
+			doh.run();
+		}
+	}else if(!navigator.javaEnabled()){
+		// FF, Safari, Opera etc.
+		// unreliable in IE6
+		doh.robot._appletDead=true;
+		doh.run();
+	}else{
+		// Opera etc. have Java enabled, but load the applet asychronously so it might still be missing from server at this point
+		// Do an XHR to find out if the applet is there
+		// IE is taken care of in the first if, so no need for special ActiveX XHR for it
+		var dohRobotCheck=new XMLHttpRequest();
+		dohRobotCheck.onreadystatechange=function(){
+			if(dohRobotCheck.readyState == 4 && dohRobotCheck.status == 404){
+				// oops! no applet
+				// move the tests along
+				doh.robot._appletDead=true;
+				doh.run();
+			}
+		};
+		dohRobotCheck.open("HEAD", "robot/DOHRobot.jar");
+		dohRobotCheck.send(null);
+	}
+</script>
+</body>
+</html>
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/robot.js
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/robot.js	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/robot.js	(revision 0)
@@ -0,0 +1,486 @@
+if(window["dojo"]){
+	dojo.provide("doh.robot");
+	dojo.experimental("doh.robot");
+	dojo.require("doh.runner");
+}else if(!doh["robot"]){
+	doh.robot={};
+}
+
+if(!doh.robot["_robotLoaded"]){
+(function(){
+
+	// loading state
+	var _robot = null;
+
+	var isSecure = (function(){
+		var key = Math.random();
+		return function(fcn){
+			return key;
+		};
+	})();
+
+	// no dojo available
+	// hijack doh.run instead
+	var _run = doh.run;
+	doh.run = function(){
+		if(!doh.robot._runsemaphore.unlock()){
+			// hijack doh._onEnd to clear the applet
+			// have to do it here because _browserRunner sets it in onload in standalone case
+			var __onEnd = doh._onEnd;
+			doh._onEnd = function(){
+				doh.robot.killRobot();
+				doh._onEnd = __onEnd;
+				doh._onEnd();
+			};
+			// if the iframe requested the applet and got a 404, then _robot is obviously unavailable
+			// at least run the non-robot tests!
+			if(doh.robot._appletDead){
+				doh.robot._onKeyboard();
+			}else{
+				_robot._callLoaded(isSecure());
+			}
+		}
+	};
+
+	var _keyPress = function(/*Number*/ charCode, /*Number*/ keyCode, /*Boolean*/ alt, /*Boolean*/ ctrl, /*Boolean*/ shift, /*Integer, optional*/ delay, /*Boolean*/ async){
+		// internal function to type one non-modifier key
+
+		// typecasting Numbers helps Sun's IE plugin lookup methods that take int arguments
+
+		// otherwise JS will send a double and Sun will complain
+		_robot.typeKey(isSecure(), Number(charCode), Number(keyCode), Boolean(alt), Boolean(ctrl), Boolean(shift), Number(delay||0), Boolean(async||false));
+	};
+
+	doh.robot = {
+	_robotLoaded: true,
+
+	_killApplet: function(){}, // overridden by Robot.html
+
+	killRobot: function(){
+		doh.robot._robotLoaded = false;
+		document.documentElement.className = document.documentElement.className.replace(/ ?dohRobot/);
+		doh.robot._killApplet();
+	},
+
+	// Robot init methods
+
+	// controls access to doh.run
+	// basically, doh.run takes two calls to start the robot:
+	// one (or more after the robot loads) from the test page
+	// one from either the applet or an error condition
+	_runsemaphore: {
+		lock:["lock"],
+		unlock:function(){
+			try{
+				return this.lock.shift();
+			}catch(e){
+				return null;
+			}
+		}	
+	},
+	
+	_initRobot: function(r){
+		// called from Robot
+		// Robot calls _initRobot in its startup sequence
+		// add dohRobot class to HTML element so tests can use that in CSS rules if desired
+		document.documentElement.className = document.documentElement.className.replace(/\S$/, "& ") + "dohRobot";
+		window.scrollTo(0, 0);
+//		document.documentElement.scrollTop = document.documentElement.scrollLeft = 0;
+		_robot = r;
+		_robot._setKey(isSecure());
+		// lazy load
+		doh.run();
+	},
+
+	// some utility functions to help the iframe use private variables
+	_run: function(frame){
+		frame.style.visibility = "hidden";
+		doh.run = _run;
+		doh.run();
+	},
+
+	_initKeyboard: function(){
+		_robot._initKeyboard(isSecure());
+	},
+
+	_initWheel: function(){
+		_robot._initWheel(isSecure());
+	},
+
+	_setDocumentBounds: function(docScreenX, docScreenY){
+		var robotView = document.getElementById("dohrobotview");
+		_robot.setDocumentBounds(isSecure(), Number(docScreenX), Number(docScreenY), Number(robotView.offsetLeft), Number(robotView.offsetTop));
+	},
+
+	_notified: function(keystring){
+		_robot._notified(isSecure(), keystring);
+	},
+
+	_time:0,
+
+	// if the applet is 404 or cert is denied, this becomes true and kills tests
+	_appletDead:false,
+
+	_assertRobot:function(){
+		// make sure the applet is there and cert accepted
+		// otherwise, skip the test requesting the robot action
+		if(doh.robot._appletDead){ throw new Error('doh.robot not available; skipping test.'); }
+	},
+
+	_mouseMove: function(/*Number*/ x, /*Number*/ y, /*Boolean*/ absolute, /*Integer, optional*/ duration){
+        if (typeof (x) === "function") { x = x();} // allows for multiple page scrolls, added by FLUID
+        if (typeof (y) === "function") { y = y();} // allows for multiple page scrolls, added by FLUID
+		if(absolute){
+			var scroll = {y: (window.pageYOffset || document.documentElement.scrollTop || document.body.scrollTop || 0),
+			x: (window.pageXOffset || (window["dojo"]?dojo._fixIeBiDiScrollLeft(document.documentElement.scrollLeft):undefined) || document.body.scrollLeft || 0)};
+			y -= scroll.y;
+			x -= scroll.x;
+		}
+		_robot.moveMouse(isSecure(), Number(x), Number(y), Number(0), Number(duration||100));
+	},
+
+	// Main doh.robot API
+	sequence:function(/*Function*/ f, /*Integer, optional*/ delay, /*Integer, optional*/ duration){
+		// summary:
+		//		Defer an action by adding it to the robot's incrementally delayed queue of actions to execute.
+		//
+		// f:
+		//		A function containing actions you want to defer.
+		//
+		// delay:
+		//		Delay, in milliseconds, to wait before firing.
+		//		The delay is a delta with respect to the previous automation call.
+		//		For example, the following code ends after 600ms:
+		//			doh.robot.mouseClick({left:true}, 100) // first call; wait 100ms
+		//			doh.robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
+		//
+		// duration:
+		//		Delay to wait after firing.
+		//
+
+		delay = delay || 1;
+		doh.robot._time += delay;
+		setTimeout(function(){
+			doh.robot._time -= delay;
+			f();
+			if(duration){
+				setTimeout(function(){
+					doh.robot._time -= duration;
+				}, duration);
+			}
+		}, doh.robot._time);
+		if(duration){
+			doh.robot._time += duration;
+		}
+	},
+
+	typeKeys: function(/*String||Number*/ chars, /*Integer, optional*/ delay, /*Integer, optional*/ duration){
+		// summary:
+		//		Types a string of characters in order, or types a dojo.keys.* constant.
+		//
+		// description:
+		// 		Types a string of characters in order, or types a dojo.keys.* constant.
+		// 		Example: doh.robot.typeKeys("dijit.ed", 500);
+		//
+		// chars:
+		//		String of characters to type, or a dojo.keys.* constant
+		//
+		// delay:
+		//		Delay, in milliseconds, to wait before firing.
+		//		The delay is a delta with respect to the previous automation call.
+		//		For example, the following code ends after 600ms:
+		//			doh.robot.mouseClick({left:true}, 100) // first call; wait 100ms
+		//			doh.robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
+		//
+		// duration:
+		//		Time, in milliseconds, to spend pressing all of the keys.
+		//
+
+		this._assertRobot();
+		this.sequence(function(){
+			duration=duration||0;
+			if(typeof(chars) == Number){
+				_keyPress(chars, chars, false, false, false, delay);
+			}else if(chars.length){
+				for(var i = 0; i<chars.length; i++){
+					_keyPress(chars.charCodeAt(i), 0, false, false, false, duration/chars.length);
+				}
+			}
+		}, delay, duration);
+	},
+
+	keyPress: function(/*Integer*/ charOrCode, /*Integer, optional*/ delay, /*Object*/ modifiers, /*Boolean*/ asynchronous){
+		// summary:
+		//		Types a key combination, like SHIFT-TAB.
+		//
+		// description:
+		// 		Types a key combination, like SHIFT-TAB.
+		// 		Example: to press shift-tab immediately, call doh.robot.keyPress(dojo.keys.TAB, 0, {shift:true})
+		//
+		// charOrCode:
+		//		char/JS keyCode/dojo.keys.* constant for the key you want to press
+		//
+		// delay:
+		//		Delay, in milliseconds, to wait before firing.
+		//		The delay is a delta with respect to the previous automation call.
+		//		For example, the following code ends after 600ms:
+		//			doh.robot.mouseClick({left:true}, 100) // first call; wait 100ms
+		//			doh.robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
+		//
+		// modifiers:
+		//		JSON object that represents all of the modifier keys being pressed.
+		//		It takes the following Boolean attributes:
+		//			- shift
+		//			- alt
+		//			- ctrl
+		//
+		// asynchronous:
+		//		If true, the delay happens asynchronously and immediately, outside of the browser's JavaScript thread and any previous calls.
+		//		This is useful for interacting with the browser's modal dialogs.
+		//
+
+		this._assertRobot();
+		if(!modifiers){
+			modifiers = {alt:false, ctrl:false, shift:false};
+		}else{
+			// normalize modifiers
+			var attrs = ["alt", "ctrl", "shift"];
+			for(var i = 0; i<attrs.length; i++){
+				if(!modifiers[attrs[i]]){
+					modifiers[attrs[i]] = false;
+				}
+			}
+		}
+		var isChar = typeof(charOrCode)=="string";
+		if(asynchronous){
+			_keyPress(isChar?charOrCode.charCodeAt(0):0, isChar?0:charOrCode, modifiers.alt, modifiers.ctrl, modifiers.shift, delay, true);
+			return;
+		}
+		this.sequence(function(){
+			_keyPress(isChar?charOrCode.charCodeAt(0):0, isChar?0:charOrCode, modifiers.alt, modifiers.ctrl, modifiers.shift, 0);
+		},delay);
+	},
+
+	keyDown: function(/*Integer*/ charOrCode, /*Integer, optional*/ delay){
+		// summary:
+		//		Holds down a single key, like SHIFT or 'a'.
+		//
+		// description:
+		// 		Holds down a single key, like SHIFT or 'a'.
+		// 		Example: to hold down the 'a' key immediately, call doh.robot.keyDown('a')
+		//
+		// charOrCode:
+		//		char/JS keyCode/dojo.keys.* constant for the key you want to hold down
+		//		Warning: holding down a shifted key, like 'A', can have unpredictable results.
+		//
+		// delay:
+		//		Delay, in milliseconds, to wait before firing.
+		//		The delay is a delta with respect to the previous automation call.
+		//		For example, the following code ends after 600ms:
+		//			doh.robot.mouseClick({left:true}, 100) // first call; wait 100ms
+		//			doh.robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
+		//
+
+		this._assertRobot();
+		this.sequence(function(){
+			var isChar = typeof(charOrCode)=="string";
+			_robot.downKey(isSecure(), isChar?charOrCode:0, isChar?0:charOrCode, 0);
+		},delay);
+	},
+
+	keyUp: function(/*Integer*/ charOrCode, /*Integer, optional*/ delay){
+		// summary:
+		//		Releases a single key, like SHIFT or 'a'.
+		//
+		// description:
+		// 		Releases a single key, like SHIFT or 'a'.
+		// 		Example: to release the 'a' key immediately, call doh.robot.keyUp('a')
+		//
+		// charOrCode:
+		//		char/JS keyCode/dojo.keys.* constant for the key you want to release
+		//		Warning: releasing a shifted key, like 'A', can have unpredictable results.
+		//
+		// delay:
+		//		Delay, in milliseconds, to wait before firing.
+		//		The delay is a delta with respect to the previous automation call.
+		//		For example, the following code ends after 600ms:
+		//			doh.robot.mouseClick({left:true}, 100) // first call; wait 100ms
+		//			doh.robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
+		//
+
+		this._assertRobot();
+		this.sequence(function(){
+			var isChar=typeof(charOrCode)=="string";
+			_robot.upKey(isSecure(), isChar?charOrCode:0, isChar?0:charOrCode, 0);
+		},delay);
+	},
+
+
+	mouseClick: function(/*Object*/ buttons, /*Integer, optional*/ delay){
+		// summary:
+		//		Convenience function to do a press/release.
+		//		See doh.robot.mousePress for more info.
+		//
+		// description:
+		//		Convenience function to do a press/release.
+		//		See doh.robot.mousePress for more info.
+		//
+
+		this._assertRobot();
+		doh.robot.mousePress(buttons, delay);
+		doh.robot.mouseRelease(buttons, 1);
+	},
+
+	mousePress: function(/*Object*/ buttons, /*Integer, optional*/ delay){
+		// summary:
+		// 		Presses mouse buttons.
+		// description:
+		// 		Presses the mouse buttons you pass as true.
+		// 		Example: to press the left mouse button, pass {left:true}.
+		// 		Mouse buttons you don't specify keep their previous pressed state.
+		//
+		// buttons:	JSON object that represents all of the mouse buttons being pressed.
+		//		It takes the following Boolean attributes:
+		//			- left
+		//			- middle
+		//			- right
+		//
+		// delay:
+		//		Delay, in milliseconds, to wait before firing.
+		//		The delay is a delta with respect to the previous automation call.
+		//		For example, the following code ends after 600ms:
+		//			doh.robot.mouseClick({left:true}, 100) // first call; wait 100ms
+		//			doh.robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
+		//
+
+		this._assertRobot();
+		if(!buttons){ return; }
+		this.sequence(function(){
+			var attrs = ["left", "middle", "right"];
+			for(var i = 0; i<attrs.length; i++){
+				if(!buttons[attrs[i]]){
+					buttons[attrs[i]] = false;
+				}
+			}
+			_robot.pressMouse(isSecure(), Boolean(buttons.left), Boolean(buttons.middle), Boolean(buttons.right), Number(0));
+		},delay);
+	},
+
+	mouseMove: function(/*Number*/ x, /*Number*/ y, /*Integer, optional*/ delay, /*Integer, optional*/ duration, /*Boolean*/ absolute){
+		// summary:
+		// 		Moves the mouse to the specified x,y offset relative to the viewport.
+		//
+		// x:
+		//		x offset relative to the viewport, in pixels, to move the mouse.
+		//
+		// y:
+		//		y offset relative to the viewport, in pixels, to move the mouse.
+		//
+		// delay:
+		//		Delay, in milliseconds, to wait before firing.
+		//		The delay is a delta with respect to the previous automation call.
+		//		For example, the following code ends after 600ms:
+		//			doh.robot.mouseClick({left:true}, 100) // first call; wait 100ms
+		//			doh.robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
+		//
+		// duration:
+		//		Approximate time Robot will spend moving the mouse
+		//		The default is 100ms.
+		//
+		// absolute:
+		//		Boolean indicating whether the x and y values are absolute coordinates.
+		//		If false, then mouseMove expects that the x,y will be relative to the window. (clientX/Y)
+		//		If true, then mouseMove expects that the x,y will be absolute. (pageX/Y)
+		//
+
+		this._assertRobot();
+		duration = duration||100;
+		this.sequence(function(){
+			doh.robot._mouseMove(x, y, absolute, duration);
+		},delay,duration);
+	},
+
+	mouseRelease: function(/*Object*/ buttons, /*Integer, optional*/ delay){
+		// summary:
+		// 		Releases mouse buttons.
+		//
+		// description:
+		// 		Releases the mouse buttons you pass as true.
+		// 		Example: to release the left mouse button, pass {left:true}.
+		// 		Mouse buttons you don't specify keep their previous pressed state.
+		//		See doh.robot.mousePress for more info.
+		//
+
+		this._assertRobot();
+		if(!buttons){ return; }
+		this.sequence(function(){
+			var attrs = ["left", "middle", "right"];
+			for(var i = 0; i<attrs.length; i++){
+				if(!buttons[attrs[i]]){
+					buttons[attrs[i]] = false;
+				}
+			}
+			_robot.releaseMouse(isSecure(), Boolean(buttons.left), Boolean(buttons.middle), Boolean(buttons.right), Number(0));
+		},delay);
+	},
+
+	// mouseWheelSize: Integer value that determines the amount of wheel motion per unit
+	mouseWheelSize: 1,
+
+	mouseWheel: function(/*Number*/ wheelAmt, /*Integer, optional*/ delay, /*Integer, optional*/ duration){
+		// summary:
+		//		Spins the mouse wheel.
+		//
+		// description:
+		// 		Spins the wheel wheelAmt "notches."
+		// 		Negative wheelAmt scrolls up/away from the user.
+		// 		Positive wheelAmt scrolls down/toward the user.
+		// 		Note: this will all happen in one event.
+		// 		Warning: the size of one mouse wheel notch is an OS setting.
+		//		You can accesss this size from doh.robot.mouseWheelSize
+		//
+		// wheelAmt:
+		//		Number of notches to spin the wheel.
+		// 		Negative wheelAmt scrolls up/away from the user.
+		// 		Positive wheelAmt scrolls down/toward the user.
+		//
+		// delay:
+		//		Delay, in milliseconds, to wait before firing.
+		//		The delay is a delta with respect to the previous automation call.
+		//		For example, the following code ends after 600ms:
+		//			doh.robot.mouseClick({left:true}, 100) // first call; wait 100ms
+		//			doh.robot.typeKeys("dij", 500) // 500ms AFTER previous call; 600ms in all
+		//
+		// duration:
+		//		Approximate time Robot will spend moving the mouse
+		//		By default, the Robot will wheel the mouse as fast as possible.
+		//
+
+
+		this._assertRobot();
+		if(!wheelAmt){ return; }
+		this.sequence(function(){
+			_robot.wheelMouse(isSecure(), Number(wheelAmt), Number(0), Number(duration||0));
+		},delay,duration);
+	}
+	};
+
+	// the applet itself
+	// needs to be down here so the handlers are set up
+	var iframesrc;
+	var scripts = document.getElementsByTagName("script");
+	for(var x = 0; x<scripts.length; x++){
+		var s = scripts[x].src;
+		if(s && (s.substr(s.length-9) == "runner.js")){
+			iframesrc = s.substr(0, s.length-9)+'Robot.html';
+			break;
+		}
+	}
+	// if loaded with dojo, there might not be a runner.js!
+	if(!iframesrc && window["dojo"]){
+		iframesrc = dojo.moduleUrl("util", "doh/")+"Robot.html";
+	}
+	document.writeln('<div id="dohrobotview" style="border:0px none; margin:0px; padding:0px; position:absolute; bottom:0px; right:0px; width:1px; height:1px; overflow:hidden; visibility:hidden; background-color:red;"></div>'+
+		'<iframe style="border:0px none; z-index:32767; padding:0px; margin:0px; position:absolute; left:0px; top:0px; height:42px; width:200px; overflow:hidden; background-color:transparent;" tabIndex="-1" src="'+iframesrc+'" ALLOWTRANSPARENCY="true"></iframe>');
+})();
+}
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/robotx.js
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/robotx.js	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/robotx.js	(revision 0)
@@ -0,0 +1,125 @@
+/*
+	Copyright (c) 2004-2008, The Dojo Foundation All Rights Reserved.
+	Available via Academic Free License >= 2.1 OR the modified BSD license.
+	see: http://dojotoolkit.org/license for details
+*/
+
+
+if(!dojo._hasResource["dojo.robotx"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojo.robotx"] = true;
+dojo.provide("dojo.robotx");
+dojo.require("dojo.robot");
+dojo.experimental("dojo.robotx");
+
+// loads an external app into an iframe and points dojo.doc to the iframe document, allowing the robot to control it
+// to use: set robotURL in djConfig to the URL you want to load
+// dojo.require this file
+
+(function(){
+// have to wait for test page to load before testing!
+doh.robot._runsemaphore.lock.push("dojo.robotx.lock");
+
+var iframe = document.getElementById('robotapplication');
+
+var groupStarted=dojo.connect(doh, '_groupStarted', function(){
+	dojo.disconnect(groupStarted);
+	if(!document.getElementById('robotconsole').childNodes.length){
+		document.body.removeChild(document.getElementById('robotconsole'));
+		iframe.style.height="100%";
+	}
+	iframe.style.visibility="visible";
+});
+
+var onIframeLoad=function(){
+	//iframe = document.getElementById('robotapplication');
+	doh.robot._updateDocument();
+	onIframeLoad = null;
+	doh.run();
+};
+
+var iframeLoad=function(){
+	if(onIframeLoad){
+		onIframeLoad();
+	}
+	var unloadConnect = dojo.connect(dojo.body(), 'onunload', function(){
+		dojo.doc = document;
+		dojo.disconnect(unloadConnect);
+	});
+};
+
+// write the firebug console to a place it will fit
+dojo.config.debugContainerId = "robotconsole";
+document.write('<div id="robotconsole" style="position:absolute;left:0px;top:75%;width:100%; height:25%;"></div>');
+
+// write the iframe
+//document.writeln('<iframe id="robotapplication" style="visibility:hidden; border:0px none; padding:0px; margin:0px; position:absolute; left:0px; top:0px; width:100%; height:100%; z-index: 1;" src="'+dojo.config.robotURL+'" onload="iframeLoad();" ></iframe>');
+iframe = document.createElement('iframe');
+iframe.setAttribute("ALLOWTRANSPARENCY","true");
+dojo.style(iframe,{visibility:'hidden', border:'0px none', padding:'0px', margin:'0px', position:'absolute', left:'0px', top:'0px', width:'100%', height:'75%', zIndex:'1'});
+if(iframe['attachEvent'] !== undefined){
+	iframe.attachEvent('onload', iframeLoad);
+}else{
+	dojo.connect(iframe, 'onload', iframeLoad);
+}
+
+dojo.mixin(doh.robot,{
+	_updateDocument: function(){
+		dojo.doc = iframe.contentWindow.document;
+	},
+
+	initRobot: function(/*String*/ url){
+		// summary:
+		//		Opens the application at the specified URL for testing, redirecting dojo to point to the application environment instead of the test environment.
+		//
+		// url:
+		//		URL to open. Any of the test's dojo.doc calls (e.g. dojo.byId()), and any dijit.registry calls (e.g. dijit.byId()) will point to elements and widgets inside this application.
+		//
+		iframe.src=url;
+		dojo.addOnLoad(function(){
+			dojo.style(document.body,{
+				width: '100%',
+				height: '100%'
+			});
+			document.body.appendChild(iframe);
+			var base=document.createElement('base');
+			base.href=url;
+			document.getElementsByTagName("head")[0].appendChild(base);
+		});
+	},
+
+	waitForPageToLoad: function(/*Function*/ submitActions){
+		// summary:
+		// 		Notifies DOH that the doh.robot is about to make a page change in the application it is driving,
+		//		returning a doh.Deferred object the user should return in their runTest function as part of a DOH test.
+		//
+		// description:
+		// 		Notifies DOH that the doh.robot is about to make a page change in the application it is driving,
+		//		returning a doh.Deferred object the user should return in their runTest function as part of a DOH test.
+		//		Example:
+		//			runTest:function(){
+		//				return waitForPageLoad(function(){ doh.robot.keyPress(dojo.keys.ENTER, 500); });
+		//			}
+		//
+		// submitActions:
+		//		The doh.robot will execute the actions the test passes into the submitActions argument (like clicking the submit button),
+		//		expecting these actions to create a page change (like a form submit).
+		//		After these actions execute and the resulting page loads, the next test will start.
+		//
+
+		var d = new doh.Deferred();
+		// create iframe event handler to track submit progress
+		onIframeLoad = function(){
+			onIframeLoad = null;
+			// set dojo.doc on every page change to point to the iframe doc so the robot works
+			doh.robot._updateDocument();
+			d.callback(true);
+		};
+		submitActions();
+		return d;
+	}
+
+});
+
+})();
+
+}
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/runner.html
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/runner.html	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/runner.html	(revision 0)
@@ -0,0 +1,314 @@
+<html>
+	<!--
+		NOTE: we are INTENTIONALLY in quirks mode. It makes it much easier to
+		get a "full screen" UI w/ straightforward CSS.
+	-->
+	<!--
+		// TODO: implement global progress bar
+		// TODO: provide a UI for prompted tests
+	-->
+	<head>
+		<title>The Dojo Unit Test Harness, $Rev$</title>
+
+		<script type="text/javascript">
+			// workaround for bug in Safari 3.  See #7189
+			if (/3[\.0-9]+ Safari/.test(navigator.appVersion))
+			{
+				window.console = {
+				    origConsole: window.console,
+				    log: function(s){
+						this.origConsole.log(s);
+					},
+					info: function(s){
+						this.origConsole.info(s);
+					},
+					error: function(s){
+						this.origConsole.error(s);
+					},
+					warn: function(s){
+						this.origConsole.warn(s);
+					}
+				};
+			}
+		</script>
+
+		<script type="text/javascript">
+			window.dojoUrl = "../../dojo/dojo.js";
+			window.testUrl = "";
+			window.testModule = "";
+
+			// parse out our test URL and our Dojo URL from the query string
+			var qstr = window.location.search.substr(1);
+			if(qstr.length){
+				var qparts = qstr.split("&");
+				for(var x=0; x<qparts.length; x++){
+					var tp = qparts[x].split("=");
+					if(tp[0] == "dojoUrl"){
+						window.dojoUrl = tp[1];
+					}
+					if(tp[0] == "testUrl"){
+						window.testUrl = tp[1];
+					}
+					if(tp[0] == "testModule"){
+						window.testModule = tp[1];
+					}
+					if(tp[0] == "registerModulePath"){
+						var modules = tp[1].split(";");
+						window.registerModulePath=[];
+						for (var i=0; i<modules.length;i++){
+							window.registerModulePath.push(modules[i].split(","));
+						}
+					}
+				}
+			}
+
+			document.write("<scr"+"ipt type='text/javascript' djConfig='isDebug: true' src='"+dojoUrl+"'></scr"+"ipt>");
+		</script>
+		<script type="text/javascript">
+			try{
+				dojo.require("doh.runner");
+			}catch(e){
+				document.write("<scr"+"ipt type='text/javascript' src='runner.js'></scr"+"ipt>");
+				document.write("<scr"+"ipt type='text/javascript' src='_browserRunner.js'></scr"+"ipt>");
+			}
+			if(testUrl.length){
+				document.write("<scr"+"ipt type='text/javascript' src='"+testUrl+".js'></scr"+"ipt>");
+			}
+		</script>
+		<style type="text/css">
+			@import "../../dojo/resources/dojo.css";
+			/*
+			body {
+				margin: 0px;
+				padding: 0px;
+				font-size: 13px;
+				color: #292929;
+				font-family: Myriad, Lucida Grande, Bitstream Vera Sans, Arial, Helvetica, sans-serif;
+				*font-size: small;
+				*font: x-small;
+			}
+
+			th, td {
+				font-size: 13px;
+				color: #292929;
+				font-family: Myriad, Lucida Grande, Bitstream Vera Sans, Arial, Helvetica, sans-serif;
+				font-weight: normal;
+			}
+
+			* body {
+				line-height: 1.25em;
+			}
+			
+			table {
+				border-collapse: collapse;
+			}
+			*/
+
+			#testLayout {
+				position: relative;
+				left: 0px;
+				top: 0px;
+				width: 100%;
+				height: 100%;
+				border: 1px solid black;
+				border: 0px;
+			}
+
+			.tabBody {
+				margin: 0px;
+				padding: 0px;
+				/*
+				border: 1px solid black;
+				*/
+				background-color: #DEDEDE;
+				border: 0px;
+				width: 100%;
+				height: 100%;
+				position: absolute;
+				left: 0px; 
+				top: 0px;
+				overflow: auto;
+			}
+
+			#logBody {
+				padding-left: 5px;
+				padding-top: 5px;
+				font-family: Monaco, monospace;
+				font-size: 11px;
+				white-space: pre;
+			}
+
+			#progressOuter {
+				background:#e9e9e9 url("http://svn.dojotoolkit.org/src/dijit/trunk/themes/tundra/images/dojoTundraGradientBg.png") repeat-x 0 0;
+				height: 1em;
+				/*the following trick is necessary to prevent IE from wrapping the last piece of progress bar into a new line*/
+				_margin:1px;
+				_padding: -1px;
+				
+				/*
+				border-color: #e8e8e8;
+				*/
+			}
+
+			#progressOuter .success, #progressOuter .failure{
+				float: left;
+				height: 1em;
+			}
+
+			#play, #pause {
+				font-family: Webdings;
+				font-size: 1.4em;
+				border: 1px solid #DEDEDE;
+				cursor: pointer;
+				padding-right: 0.5em;
+			}
+
+			.header {
+				border: 1px solid #DEDEDE;
+			}
+
+			button.tab {
+				border-width: 1px 1px 0px 1px;
+				border-style: solid;
+				border-color: #DEDEDE;
+				margin-right: 5px;
+			}
+
+			#testListContainer {
+				/*
+				border: 1px solid black;
+				*/
+				position: relative;
+				height: 99%;
+				width: 100%;
+				overflow: auto;
+			}
+
+			#testList {
+				border-collapse: collapse;
+				position: absolute;
+				left: 0px;
+				width: 100%;
+			}
+
+			#testList > tbody > tr > td {
+				border-bottom: 1px solid #DEDEDE;
+				border-right : 1px solid #DEDEDE;
+				padding: 3px;
+			}
+
+			#testListHeader th {
+				border-bottom: 1px solid #DEDEDE;
+				border-right : 1px solid #DEDEDE;
+				padding: 3px;
+				font-weight: bolder;
+				font-style: italic;
+			}
+
+			#toggleButtons {
+				float: left;
+				background-color: #DEDEDE;
+			}
+
+			div.testGroupName {
+				position: absolute;
+			}
+
+			.inProgress {
+				background-color: #85afde;
+			}
+
+			.success {
+				background-color: #7cdea7;
+			}
+
+			.failure {
+				background-color: #de827b;
+			}
+		</style>
+	</head>
+	<body>
+		<table id="testLayout" cellpadding="0" cellspacing="0" style="margin: 0;">
+			<tr valign="top" height="40">
+				<td colspan="2" id="logoBar">
+					<h3 style="margin: 5px 5px 0px 5px; float: left;">D.O.H.: The Dojo Objective Harness</h3>
+					<img src="small_logo.png" height="40" style="margin: 0px 5px 0px 5px; float: right;">
+					<span style="margin: 10px 5px 0px 5px; float: right;">
+						<input type="checkbox" id="audio" name="audio">
+						<label for="audio">sounds?</label>
+					</span>
+				</td>
+			</tr>
+			<tr valign="top" height="10">
+				<td colspan="2"><div id="progressOuter"></div></td>
+			</tr>
+			<tr valign="top" height="30">
+				<td width="30%" class="header">
+					<span id="toggleButtons" onclick="doh.togglePaused();">
+						<button id="play">&#052;</button>
+						<button id="pause" style="display: none;">&#059;</button>
+					</span>
+					<span id="runningStatus">
+						<span id="pausedMsg">Stopped</span>
+						<span id="playingMsg" style="display: none;">Tests Running</span>
+					</span>
+				</td>
+				<td width="*" class="header" valign="bottom">
+					<button class="tab" onclick="showTestPage();">Test Page</button>
+					<button class="tab" onclick="showLogPage();">Log</button>
+				</td>
+			</tr>
+			<tr valign="top" style="border: 0; padding: 0; margin: 0;">
+				<td height="100%" style="border: 0; padding: 0; margin: 0;">
+					<div id="testListContainer">
+						<table cellpadding="0" cellspacing="0" border="0"
+							width="100%" id="testList" style="margin: 0;">
+							<thead>
+								<tr id="testListHeader" style="border: 0; padding: 0; margin: 0;" >
+									<th>&nbsp;</th>
+									<th width="20">
+										<input type="checkbox" checked 
+											onclick="toggleRunAll();">
+									</th>
+									<th width="*" style="text-align: left;">test</th>
+									<th width="50">time</th>
+								</tr>
+							</thead>
+							<tbody valign="top">
+								<tr id="groupTemplate" style="display: none;">
+									<td style="font-family: Webdings; width: 15px;">&#052;</td>
+									<td>
+										<input type="checkbox" checked>
+									</td>
+									<td>group name</td>
+									<td>10ms</td>
+								</tr>
+								<tr id="testTemplate" style="display: none;">
+									<td>&nbsp;</td>
+									<td>&nbsp;</td>
+									<td style="padding-left: 20px;">test name</td>
+									<td>10ms</td>
+								</tr>
+							</tbody>
+						</table>
+					</div>
+				</td>
+				<td>
+					<div style="position: relative; width: 99%; height: 100%; top: 0px; left: 0px;">
+						<div class="tabBody"
+							style="z-index: 1;">
+<pre id="logBody"></pre>
+						</div>
+						<iframe id="testBody" class="tabBody"
+							style="z-index: 0;"></iframe>
+						<!--
+							src="http://redesign.dojotoolkit.org"></iframe>
+						-->
+					</div>
+				</td>
+			</tr>
+		</table>
+		<span id="hiddenAudio"></span>
+	</body>
+</html>
+
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/runner.js
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/runner.js	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/runner.js	(revision 0)
@@ -0,0 +1,1053 @@
+// package system gunk. 
+try{
+	dojo.provide("doh.runner");
+}catch(e){
+	if(!this["doh"]){
+		doh = {};
+	}
+}
+
+//
+// Utility Functions and Classes
+//
+
+doh.selfTest = false;
+
+doh.global = this;
+
+doh.hitch = function(/*Object*/thisObject, /*Function|String*/method /*, ...*/){
+	var args = [];
+	for(var x=2; x<arguments.length; x++){
+		args.push(arguments[x]);
+	}
+	var fcn = ((typeof method == "string") ? thisObject[method] : method) || function(){};
+	return function(){
+		var ta = args.concat([]); // make a copy
+		for(var x=0; x<arguments.length; x++){
+			ta.push(arguments[x]);
+		}
+		return fcn.apply(thisObject, ta); // Function
+	};
+}
+
+doh._mixin = function(/*Object*/ obj, /*Object*/ props){
+	// summary:
+	//		Adds all properties and methods of props to obj. This addition is
+	//		"prototype extension safe", so that instances of objects will not
+	//		pass along prototype defaults.
+	var tobj = {};
+	for(var x in props){
+		// the "tobj" condition avoid copying properties in "props"
+		// inherited from Object.prototype.  For example, if obj has a custom
+		// toString() method, don't overwrite it with the toString() method
+		// that props inherited from Object.protoype
+		if((typeof tobj[x] == "undefined") || (tobj[x] != props[x])){
+			obj[x] = props[x];
+		}
+	}
+	// IE doesn't recognize custom toStrings in for..in
+	if(	this["document"] 
+		&& document.all
+		&& (typeof props["toString"] == "function")
+		&& (props["toString"] != obj["toString"])
+		&& (props["toString"] != tobj["toString"])
+	){
+		obj.toString = props.toString;
+	}
+	return obj; // Object
+}
+
+doh.mixin = function(/*Object*/obj, /*Object...*/props){
+	// summary:	Adds all properties and methods of props to obj. 
+	for(var i=1, l=arguments.length; i<l; i++){
+		doh._mixin(obj, arguments[i]);
+	}
+	return obj; // Object
+}
+
+doh.extend = function(/*Object*/ constructor, /*Object...*/ props){
+	// summary:
+	//		Adds all properties and methods of props to constructor's
+	//		prototype, making them available to all instances created with
+	//		constructor.
+	for(var i=1, l=arguments.length; i<l; i++){
+		doh._mixin(constructor.prototype, arguments[i]);
+	}
+	return constructor; // Object
+}
+
+
+doh._line = "------------------------------------------------------------";
+
+/*
+doh._delegate = function(obj, props){
+	// boodman-crockford delegation
+	function TMP(){};
+	TMP.prototype = obj;
+	var tmp = new TMP();
+	if(props){
+		dojo.lang.mixin(tmp, props);
+	}
+	return tmp;
+}
+*/
+
+doh.debug = function(){
+	// summary:
+	//		takes any number of arguments and sends them to whatever debugging
+	//		or logging facility is available in this environment
+
+	// YOUR TEST RUNNER NEEDS TO IMPLEMENT THIS
+}
+
+doh._AssertFailure = function(msg, hint){
+	// idea for this as way of dis-ambiguating error types is from JUM. 
+	// The JUM is dead! Long live the JUM!
+
+	if(!(this instanceof doh._AssertFailure)){
+		return new doh._AssertFailure(msg);
+	}
+	if(hint){
+		msg = (new String(msg||""))+" with hint: \n\t\t"+(new String(hint)+"\n");
+	}
+	this.message = new String(msg||"");
+	return this;
+}
+doh._AssertFailure.prototype = new Error();
+doh._AssertFailure.prototype.constructor = doh._AssertFailure;
+doh._AssertFailure.prototype.name = "doh._AssertFailure";
+
+doh.Deferred = function(canceller){
+	this.chain = [];
+	this.id = this._nextId();
+	this.fired = -1;
+	this.paused = 0;
+	this.results = [null, null];
+	this.canceller = canceller;
+	this.silentlyCancelled = false;
+};
+
+doh.extend(doh.Deferred, {
+	getTestCallback: function(cb, scope){
+		var _this = this;
+		return function(){
+			try{
+				cb.apply(scope||doh.global||_this, arguments);
+			}catch(e){
+				_this.errback(e);
+				return;
+			}
+			_this.callback(true);
+		};
+	},
+
+	getFunctionFromArgs: function(){
+		var a = arguments;
+		if((a[0])&&(!a[1])){
+			if(typeof a[0] == "function"){
+				return a[0];
+			}else if(typeof a[0] == "string"){
+				return doh.global[a[0]];
+			}
+		}else if((a[0])&&(a[1])){
+			return doh.hitch(a[0], a[1]);
+		}
+		return null;
+	},
+
+	makeCalled: function() {
+		var deferred = new doh.Deferred();
+		deferred.callback();
+		return deferred;
+	},
+
+	_nextId: (function(){
+		var n = 1;
+		return function(){ return n++; };
+	})(),
+
+	cancel: function(){
+		if(this.fired == -1){
+			if (this.canceller){
+				this.canceller(this);
+			}else{
+				this.silentlyCancelled = true;
+			}
+			if(this.fired == -1){
+				this.errback(new Error("Deferred(unfired)"));
+			}
+		}else if(this.fired == 0 &&
+					(this.results[0] instanceof doh.Deferred)){
+			this.results[0].cancel();
+		}
+	},
+			
+
+	_pause: function(){
+		this.paused++;
+	},
+
+	_unpause: function(){
+		this.paused--;
+		if ((this.paused == 0) && (this.fired >= 0)) {
+			this._fire();
+		}
+	},
+
+	_continue: function(res){
+		this._resback(res);
+		this._unpause();
+	},
+
+	_resback: function(res){
+		this.fired = ((res instanceof Error) ? 1 : 0);
+		this.results[this.fired] = res;
+		this._fire();
+	},
+
+	_check: function(){
+		if(this.fired != -1){
+			if(!this.silentlyCancelled){
+				throw new Error("already called!");
+			}
+			this.silentlyCancelled = false;
+			return;
+		}
+	},
+
+	callback: function(res){
+		this._check();
+		this._resback(res);
+	},
+
+	errback: function(res){
+		this._check();
+		if(!(res instanceof Error)){
+			res = new Error(res);
+		}
+		this._resback(res);
+	},
+
+	addBoth: function(cb, cbfn){
+		var enclosed = this.getFunctionFromArgs(cb, cbfn);
+		if(arguments.length > 2){
+			enclosed = doh.hitch(null, enclosed, arguments, 2);
+		}
+		return this.addCallbacks(enclosed, enclosed);
+	},
+
+	addCallback: function(cb, cbfn){
+		var enclosed = this.getFunctionFromArgs(cb, cbfn);
+		if(arguments.length > 2){
+			enclosed = doh.hitch(null, enclosed, arguments, 2);
+		}
+		return this.addCallbacks(enclosed, null);
+	},
+
+	addErrback: function(cb, cbfn){
+		var enclosed = this.getFunctionFromArgs(cb, cbfn);
+		if(arguments.length > 2){
+			enclosed = doh.hitch(null, enclosed, arguments, 2);
+		}
+		return this.addCallbacks(null, enclosed);
+	},
+
+	addCallbacks: function(cb, eb){
+		this.chain.push([cb, eb]);
+		if(this.fired >= 0){
+			this._fire();
+		}
+		return this;
+	},
+
+	_fire: function(){
+		var chain = this.chain;
+		var fired = this.fired;
+		var res = this.results[fired];
+		var self = this;
+		var cb = null;
+		while(chain.length > 0 && this.paused == 0){
+			// Array
+			var pair = chain.shift();
+			var f = pair[fired];
+			if(f == null){
+				continue;
+			}
+			try {
+				res = f(res);
+				fired = ((res instanceof Error) ? 1 : 0);
+				if(res instanceof doh.Deferred){
+					cb = function(res){
+						self._continue(res);
+					};
+					this._pause();
+				}
+			}catch(err){
+				fired = 1;
+				res = err;
+			}
+		}
+		this.fired = fired;
+		this.results[fired] = res;
+		if((cb)&&(this.paused)){
+			res.addBoth(cb);
+		}
+	}
+});
+
+//
+// State Keeping and Reporting
+//
+
+doh._testCount = 0;
+doh._groupCount = 0;
+doh._errorCount = 0;
+doh._failureCount = 0;
+doh._currentGroup = null;
+doh._currentTest = null;
+doh._paused = true;
+
+doh._init = function(){
+	this._currentGroup = null;
+	this._currentTest = null;
+	this._errorCount = 0;
+	this._failureCount = 0;
+	this.debug(this._testCount, "tests to run in", this._groupCount, "groups");
+}
+
+// doh._urls = [];
+doh._groups = {};
+
+//
+// Test Registration
+//
+
+doh.registerTestNs = function(/*String*/ group, /*Object*/ ns){
+	// summary:
+	//		adds the passed namespace object to the list of objects to be
+	//		searched for test groups. Only "public" functions (not prefixed
+	//		with "_") will be added as tests to be run. If you'd like to use
+	//		fixtures (setUp(), tearDown(), and runTest()), please use
+	//		registerTest() or registerTests().
+	for(var x in ns){
+		if(	(x.charAt(0) != "_") &&
+			(typeof ns[x] == "function") ){
+			this.registerTest(group, ns[x]);
+		}
+	}
+}
+
+doh._testRegistered = function(group, fixture){
+	// slot to be filled in
+}
+
+doh._groupStarted = function(group){
+	// slot to be filled in
+}
+
+doh._groupFinished = function(group, success){
+	// slot to be filled in
+}
+
+doh._testStarted = function(group, fixture){
+	// slot to be filled in
+}
+
+doh._testFinished = function(group, fixture, success){
+	// slot to be filled in
+}
+
+doh.registerGroup = function(	/*String*/ group, 
+								/*Array||Function||Object*/ tests, 
+								/*Function*/ setUp, 
+								/*Function*/ tearDown){
+	// summary:
+	//		registers an entire group of tests at once and provides a setUp and
+	//		tearDown facility for groups. If you call this method with only
+	//		setUp and tearDown parameters, they will replace previously
+	//		installed setUp or tearDown functions for the group with the new
+	//		methods.
+	// group:
+	//		string name of the group
+	// tests:
+	//		either a function or an object or an array of functions/objects. If
+	//		an object, it must contain at *least* a "runTest" method, and may
+	//		also contain "setUp" and "tearDown" methods. These will be invoked
+	//		on either side of the "runTest" method (respectively) when the test
+	//		is run. If an array, it must contain objects matching the above
+	//		description or test functions.
+	// setUp: a function for initializing the test group
+	// tearDown: a function for initializing the test group
+	if(tests){
+		this.register(group, tests);
+	}
+	if(setUp){
+		this._groups[group].setUp = setUp;
+	}
+	if(tearDown){
+		this._groups[group].tearDown = tearDown;
+	}
+}
+
+doh._getTestObj = function(group, test){
+	var tObj = test;
+	if(typeof test == "string"){
+		if(test.substr(0, 4)=="url:"){
+			return this.registerUrl(group, test);
+		}else{
+			tObj = {
+				name: test.replace("/\s/g", "_") // FIXME: bad escapement
+			};
+			tObj.runTest = new Function("t", test);
+		}
+	}else if(typeof test == "function"){
+		// if we didn't get a fixture, wrap the function
+		tObj = { "runTest": test };
+		if(test["name"]){
+			tObj.name = test.name;
+		}else{
+			try{
+				var fStr = "function ";
+				var ts = tObj.runTest+"";
+				if(0 <= ts.indexOf(fStr)){
+					tObj.name = ts.split(fStr)[1].split("(", 1)[0];
+				}
+				// doh.debug(tObj.runTest.toSource());
+			}catch(e){
+			}
+		}
+		// FIXME: try harder to get the test name here
+	}
+	return tObj;
+}
+
+doh.registerTest = function(/*String*/ group, /*Function||Object*/ test){
+	// summary:
+	//		add the provided test function or fixture object to the specified
+	//		test group.
+	// group:
+	//		string name of the group to add the test to
+	// test:
+	//		either a function or an object. If an object, it must contain at
+	//		*least* a "runTest" method, and may also contain "setUp" and
+	//		"tearDown" methods. These will be invoked on either side of the
+	//		"runTest" method (respectively) when the test is run.
+	if(!this._groups[group]){
+		this._groupCount++;
+		this._groups[group] = [];
+		this._groups[group].inFlight = 0;
+	}
+	var tObj = this._getTestObj(group, test);
+	if(!tObj){ return null; }
+	this._groups[group].push(tObj);
+	this._testCount++;
+	this._testRegistered(group, tObj);
+	return tObj;
+}
+
+doh.registerTests = function(/*String*/ group, /*Array*/ testArr){
+	// summary:
+	//		registers a group of tests, treating each element of testArr as
+	//		though it were being (along with group) passed to the registerTest
+	//		method.
+	for(var x=0; x<testArr.length; x++){
+		this.registerTest(group, testArr[x]);
+	}
+}
+
+// FIXME: move implementation to _browserRunner?
+doh.registerUrl = function(	/*String*/ group, 
+								/*String*/ url, 
+								/*Integer*/ timeout){
+	this.debug("ERROR:");
+	this.debug("\tNO registerUrl() METHOD AVAILABLE.");
+	// this._urls.push(url);
+}
+
+doh.registerString = function(group, str){
+}
+
+// FIXME: remove the doh.add alias SRTL.
+doh.register = doh.add = function(groupOrNs, testOrNull){
+	// summary:
+	// 		"magical" variant of registerTests, registerTest, and
+	// 		registerTestNs. Will accept the calling arguments of any of these
+	// 		methods and will correctly guess the right one to register with.
+	if(	(arguments.length == 1)&&
+		(typeof groupOrNs == "string") ){
+		if(groupOrNs.substr(0, 4)=="url:"){
+			this.registerUrl(groupOrNs);
+		}else{
+			this.registerTest("ungrouped", groupOrNs);
+		}
+	}
+	if(arguments.length == 1){
+		this.debug("invalid args passed to doh.register():", groupOrNs, ",", testOrNull);
+		return;
+	}
+	if(typeof testOrNull == "string"){
+		if(testOrNull.substr(0, 4)=="url:"){
+			this.registerUrl(testOrNull);
+		}else{
+			this.registerTest(groupOrNs, testOrNull);
+		}
+		// this.registerTestNs(groupOrNs, testOrNull);
+		return;
+	}
+	if(doh._isArray(testOrNull)){
+		this.registerTests(groupOrNs, testOrNull);
+		return;
+	}
+	this.registerTest(groupOrNs, testOrNull);
+};
+
+doh.registerDocTests = function(module){
+	// no-op for when Dojo isn't loaded into the page
+	this.debug("registerDocTests() requires dojo to be loaded into the environment. Skipping doctest set for module:", module);
+};
+(function(){
+	if(typeof dojo != "undefined"){
+		try{
+			dojo.require("dojox.testing.DocTest");
+		}catch(e){
+			// if the DocTest module isn't available (e.g., the build we're
+			// running from doesn't include it), stub it out and log the error
+			console.debug(e);
+
+			doh.registerDocTests = function(){}
+			return;
+		}
+		doh.registerDocTests = function(module){
+			//	summary:
+			//		Get all the doctests from the given module and register each of them
+			//		as a single test case here.
+			//
+			
+			var docTest = new dojox.testing.DocTest();
+			var docTests = docTest.getTests(module);
+			var len = docTests.length;
+			var tests = [];
+			for (var i=0; i<len; i++){
+				var test = docTests[i];
+				// Extract comment on first line and add to test name.
+				var comment = "";
+				if (test.commands.length && test.commands[0].indexOf("//")!=-1) {
+					var parts = test.commands[0].split("//");
+					comment = ", "+parts[parts.length-1]; // Get all after the last //, so we dont get trapped by http:// or alikes :-).
+				}
+				tests.push({
+					runTest: (function(test){ 
+						return function(t){
+							var r = docTest.runTest(test.commands, test.expectedResult);
+							t.assertTrue(r.success);
+						}
+					})(test),
+					name:"Line "+test.line+comment
+				}
+				);
+			}
+			this.register("DocTests: "+module, tests);
+		}
+	}
+})();
+
+//
+// Assertions and In-Test Utilities
+//
+
+doh.t = doh.assertTrue = function(/*Object*/ condition, /*String?*/ hint){
+	// summary:
+	//		is the passed item "truthy"?
+	if(arguments.length < 1){ 
+		throw new doh._AssertFailure("assertTrue failed because it was not passed at least 1 argument"); 
+	} 
+	if(!eval(condition)){
+		throw new doh._AssertFailure("assertTrue('" + condition + "') failed", hint);
+	}
+}
+
+doh.f = doh.assertFalse = function(/*Object*/ condition, /*String?*/ hint){
+	// summary:
+	//		is the passed item "falsey"?
+	if(arguments.length < 1){ 
+		throw new doh._AssertFailure("assertFalse failed because it was not passed at least 1 argument"); 
+	} 
+	if(eval(condition)){
+		throw new doh._AssertFailure("assertFalse('" + condition + "') failed", hint);
+	}
+}
+
+doh.e = doh.assertError = function(/*Error object*/expectedError, /*Object*/scope, /*String*/functionName, /*Array*/args, /*String?*/ hint){
+	//	summary:
+	//		Test for a certain error to be thrown by the given function.
+	//	example:
+	//		t.assertError(dojox.data.QueryReadStore.InvalidAttributeError, store, "getValue", [item, "NOT THERE"]);
+	//		t.assertError(dojox.data.QueryReadStore.InvalidItemError, store, "getValue", ["not an item", "NOT THERE"]);
+	try{
+		scope[functionName].apply(scope, args);
+	}catch (e){
+		if(e instanceof expectedError){
+			return true;
+		}else{
+			throw new doh._AssertFailure("assertError() failed:\n\texpected error\n\t\t"+expectedError+"\n\tbut got\n\t\t"+e+"\n\n", hint);
+		}
+	}
+	throw new doh._AssertFailure("assertError() failed:\n\texpected error\n\t\t"+expectedError+"\n\tbut no error caught\n\n", hint);
+}
+
+
+doh.is = doh.assertEqual = function(/*Object*/ expected, /*Object*/ actual, /*String?*/ hint){
+	// summary:
+	//		are the passed expected and actual objects/values deeply
+	//		equivalent?
+
+	// Compare undefined always with three equal signs, because undefined==null
+	// is true, but undefined===null is false. 
+	if((expected === undefined)&&(actual === undefined)){ 
+		return true;
+	}
+	if(arguments.length < 2){ 
+		throw doh._AssertFailure("assertEqual failed because it was not passed 2 arguments"); 
+	} 
+	if((expected === actual)||(expected == actual)){ 
+		return true;
+	}
+	if(	(this._isArray(expected) && this._isArray(actual))&&
+		(this._arrayEq(expected, actual)) ){
+		return true;
+	}
+	if( ((typeof expected == "object")&&((typeof actual == "object")))&&
+		(this._objPropEq(expected, actual)) ){
+		return true;
+	}
+	throw new doh._AssertFailure("assertEqual() failed:\n\texpected\n\t\t"+expected+"\n\tbut got\n\t\t"+actual+"\n\n", hint);
+}
+
+doh.isNot = doh.assertNotEqual = function(/*Object*/ notExpected, /*Object*/ actual, /*String?*/ hint){
+	// summary:
+	//		are the passed notexpected and actual objects/values deeply
+	//		not equivalent?
+
+	// Compare undefined always with three equal signs, because undefined==null
+	// is true, but undefined===null is false. 
+	if((notExpected === undefined)&&(actual === undefined)){ 
+        throw new doh._AssertFailure("assertNotEqual() failed: not expected |"+notExpected+"| but got |"+actual+"|", hint);
+	}
+	if(arguments.length < 2){ 
+		throw doh._AssertFailure("assertEqual failed because it was not passed 2 arguments"); 
+	} 
+	if((notExpected === actual)||(notExpected == actual)){ 
+        throw new doh._AssertFailure("assertNotEqual() failed: not expected |"+notExpected+"| but got |"+actual+"|", hint);
+	}
+	if(	(this._isArray(notExpected) && this._isArray(actual))&&
+		(this._arrayEq(notExpected, actual)) ){
+		throw new doh._AssertFailure("assertNotEqual() failed: not expected |"+notExpected+"| but got |"+actual+"|", hint);
+	}
+	if( ((typeof notExpected == "object")&&((typeof actual == "object")))&&
+		(this._objPropEq(notExpected, actual)) ){
+        throw new doh._AssertFailure("assertNotEqual() failed: not expected |"+notExpected+"| but got |"+actual+"|", hint);
+	}
+    return true;
+}
+
+doh._arrayEq = function(expected, actual){
+	if(expected.length != actual.length){ return false; }
+	// FIXME: we're not handling circular refs. Do we care?
+	for(var x=0; x<expected.length; x++){
+		if(!doh.assertEqual(expected[x], actual[x])){ return false; }
+	}
+	return true;
+}
+
+doh._objPropEq = function(expected, actual){
+	if(expected instanceof Date){
+		return actual instanceof Date && expected.getTime()==actual.getTime();
+	}
+	var x;
+	// Make sure ALL THE SAME properties are in both objects!
+	for(x in actual){ // Lets check "actual" here, expected is checked below.
+		if(expected[x] === undefined){
+			return false;
+		}
+	};
+
+	for(x in expected){
+		if(!doh.assertEqual(expected[x], actual[x])){
+			return false;
+		}
+	}
+	return true;
+}
+
+doh._isArray = function(it){
+	return (it && it instanceof Array || typeof it == "array" || 
+		(
+			!!doh.global["dojo"] &&
+			doh.global["dojo"]["NodeList"] !== undefined && 
+			it instanceof doh.global["dojo"]["NodeList"]
+		)
+	);
+}
+
+//
+// Runner-Wrapper
+//
+
+doh._setupGroupForRun = function(/*String*/ groupName, /*Integer*/ idx){
+	var tg = this._groups[groupName];
+	this.debug(this._line);
+	this.debug("GROUP", "\""+groupName+"\"", "has", tg.length, "test"+((tg.length > 1) ? "s" : "")+" to run");
+}
+
+doh._handleFailure = function(groupName, fixture, e){
+	// this.debug("FAILED test:", fixture.name);
+	// mostly borrowed from JUM
+	this._groups[groupName].failures++;
+	var out = "";
+	if(e instanceof this._AssertFailure){
+		this._failureCount++;
+		if(e["fileName"]){ out += e.fileName + ':'; }
+		if(e["lineNumber"]){ out += e.lineNumber + ' '; }
+		out += e+": "+e.message;
+		this.debug("\t_AssertFailure:", out);
+	}else{
+		this._errorCount++;
+	}
+	this.debug(e);
+	if(fixture.runTest["toSource"]){
+		var ss = fixture.runTest.toSource();
+		this.debug("\tERROR IN:\n\t\t", ss);
+	}else{
+		this.debug("\tERROR IN:\n\t\t", fixture.runTest);
+	}
+
+	if(e.rhinoException){
+		e.rhinoException.printStackTrace();
+	}else if(e.javaException){
+		e.javaException.printStackTrace();
+	} 
+}
+
+try{
+	setTimeout(function(){}, 0);
+}catch(e){
+	setTimeout = function(func){
+		return func();
+	}
+}
+
+doh._runFixture = function(groupName, fixture){
+	var tg = this._groups[groupName];
+	this._testStarted(groupName, fixture);
+	var threw = false;
+	var err = null;
+	// run it, catching exceptions and reporting them
+	try{
+		// let doh reference "this.group.thinger..." which can be set by
+		// another test or group-level setUp function
+		fixture.group = tg; 
+		// only execute the parts of the fixture we've got
+		if(fixture["setUp"]){ fixture.setUp(this); }
+		if(fixture["runTest"]){  // should we error out of a fixture doesn't have a runTest?
+			fixture.startTime = new Date();
+			var ret = fixture.runTest(this); 
+			fixture.endTime = new Date();
+			// if we get a deferred back from the test runner, we know we're
+			// gonna wait for an async result. It's up to the test code to trap
+			// errors and give us an errback or callback.
+			if(ret instanceof doh.Deferred){
+
+				tg.inFlight++;
+				ret.groupName = groupName;
+				ret.fixture = fixture;
+
+				ret.addErrback(function(err){
+					doh._handleFailure(groupName, fixture, err);
+				});
+
+				var retEnd = function(){
+					if(fixture["tearDown"]){ fixture.tearDown(doh); }
+					tg.inFlight--;
+					if((!tg.inFlight)&&(tg.iterated)){
+						doh._groupFinished(groupName, (!tg.failures));
+					}
+					doh._testFinished(groupName, fixture, ret.results[0]);
+					if(doh._paused){
+						doh.run();
+					}
+				}
+
+				var timer = setTimeout(function(){
+					// ret.cancel();
+					// retEnd();
+					ret.errback(new Error("test timeout in "+fixture.name.toString()));
+				}, fixture["timeout"]||1000);
+
+				ret.addBoth(function(arg){
+					clearTimeout(timer);
+					retEnd();
+				});
+				if(ret.fired < 0){
+					doh.pause();
+				}
+				return ret;
+			}
+		}
+		if(fixture["tearDown"]){ fixture.tearDown(this); }
+	}catch(e){
+		threw = true;
+		err = e;
+		if(!fixture.endTime){
+			fixture.endTime = new Date();
+		}
+	}
+	var d = new doh.Deferred();
+	setTimeout(this.hitch(this, function(){
+		if(threw){
+			this._handleFailure(groupName, fixture, err);
+		}
+		this._testFinished(groupName, fixture, (!threw));
+
+		if((!tg.inFlight)&&(tg.iterated)){
+			doh._groupFinished(groupName, (!tg.failures));
+		}else if(tg.inFlight > 0){
+			setTimeout(this.hitch(this, function(){
+				doh.runGroup(groupName); // , idx);
+			}), 100);
+			this._paused = true;
+		}
+		if(doh._paused){
+			doh.run();
+		}
+	}), 30);
+	doh.pause();
+	return d;
+}
+
+doh._testId = 0;
+doh.runGroup = function(/*String*/ groupName, /*Integer*/ idx){
+	// summary:
+	//		runs the specified test group
+
+	// the general structure of the algorithm is to run through the group's
+	// list of doh, checking before and after each of them to see if we're in
+	// a paused state. This can be caused by the test returning a deferred or
+	// the user hitting the pause button. In either case, we want to halt
+	// execution of the test until something external to us restarts it. This
+	// means we need to pickle off enough state to pick up where we left off.
+
+	// FIXME: need to make fixture execution async!!
+
+	var tg = this._groups[groupName];
+	if(tg.skip === true){ return; }
+	if(this._isArray(tg)){
+		if(idx<=tg.length){
+			if((!tg.inFlight)&&(tg.iterated == true)){
+				if(tg["tearDown"]){ tg.tearDown(this); }
+				doh._groupFinished(groupName, (!tg.failures));
+				return;
+			}
+		}
+		if(!idx){
+			tg.inFlight = 0;
+			tg.iterated = false;
+			tg.failures = 0;
+		}
+		doh._groupStarted(groupName);
+		if(!idx){
+			this._setupGroupForRun(groupName, idx);
+			if(tg["setUp"]){ tg.setUp(this); }
+		}
+		for(var y=(idx||0); y<tg.length; y++){
+			if(this._paused){
+				this._currentTest = y;
+				// this.debug("PAUSED at:", tg[y].name, this._currentGroup, this._currentTest);
+				return;
+			}
+			doh._runFixture(groupName, tg[y]);
+			if(this._paused){
+				this._currentTest = y+1;
+				if(this._currentTest == tg.length){
+					tg.iterated = true;
+				}
+				// this.debug("PAUSED at:", tg[y].name, this._currentGroup, this._currentTest);
+				return;
+			}
+		}
+		tg.iterated = true;
+		if(!tg.inFlight){
+			if(tg["tearDown"]){ tg.tearDown(this); }
+			doh._groupFinished(groupName, (!tg.failures));
+		}
+	}
+}
+
+doh._onEnd = function(){}
+
+doh._report = function(){
+	// summary:
+	//		a private method to be implemented/replaced by the "locally
+	//		appropriate" test runner
+
+	// this.debug("ERROR:");
+	// this.debug("\tNO REPORTING OUTPUT AVAILABLE.");
+	// this.debug("\tIMPLEMENT doh._report() IN YOUR TEST RUNNER");
+
+	this.debug(this._line);
+	this.debug("| TEST SUMMARY:");
+	this.debug(this._line);
+	this.debug("\t", this._testCount, "tests in", this._groupCount, "groups");
+	this.debug("\t", this._errorCount, "errors");
+	this.debug("\t", this._failureCount, "failures");
+}
+
+doh.togglePaused = function(){
+	this[(this._paused) ? "run" : "pause"]();
+}
+
+doh.pause = function(){
+	// summary:
+	//		halt test run. Can be resumed.
+	this._paused = true;
+}
+
+doh.run = function(){
+	// summary:
+	//		begins or resumes the test process.
+	// this.debug("STARTING");
+	this._paused = false;
+	var cg = this._currentGroup;
+	var ct = this._currentTest;
+	var found = false;
+	if(!cg){
+		this._init(); // we weren't paused
+		found = true;
+	}
+	this._currentGroup = null;
+	this._currentTest = null;
+
+	for(var x in this._groups){
+		if(
+			( (!found)&&(x == cg) )||( found )
+		){
+			if(this._paused){ return; }
+			this._currentGroup = x;
+			if(!found){
+				found = true;
+				this.runGroup(x, ct);
+			}else{
+				this.runGroup(x);
+			}
+			if(this._paused){ return; }
+		}
+	}
+	this._currentGroup = null;
+	this._currentTest = null;
+	this._paused = false;
+	this._onEnd();
+	this._report();
+}
+
+tests = doh;
+
+(function(){
+	// scope protection
+	var x;
+	try{
+		if(typeof dojo != "undefined"){
+			dojo.platformRequire({
+				browser: ["doh._browserRunner"],
+				rhino: ["doh._rhinoRunner"],
+				spidermonkey: ["doh._rhinoRunner"]
+			});
+			var _shouldRequire = dojo.isBrowser ? (dojo.global == dojo.global["parent"]) : true;
+			if(_shouldRequire){
+				if(dojo.isBrowser){
+					dojo.addOnLoad(function(){
+						if (dojo.global.registerModulePath){
+							dojo.forEach(dojo.global.registerModulePath, function(m){
+								dojo.registerModulePath(m[0], m[1]);
+							});
+						}
+						if(dojo.byId("testList")){
+							var _tm = ( (dojo.global.testModule && dojo.global.testModule.length) ? dojo.global.testModule : "dojo.tests.module");
+							dojo.forEach(_tm.split(","), dojo.require, dojo);
+							setTimeout(function(){
+								doh.run();
+							}, 500);
+						}
+					});
+				}else{
+					// dojo.require("doh._base");
+				}
+			}
+		}else{
+			if(typeof load == "function" &&
+				(typeof Packages == "function" || typeof Packages == "object")){
+				throw new Error();
+			}else if(typeof load == "function"){
+				throw new Error();
+			}
+
+			if(this["document"]){
+				// if we survived all of that, we're probably in a browser but
+				// don't have Dojo handy. Load _browserRunner.js using a
+				// document.write() call.
+
+				// find runner.js, load _browserRunner relative to it
+				var scripts = document.getElementsByTagName("script");
+				for(x=0; x<scripts.length; x++){
+					var s = scripts[x].src;
+					if(s && (s.substr(s.length - 9) == "runner.js")){
+						document.write("<scri"+"pt src='" + s.substr(0, s.length - 9)
+							+ "_browserRunner.js' type='text/javascript'></scr"+"ipt>");
+					}
+				}
+			}
+		}
+	}catch(e){
+		print("\n"+doh._line);
+		print("The Dojo Unit Test Harness, $Rev$");
+		print("Copyright (c) 2007, The Dojo Foundation, All Rights Reserved");
+		print(doh._line, "\n");
+
+		load("_rhinoRunner.js");
+
+		try{
+			var dojoUrl = "../../dojo/dojo.js";
+			var testUrl = "";
+			var testModule = "dojo.tests.module";
+			for(x=0; x<arguments.length; x++){
+				if(arguments[x].indexOf("=") > 0){
+					var tp = arguments[x].split("=");
+					if(tp[0] == "dojoUrl"){
+						dojoUrl = tp[1];
+					}
+					if(tp[0] == "testUrl"){
+						testUrl = tp[1];
+					}
+					if(tp[0] == "testModule"){
+						testModule = tp[1];
+					}
+				}
+			}
+			if(dojoUrl.length){
+				if(!this["djConfig"]){
+					djConfig = {};
+				}
+				djConfig.baseUrl = dojoUrl.split("dojo.js")[0];
+				load(dojoUrl);
+			}
+			if(testUrl.length){
+				load(testUrl);
+			}
+			if(testModule.length){
+				dojo.forEach(testModule.split(","), dojo.require, dojo);
+			}
+		}catch(e){
+			print("An exception occurred: " + e);
+		}
+
+		doh.run();
+	}
+}).apply(this, typeof arguments != "undefined" ? arguments : [null]);
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/runner.sh
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/runner.sh	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/runner.sh	(revision 0)
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+java -jar ../shrinksafe/custom_rhino.jar runner.js "$@"
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/small_logo.png
===================================================================
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

Property changes on: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/doh/small_logo.png
___________________________________________________________________
Name: svn:mime-type
   + application/octet-stream

Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/.DS_Store
===================================================================
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

Property changes on: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/.DS_Store
___________________________________________________________________
Name: svn:mime-type
   + application/octet-stream

Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/AutomatedTestRunner.js
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/AutomatedTestRunner.js	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/AutomatedTestRunner.js	(revision 0)
@@ -0,0 +1,791 @@
+/*global jQuery, doh*/
+var fluid = fluid || {};
+
+(function ($) {
+    fluid.test = fluid.test || {};
+    
+    var testToRun;
+    var context;
+    var iframeOffsetTop = 0;
+    var iframeOffsetLeft = 0;
+    var adjustmentTop = 0;
+    var adjustmentLeft = 0;
+    var bodyClone;
+    var iFrame;
+    
+    //private functions
+    var setContext;
+    var adjustedPosition;
+    var setDelay;
+    var iframeScrollOffset;
+    var isInView;
+    var scrollIntoView;
+    var calculateViewTop;
+    var calculateViewBottom;
+    var calculateViewLeft;
+    var calculateViewRight;
+    
+    //Sets context and binds the test to a button
+    $(document).ready(function () {
+        $("button").click(function () {
+            $("button").parent().css('display', 'none');
+            iFrame = $(context.iframe).contents();
+            bodyClone = $("body", iFrame).clone();
+            setContext(context);
+            testToRun();
+        });
+        $(window).resize(function () {
+            setContext(context);
+        });
+    });
+    
+    /**
+     * Assigns the testFn so that it is attached to and can be called by a button click. 
+     * Assigns the context for which the test is run in.
+     * 
+     * @param {Function} testFn contains all of the automated tests
+     * @param {Object} contextObject sets the context of the test, the information about the iframe
+     * contextObject has the following keys: iframe, adjustmentX, adjustmentY
+     * 
+     * iframe is the iframe node or jquery object containing it. If not provided, it will be assumed that there is no iframe.
+     * adjustmentX is a numeric value specifying any additional x offset. The default is 0.
+     * adjustmentY is a numeric value specifying any additional y offset. The default is 0.
+     */
+    fluid.test.runAutomatedTest = function (testFn, contextObject) {
+        testToRun = testFn;
+        context = contextObject;
+    };
+    
+    
+      //-----------------\\
+     //Test Case Functions\\
+    //---------------------\\
+    
+    
+    /**
+     * Assembles a test case by assigning the passed values to the doh.register function
+     * 
+     * @param {Object} testCaseObject contains the values to set up the test case
+     * testCaseObject has the following keys: groupName, name, timeout, setUp, actionFunction, assertionFunction, tearDown
+     * 
+     * groupName is the name for which the test case belongs to (e.g. "mouse", "keyboard", etc). The default is "Automated Test Suite"
+     * name is the name of the specific test case. This should be descriptive (e.g. "Edit Text"). The default is "Automated Test"
+     * timeout is the maximum length of time,in milliseconds, a test can run before timing out. The default is 9000 milliseconds
+     * setUp is a function called to setUp the test environment. The default is an empty function.
+     * actionFunction is a function containing all of the actions you want to perform (e.g. <code>functions () {fluid.test.mouseClick(node)};</code>)
+     * assertionFunction is an assertion function (e.g. fluid.test.assertTrue(expected, actual))
+     * tearDown is a function called to reset the test environment. The default is an empty function.
+     */
+    fluid.test.testCase = function (testCaseObject) {
+        var testGroupName;
+        var testName;
+        var timeoutValue;
+        var setUpFunction;
+        var testFunction;
+        var tearDownFunction;
+        
+        if (testCaseObject) {
+            testGroupName = testCaseObject.groupName || "Automated Test Suite";
+            testName = testCaseObject.name || "Automated Test";
+            timeoutValue = testCaseObject.timeout || 9000;
+            setUpFunction = testCaseObject.setUp || function () {};
+            testFunction = testCaseObject.test || function () {};
+            tearDownFunction = testCaseObject.tearDown || function () {};
+            
+            doh.register(testGroupName, {
+                name: testName,
+                timeout: timeoutValue,
+                setUp: function () {
+                    setUpFunction();
+                },
+                runTest: function () {
+                    var actions;
+                    var assertions;
+                    var d = new doh.Deferred();
+                    
+                    actions = testCaseObject.actionFunction || function () {};
+                    assertions = testCaseObject.assertionFunction || function () {fluid.test.assertTrue(false); };
+                    
+                    actions();
+                    
+                    doh.robot.sequence(d.getTestCallback(assertions), 900);
+                    return d;
+                    
+                },
+                tearDown: function () {
+                    tearDownFunction();
+                }
+            });
+        }
+    };
+    
+    /**
+     * Must be called after all fluid.test.testCases, for the tests to run
+     */
+    fluid.test.run = function () {
+        doh.run();
+    };
+    
+    
+      //--------------\\
+     //Action Functions\\
+    //------------------\\
+    
+    
+    /**
+     * Moves the mouse over the specified location on the screen by calling the doh.robot.mouseMove. 
+     * This is a system level event.
+     * 
+     * If the location to move to is not in view, scrollIntoView is called.
+     * Note that scrollIntoView is placed inside of a doh.robot.sequence function so that it will fire at the correct time.
+     * 
+     * @param {element||jQuery||Object} node a DOM element, a single jQuery elment, or an object containing coordinates with the keys left and top
+     * @param {Object} optionsObject (optional) contains options to fine tune the coordinate offset and to set a delay 
+     * optionsObject has the following keys: left, top, delay
+     * delay defualts to 500 milliseconds and used to specify the time to wait before firing
+     */
+    fluid.test.mouseHover = function (location, optionsObject) {
+        var delay = setDelay(optionsObject); 
+        var position = adjustedPosition(location, optionsObject);
+        
+        if (!isInView(position)) {
+            doh.robot.sequence(function () {
+                scrollIntoView(position);
+                position = adjustedPosition(location, optionsObject);
+            }, 200, 200);
+        }
+        doh.robot.mouseMove(function () {
+            return position.left;
+        }, 
+        function () {
+            return position.top;
+        }, delay);
+    };
+    
+    /**
+     * Moves the mouse over the specified location on the screen and clicks there with the left mouse button
+     * It will attempt to scroll the screen to the correct location before performing the action
+     * 
+     * @param {element||jQuery||Object} node a DOM element, a single jQuery elment, or an object containing coordinates with the keys left and top
+     * @param {Object} optionsObject (optional) contains options to fine tune the coordinate offset and to set a delay 
+     * optionsObject has the following keys: left, top, delay
+     * delay defualts to 500 milliseconds and used to specify the time to wait before firing
+     */
+    fluid.test.mouseClick = function (location, optionsObject) {
+        var delay = setDelay(optionsObject);
+        fluid.test.mouseHover(location, optionsObject);
+        doh.robot.mouseClick({left: true}, delay);
+    };
+    
+    /**
+     * Moves the mouse over the specified draggable item on the screen and attempts to picks it up with a left mouse down
+     * It will attempt to scroll the screen to the correct location before performing the action
+     * 
+     * @param {element||jQuery||Object} node a DOM element, a single jQuery elment, or an object containing coordinates with the keys left and top
+     * @param {Object} optionsObject (optional) contains options to fine tune the coordinate offset and to set a delay 
+     * optionsObject has the following keys: left, top, delay
+     * delay defualts to 500 milliseconds and used to specify the time to wait before firing
+     */
+    fluid.test.mouseDrag = function (location, optionsObject) {
+        var delay = setDelay(optionsObject);
+        fluid.test.mouseHover(location, optionsObject);
+        doh.robot.mousePress({left: true}, delay);
+    };
+    
+    /**
+     * Moves the mouse and draggable item to the specified location and releases the item with a left mouse up
+     * 
+     * @param {element||jQuery||Object} node a DOM element, a single jQuery elment, or an object containing coordinates with the keys left and top
+     * @param {Object} optionsObject (optional)contains options to fine tune the coordinate offset and to set a delay 
+     * optionsObject has the following keys: left, top, delay
+     * delay defualts to 500 milliseconds and used to specify the time to wait before firing
+     */
+    fluid.test.mouseDrop = function (location, optionsObject) {
+        var delay = setDelay(optionsObject);
+        fluid.test.mouseHover(location, optionsObject);
+        doh.robot.mouseRelease({left: true}, delay);
+    };
+    
+    /**
+     * Picks up the draggable item, and drops it at the specified location using mouse up and down 
+     * It calls the mouseDrag and mouseDrop functions to perform the action
+     * 
+     * The drag and drop locations are specified as dragLocationObject and dropLocationObject
+     * @param {Object} dragLocationObject contains the arguements for a mouseDrag as the following keys: location, optionsObject
+     * @see fluid.test.mouseDrag
+     * @param {Object} dropLocationObject contains the arguements for a mouseDrop as the following keys: location, optionsObject
+     * @see fluid.test.mouseDrop
+     */
+    fluid.test.mouseDragAndDrop = function (dragLocationObject, dropLocationObject) {
+        fluid.test.mouseDrag(dragLocationObject.node, dragLocationObject.optionsObject);
+        fluid.test.mouseDrop(dropLocationObject.node, dropLocationObject.optionsObject);
+    };
+    
+    /**
+     * Presses down the key specified by the keyCode. Use in conjunction with fluid.test.keyUp
+     * This is a system level event called through doh.robot.keyUp
+     * 
+     * @param {int} keyCode contains an integer value representing the keyCode
+     * @see fluid.test.keys for keyCode assignments
+     * @param {Object} optionsObject (optional) contains an option to set the delay
+     * optionsObject has the following key: delay
+     * delay defualts to 500 milliseconds and used to specify the time to wait before firing
+     */
+    fluid.test.keyDown = function (keyCode, optionsObject) {
+        var delay = setDelay(optionsObject);
+        doh.robot.keyDown(keyCode, delay);
+    };
+    
+    /**
+     * Releases the key specified by the keyCode. Use in conjunction with fluid.test.keyDown
+     * This is a system level event called through doh.robot.keyDown
+     * 
+     * @param {int} keyCode contains an integer value representing the keyCode
+     * @see fluid.test.keys for keyCode assignments
+     * @param {Object} optionsObject (optional) contains an option to set the delay
+     * optionsObject has the following key: delay
+     * delay defualts to 500 milliseconds and used to specify the time to wait before firing
+     */
+    fluid.test.keyUp = function (keyCode, optionsObject) {
+        var delay = setDelay(optionsObject);
+        doh.robot.keyUp(keyCode, delay);
+    };
+    
+    /**
+     * Types the value specified by the keyCode
+     * This is a system level event called through doh.robot.keyPress
+     * This is analagous to performing a keyUp and keyDown operation in direct succession
+     * Typing characters (a-z) is better done through typeString
+     * @see fluid.tst.typeString
+     * 
+     * @param {int} keyCode contains an integer value representing the keyCode
+     * @see fluid.test.keys for keyCode assignments
+     * @param {Object} optionsObject (optional) contains an option to set the delay
+     * optionsObject has the following key: delay
+     * delay defualts to 500 milliseconds and used to specify the time to wait before firing
+     */
+    fluid.test.typeKeyCode = function (keyCode, optionsObject) {
+        var delay = setDelay(optionsObject);
+        doh.robot.keyPress(keyCode, delay);
+    };
+    
+    /**
+     * Types the value of string
+     * This is a system level event called through doh.robot.typeKeys
+     * 
+     * optionsObject has the following key: delay
+     * delay defualts to 500 milliseconds and used to specify the time to wait before firing
+     */
+    fluid.test.typeString = function (string, optionsObject) {
+        var delay = setDelay(optionsObject);
+        doh.robot.typeKeys(string, delay);
+    };
+    
+    /**
+     * Peforms keyboard drag and drop. A keyboard drag and drop action involves holding down a modifier key
+     * while tapping a direction key.
+     * 
+     * Assumes that the keyboard draggable item has already been selected
+     * 
+     * @param {Object} keyboardDragObject contains values specifying how and where to drag the item
+     * keyboardDragObject has the following keys: directionKey, distance, modifierKey
+     * modifierKey is a key such as CTRL that needs to be pushed to allow keyboard drag and drop
+     * directionKey is a key that indicates which direction to move in, it can be either a keyCode or a String (keyCodes coresponding to letters won't work)
+     * distance is the number of times to press the direction key
+     * @see fluid.test.keys for keyCode assignments
+     * The default values are modifierKey = CTRL, directionKey = Left, distance = 1
+     * 
+     * @param {Object} optionsObject (optional) contains an option to set the delay
+     * optionsObject has the following key: delay
+     * delay defualts to 500 milliseconds and used to specify the time to wait before firing
+     */
+    fluid.test.keyboardDragAndDrop = function (keyboardDragObject, optionsObject) {
+        if (keyboardDragObject) {
+            var direction = keyboardDragObject.directionKey || fluid.test.keys.LEFT;
+            var modKey = keyboardDragObject.modifierKey || fluid.test.keys.CTRL;
+            var numPresses = keyboardDragObject.distance || 1;
+            var i;
+        
+            fluid.test.keyDown(modKey, optionsObject);
+            if (typeof(direction) === "number") {
+                for (i = 0; i < numPresses; i++) {
+                    fluid.test.typeKeyCode(direction, optionsObject);
+                }
+            } else {
+                for (i = 0; i < numPresses; i++) {
+                    fluid.test.typeString(direction, optionsObject);
+                }
+            }
+            fluid.test.keyUp(modKey, optionsObject); 
+        }   
+    };
+    
+    /**
+     * Peforms keyboard movement. It is very similar to the keyboardDragAndDrop function except
+     * it only moves selection, and not an item
+     * 
+     * Assumes that focus is in the correct position
+     * 
+     * @param {Object} keyboardMoveObject contains values specifying how and where to move selection
+     * keyboardMoveObject has the following keys: directionKey, distance
+     * 
+     * directionKey is a key that indicates which direction to move it can be either a keyCode or a String (keyCodes coresponding to letters won't work)
+     * distance is the number of times to press the direction key
+     * 
+     * @see fluid.test.keys for keyCode assignments
+     * The default values are directionKey = Left, distance = 1
+     * 
+     * @param {Object} optionsObject (optional) contains an option to set the delay
+     * optionsObject has the following key: delay
+     * delay defualts to 500 milliseconds and used to specify the time to wait before firing
+     */
+    fluid.test.keyboardMovement = function (keyboardMoveObject, optionsObject) {
+        if (keyboardMoveObject) {
+            var direction = keyboardMoveObject.directionKey || fluid.test.keys.LEFT;
+            var numPresses = keyboardMoveObject.distance || 1;
+            var i;
+            
+            if (typeof(direction) === "number") {
+                for (i = 0; i < numPresses; i++) {
+                    fluid.test.typeKeyCode(direction, optionsObject);
+                }
+            } else {
+                for (i = 0; i < numPresses; i++) {
+                    fluid.test.typeString(direction, optionsObject);
+                }
+            }
+        } 
+    };
+    
+    /**
+     * Tabs to the specified element.
+     * This is somewhat artificial as it applies focus to the passed element, shift-tabs off, and tabs back onto the element
+     * 
+     * @param {element||jQuery} node is a DOM element or single jQuery element
+     * 
+     * @param {Object} optionsObject (optional) contains an option to set the delay
+     * optionsObject has the following key: delay
+     * delay defualts to 500 milliseconds and used to specify the time to wait before firing
+     */
+    fluid.test.tabTo = function (node, optionsObject) {
+        $(node).focus();
+        
+        fluid.test.keyDown(fluid.test.keys.SHIFT, optionsObject);
+        fluid.test.typeKeyCode(fluid.test.keys.TAB, optionsObject);
+        fluid.test.keyUp(fluid.test.keys.SHIFT, optionsObject);
+        fluid.test.typeKeyCode(fluid.test.keys.TAB, optionsObject);
+    };
+    
+    /**
+     * Shift-tabs to the specified element.
+     * This is somewhat artificial as it applies focus to the passed element, tabs off, and shift-tabs back onto the element
+     * 
+     * @param {element||jQuery} node is a DOM element or single jQuery element
+     * 
+     * @param {Object} optionsObject (optional) contains an option to set the delay
+     * optionsObject has the following key: delay
+     * delay defualts to 500 milliseconds and used to specify the time to wait before firing
+     */
+    fluid.test.shiftTabTo = function (node, optionsObject) {
+        $(node).focus();
+        
+        fluid.test.typeKeyCode(fluid.test.keys.TAB, optionsObject);
+        fluid.test.keyDown(fluid.test.keys.SHIFT, optionsObject);
+        fluid.test.typeKeyCode(fluid.test.keys.TAB, optionsObject);
+        fluid.test.keyUp(fluid.test.keys.SHIFT, optionsObject);
+    };
+    
+    /**
+     * Provedes a set of keyCode values to use in place of the integer values
+     * @final
+     */
+    fluid.test.keys = {
+        BACKSPACE: 8,
+        TAB: 9,
+        ENTER: 13,
+        SHIFT: 16,
+        CTRL: 17,
+        ALT: 18,
+        META: 19,
+        SPACE: 32,
+        PAGE_UP: 33,
+        PAGE_DOWN: 34,
+        END: 35,
+        HOME: 36,
+        LEFT: 37,
+        UP: 38,
+        RIGHT: 39,
+        DOWN: 40,
+        DELETE: 46
+    };
+    
+    
+      //-----------------\\
+     //Assertion Functions\\
+    //---------------------\\
+    
+    
+    /**
+     * Asserts that the passed object is truethy
+     * Calls doh.assertTrue to perform the assertion
+     * 
+     * @param {Object} object contains the object to test
+     */
+    fluid.test.assertTrue = function (object) {
+        doh.assertTrue(object);
+    };
+    
+    /**
+     * Asserts that the passed object is falsey
+     * Calls doh.assertFalse to perform the assertion
+     * 
+     * @param {Object} object contains the object to test
+     */
+    fluid.test.assertFalse = function (object) {
+        doh.assertFalse(object);
+    };
+    
+    /**
+     * Asserts that the expected value equals the actual value
+     * Calls doh.assertEqual to perform the assertion
+     * 
+     * @param {Object} object contains the object to test
+     */
+    fluid.test.assertEqual = function (expected, actual) {
+        doh.assertEqual(expected, actual);
+    };
+    
+    /**
+     * Asserts that the notExpected value does not equal the actual value
+     * Calls doh.assertNotEqual to perform the assertion
+     * 
+     * @param {Object} object contains the object to test
+     */
+    fluid.test.assertNotEqual = function (notExpected, actual) {
+        doh.assertNotEqual(notExpected, actual);
+    };
+    
+      //--------------\\
+     //Public Functions\\
+    //------------------\\
+        
+    /**
+     * Refreshes the iframe by replacing the body with a cloned version of the original body
+     * After replacing the body, it runs the passed refreshFn and updates the clone
+     * 
+     * @param {Function} refreshFn is a function which tells it what other refresh operations need to take place.
+     */
+    fluid.test.refreshIframe = function (refreshFn) {
+        var refresh = refreshFn || function () {};
+        $("body", iFrame).replaceWith(bodyClone);
+        refresh();
+        bodyClone = $("body", iFrame).clone();
+    };
+
+    
+      //---------------\\
+     //Private Functions\\
+    //-------------------\\
+    
+    
+    /**
+     * Calculates the absolute position of a node, taking into account the offsets passed in the contextObject
+     * 
+     * @param {element||jQuery||Object} node a DOM element, a single jQuery elment, or an object containing coordinates with the keys left and top
+     * @param {Object} optionsObject (optional) contains options to fine tune the coordinate offset
+     * optionsObject has the following keys: left, top
+     * 
+     * @return {Object} containing the adjusted coordinates with the following keys: left, top
+     * @private
+     */  
+    adjustedPosition = function (node, offsetObject) {
+        var leftPosition;
+        var topPosition;
+        var nodeLeft = 0;
+        var nodeTop = 0;
+        var offsetLeft = 0;
+        var offsetTop = 0;
+        var position = {};
+        var scrollWindow = $(document);
+        var scrollIframe = iframeScrollOffset(context.iframe);
+        var offsets;
+        
+        if (offsetObject) {
+            offsetLeft = offsetObject.left || 0;
+            offsetTop = offsetObject.top || 0;
+        }
+        
+        if (node.jquery || node.nodeType !== undefined) {
+            offsets = $(node).offset();
+
+            nodeLeft = offsets.left;
+            nodeTop = offsets.top;
+        } else if (node) {
+            nodeLeft = node.left || 0;
+            nodeTop = node.top || 0; 
+        }
+        
+        leftPosition = nodeLeft + offsetLeft + adjustmentLeft + iframeOffsetLeft - scrollWindow.scrollLeft() - scrollIframe.left;
+        topPosition = nodeTop + offsetTop + adjustmentTop + iframeOffsetTop - scrollWindow.scrollTop() - scrollIframe.top;
+        
+        position = {
+            left: leftPosition,
+            top: topPosition
+        };
+        
+        return position;
+    };
+    
+    /**
+     * Sets the delay. The actions won't happen until after the delay time has passed.
+     * 
+     * @param {Object} delayObject contains the value specifying the delay time in milliseconds
+     * delayObject has the following key: delay
+     * The default value is 500 milliseconds.
+     * 
+     * @return an integer value of the delay time
+     * @private
+     */
+    setDelay = function (delayObject) {
+        var delayTime = 500;
+        if (delayObject) {
+            delayTime = delayObject.delay || 500;
+        }
+        return delayTime;
+    };
+    
+    /**
+     * Sets the context variables
+     * Context variables are the iframe and additional offsets
+     * 
+     * @param {Object} contextObject containing values specifying the iframe and any other offsets necessary
+     * iframe is the iframe node or jquery object containing it. If not provided, it will be assumed that there is no iframe.
+     * adjustmentX is a numeric value specifying any additional x offset. The default is 0.
+     * adjustmentY is a numeric value specifying any additional y offset. The default is 0.
+     * @private
+     */
+    setContext = function (contextObject) {
+        var offsets;
+        
+        if (contextObject) {
+            if (contextObject.iframe) {
+                offsets = $(contextObject.iframe).offset();
+                iframeOffsetTop = offsets.top || 0;
+                iframeOffsetLeft = offsets.left || 0;
+            }
+            adjustmentTop = contextObject.adjustmentY || 0;
+            adjustmentLeft = contextObject.adjustmentX || 0;
+        }
+    };
+    
+    /**
+     * Determines the scroll offset of the iframe
+     * 
+     * @param {element||jQuery} frame is a DOM element or a single jQuery element representing an iframe
+     * @return {Object} containing the scroll offsets with the following keys: top, left
+     * @private
+     */
+    iframeScrollOffset = function (frame) {
+        var scrollOffsetTop = 0;
+        var scrollOffsetLeft = 0;
+        var scrolledFrame;
+        var scrollOffset;
+        
+        if (frame) {
+            scrolledFrame = $(frame).contents().find("html");
+            scrollOffsetTop = scrolledFrame.scrollTop();
+            scrollOffsetLeft = scrolledFrame.scrollLeft();
+        }
+        
+        scrollOffset = {
+            top: scrollOffsetTop,
+            left: scrollOffsetLeft
+        };
+        
+        return scrollOffset;
+    };
+    
+    /**
+     * Determines whether or not a given position is currently visible in the viewport
+     * 
+     * @param {Object} positionObject containing the the coordinates of position to test
+     * positionObject has the following keys: top, left
+     * 
+     * @return a boolean value of true if the position is in view and false otherwise
+     * @private
+     */
+    isInView = function (positionObject) {
+        var positionTop;
+        var positionLeft;
+        var frame;
+        var pageHeight;
+        var pageWidth;
+        var viewAreaVertical;
+        var viewAreaHorizontal;
+        
+        if (positionObject) {
+            positionTop = positionObject.top || 0;
+            positionLeft = positionObject.left || 0;
+            
+            frame = $(context.iframe);
+            pageHeight = $(window).height();
+            pageWidth = $(window).width();
+            
+            viewAreaVertical = {
+                top: calculateViewTop(),
+                bottom: calculateViewBottom()
+            };
+            
+            viewAreaHorizontal = {
+                left: calculateViewLeft(),
+                right: calculateViewRight()
+            };
+            
+            if (positionTop >= viewAreaVertical.top && positionTop <= viewAreaVertical.bottom && positionLeft >= viewAreaHorizontal.left && positionLeft <= viewAreaHorizontal.right) {
+                return true;
+            } else {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    };
+    
+    /**
+     * Adjusts the scroll of the iframe to attempt to centre the passed position within the viewport
+     * 
+     * @param {Object} positionObject contains the coordinates of the position to centre the viewport on
+     * positionObject has the following keys: top, left
+     * @private
+     */
+    scrollIntoView = function (positionObject) {
+        var positionTop;
+        var positionLeft;
+        var frame;
+        var frameScroll;
+        var frameScrollTop;
+        var frameScrollLeft;
+        var frameHeight;
+        var frameWidth;
+        var page;
+        var pageHeight;
+        var pageWidth;
+        var viewHeight;
+        var viewWidth;
+        var midVert;
+        var midHor;
+        var newScrollTop;
+        var newScrollLeft;
+        
+        if (positionObject) {
+            positionTop = positionObject.top || 0;
+            positionLeft = positionObject.left || 0;
+            
+            frame = $(context.iframe);
+            frameHeight = frame.innerHeight();
+            frameWidth = frame.innerWidth();
+            frameScroll = frame.contents().find("html");
+            frameScrollTop = frameScroll.scrollTop();
+            frameScrollLeft = frameScroll.scrollLeft();
+            
+            page = $(window);
+            pageHeight = page.height();
+            pageWidth = page.width();
+            
+            viewHeight = Math.min(pageHeight, frameHeight);
+            viewWidth = Math.min(pageWidth, frameWidth);
+            
+            midVert = (viewHeight / 2);
+            midHor = (viewWidth / 2);
+            
+            if (positionTop < midVert) {
+                if (positionTop < 0) {
+                    newScrollTop = 0;
+                } else {
+                    newScrollTop = Math.max(0, frameScrollTop - (midVert - positionTop));  
+                }
+                
+            } else {
+                newScrollTop = positionTop - midVert + frameScrollTop;
+            }
+            
+            if (positionLeft < midHor) {
+                if (positionLeft < 0) {
+                    newScrollLeft = 0;
+                } else {
+                    newScrollLeft = Math.max(0, frameScrollLeft - (midHor - positionLeft));  
+                }
+                
+            } else {
+                newScrollLeft = positionLeft - midHor  + frameScrollLeft;
+            }
+            
+            frameScroll.scrollTop(newScrollTop);
+            page.scrollLeft(newScrollLeft);
+        }
+    };
+    
+    /**
+     * Calculates what the top of the current viewport is
+     * 
+     * @return the integer value of its position
+     * @private
+     */
+    calculateViewTop = function () {
+        var pageHeight = $(window).height();
+        var frame = $(context.iframe);
+        var pageTop; 
+        
+        pageTop = Math.max(0, pageHeight - frame.innerHeight());
+        
+        return pageTop;
+        
+    };
+    
+    /**
+     * Calculates what the bottom of the current viewport is
+     * 
+     * @return the integer value of its position
+     * @private
+     */
+    calculateViewBottom = function () {
+        var pageHeight = $(window).height();
+        var pageBottom;
+        
+        pageBottom = pageHeight;
+        
+        return pageBottom;
+    };
+    
+    /**
+     * Calculates what the left of the current viewport is
+     * 
+     * @return the integer value of its position
+     * @private
+     */
+    calculateViewLeft = function () {
+        var pageWidth = $(window).width();
+        var frame = $(context.iframe);
+        var pageLeft;
+        
+        pageLeft = Math.max(0, pageWidth - frame.innerWidth());
+        
+        return pageLeft;
+    };
+    
+    /**
+     * Calculates what the right of the current viewport is
+     * 
+     * @return the integer value of its position
+     * @private
+     */
+    calculateViewRight = function () {
+        var pageWidth = $(window).width();
+        var pageRight;
+        
+        pageRight = pageWidth;
+        
+        return pageRight;
+    };
+    
+})(jQuery);
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/image-reorderer-automated.js
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/image-reorderer-automated.js	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/image-reorderer-automated.js	(revision 0)
@@ -0,0 +1,530 @@
+/*global jQuery, $, fluid*/
+fluid.test.runAutomatedTest(function () {   
+ 
+    //Variables which can be used by all tests
+    var iframe = $("#testFrame");
+    var iframeContents = iframe.contents();
+    var selector = "div[id^='gallerylightbox-cell:']";
+    var thumbnails = iframeContents.find(selector);
+    var numImages = thumbnails.length;
+    var currentPosition;
+    var locations = [];
+    var i;
+    var reset = function () {
+            $(window)[0].frames.testFrame.fluid.reorderImages("#gallery");
+        };
+    
+    //Private functions
+    var imageIndex;
+    var calculatedHorizontalPosition;
+    var calculatedVerticalPosition;
+    var findThumbs;
+    
+    //fill array
+    for (i = 0; i < numImages; i++) {
+        locations[i] = thumbnails.eq(i).offset(); 
+    }
+    
+    /*
+     * Automated Tests
+     */
+    
+    //State Tests
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Mouse>>", 
+        name: "**Drag and Drop**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.mouseDragAndDrop({node: locations[3]}, {node: locations[7]});
+        }, 
+        assertionFunction: function () {
+            fluid.test.assertEqual(7, imageIndex("div[id*=':3:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    }); 
+
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (Right Arrow)**", 
+        timeout: 69000,
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':6:']");
+            
+            thumbnails.eq(6).focus();
+//            fluid.test.shiftTabTo(thumbnails.eq(6));
+            fluid.test.keyboardMovement({directionKey: fluid.test.keys.RIGHT, distance: 3});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(currentPosition, imageIndex("div[id*=':6:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (Left Arrow)**", 
+        timeout: 69000,
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':7:']");
+            
+            thumbnails.eq(7).focus();
+//            fluid.test.shiftTabTo(thumbnails.eq(7));
+            fluid.test.keyboardMovement({distance: 3});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(currentPosition, imageIndex("div[id*=':7:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (Up Arrow)**", 
+        timeout: 69000,
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':8:']");
+            
+            thumbnails.eq(8).focus();
+//            fluid.test.shiftTabTo(thumbnails.eq(8));
+            fluid.test.keyboardMovement({directionKey: fluid.test.keys.UP, distance: 3});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(currentPosition, imageIndex("div[id*=':8:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (Down Arrow)**", 
+        timeout: 69000,
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':9:']");
+            
+            thumbnails.eq(9).focus();
+//            fluid.test.shiftTabTo(thumbnails.eq(9));
+            fluid.test.keyboardMovement({directionKey: fluid.test.keys.DOWN, distance: 3});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(currentPosition, imageIndex("div[id*=':9:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (k)**", 
+        timeout: 69000,
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':10:']");
+            
+            thumbnails.eq(10).focus();
+//            fluid.test.shiftTabTo(thumbnails.eq(10));
+            fluid.test.keyboardMovement({directionKey: "k", distance: 3});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(currentPosition, imageIndex("div[id*=':10:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (j)**", 
+        timeout: 69000,
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':11:']");
+            
+            thumbnails.eq(11).focus();
+//            fluid.test.shiftTabTo(thumbnails.eq(11));
+            fluid.test.keyboardMovement({directionKey: "j", distance: 3});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(currentPosition, imageIndex("div[id*=':11:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (i)**", 
+        timeout: 69000,
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':12:']");
+            
+            thumbnails.eq(12).focus();
+//            fluid.test.shiftTabTo(thumbnails.eq(12));
+            fluid.test.keyboardMovement({directionKey: "i", distance: 3});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(currentPosition, imageIndex("div[id*=':12:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection**", 
+        timeout: 69000,
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':5:']");
+            
+            thumbnails.eq(5).focus();
+//            fluid.test.shiftTabTo(thumbnails.eq(5));
+            fluid.test.keyboardMovement({directionKey: "m", distance: 3});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(currentPosition, imageIndex("div[id*=':5:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+ 
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (Right Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':3:']");
+            
+            thumbnails.eq(3).focus();
+//            fluid.test.shiftTabTo(thumbnails.eq(3));
+            fluid.test.keyboardDragAndDrop({directionKey: fluid.test.keys.RIGHT, distance: 3});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedHorizontalPosition(currentPosition, 3), imageIndex("div[id*=':3:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (Left Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':4:']");
+            
+            thumbnails.eq(4).focus();
+//            fluid.test.shiftTabTo(thumbnails.eq(4));
+            fluid.test.keyboardDragAndDrop({directionKey: fluid.test.keys.LEFT, distance: 3});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedHorizontalPosition(currentPosition, -3), imageIndex("div[id*=':4:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (Up Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':5:']");
+            
+            thumbnails.eq(5).focus();
+//            fluid.test.shiftTabTo(thumbnails.eq(5));
+            fluid.test.keyboardDragAndDrop({directionKey: fluid.test.keys.UP, distance: 3});
+            
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(11, imageIndex("div[id*=':5:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (Down Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':6:']");
+            
+            thumbnails.eq(6).focus();
+//            fluid.test.shiftTabTo(thumbnails.eq(6));
+            fluid.test.keyboardDragAndDrop({directionKey: fluid.test.keys.DOWN, distance: 3});
+            
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(6, imageIndex("div[id*=':6:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (i)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':7:']");
+            
+            thumbnails.eq(7).focus();
+//            fluid.test.shiftTabTo(thumbnails.eq(7));
+            fluid.test.keyboardDragAndDrop({directionKey: "i", distance: 3});
+            
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(7, imageIndex("div[id*=':7:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (m)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':8:']");
+            
+            thumbnails.eq(8).focus();
+//            fluid.test.shiftTabTo(thumbnails.eq(8));
+            fluid.test.keyboardDragAndDrop({directionKey: "m", distance: 3});
+            
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(2, imageIndex("div[id*=':8:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (k)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':9:']");
+            
+            thumbnails.eq(9).focus();
+//            fluid.test.shiftTabTo(thumbnails.eq(9));
+            fluid.test.keyboardDragAndDrop({directionKey: "k", distance: 3});
+            
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedHorizontalPosition(currentPosition, 3), imageIndex("div[id*=':9:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (j)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':10:']");
+            
+            thumbnails.eq(10).focus();
+//            fluid.test.shiftTabTo(thumbnails.eq(10));
+            fluid.test.keyboardDragAndDrop({directionKey: "j", distance: 3});
+            
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedHorizontalPosition(currentPosition, -3), imageIndex("div[id*=':10:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Move to first position**", 
+        timeout: 69000,
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':5:']");
+            fluid.test.mouseDragAndDrop({node: locations[5]}, {node: locations[0]});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedHorizontalPosition(currentPosition, -5), imageIndex("div[id*=':5:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Move to last position**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':1:']");
+            fluid.test.mouseDragAndDrop({node: locations[1]}, {node: locations[13]});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedHorizontalPosition(currentPosition, 12), imageIndex("div[id*=':1:']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Drop on white space**", 
+        timeout: 69000,
+        actionFunction: function () {
+            currentPosition = imageIndex("div[id*=':10:']");
+            fluid.test.mouseDragAndDrop({node: locations[10]}, {node: {top: 0, left: 0}});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedHorizontalPosition(currentPosition, -10), imageIndex("div[id*=':10:']")); 
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findThumbs();
+        }
+    });
+
+    //runs the tests
+    fluid.test.run();
+    
+    //helper functions
+    
+    /**
+     * Determines the current index of an element
+     * It will take into account the iframe
+     * 
+     * @param {String} selectorString a jQuery selector to find a single item in the DOM
+     * @return {int} value of its index
+     */
+    imageIndex = function (selectorString) {
+        var images = iframeContents.find(selector);
+        var index = images.index(iframeContents.find(selectorString));
+        
+        return index;  
+    };
+    
+    /**
+     * Calculates what the new position should be
+     * can't handle up and down position changes, only left and right
+     * 
+     * @param {Object} current an integer value of the current position
+     * @param {Object} change an integer value representing the number of positions moved
+     * They represent the current index location and the number of positions moved
+     * Positions moved is passed as a positive integer for moving right and negative for left
+     * 
+     * @return {int} value of the new position
+     */
+    calculatedHorizontalPosition = function (current, change) {
+        var newPosition;
+        var result;
+        
+        newPosition = current + change;
+        
+        result = newPosition % numImages;
+        if (result < 0) {
+            result += numImages;
+        }
+        
+        return result;
+    };
+    
+    /**
+     * DOESN'T WORK. DON'T USE.
+     * NEED TO DEVELOP A STRATEGY TO PROGRAMATICALLY CALCULATE UP/DOWN MOVEMENT
+     * 
+     * Calculates what the new position should be
+     * can't handle left and right position changes, only up and down
+     *
+     */
+    calculatedVerticalPosition = function () {};
+    
+    /**
+     * Creates the set of thumbnails
+     * 
+     * This should be called after a reset, to ensure that the set is current
+     */
+    findThumbs = function () {
+        thumbnails = iframeContents.find(selector);
+    };
+    
+}, {iframe: "#testFrame", adjustmentX: 10, adjustmentY: 10});
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/inline-edit-automated.js
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/inline-edit-automated.js	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/inline-edit-automated.js	(revision 0)
@@ -0,0 +1,303 @@
+/*global jQuery, $, fluid*/
+fluid.test.runAutomatedTest(function () {   
+ 
+    //Variables which can be used by all tests
+    var iframe = $("#testFrame");
+    var iframeContents = iframe.contents();
+    var inlineEditFields = iframeContents.find("span.editContainer").prev();
+    var undoLink = iframeContents.find("a.undoControl");
+    var redoLink = iframeContents.find("a.redoControl");
+    var numFields = inlineEditFields.length;
+    var initialValues = [];
+    var i;
+    var reset = function () {
+        $(window)[0].frames.testFrame.inlineEditSetup();
+    };
+    
+    //private functions
+    var deleteAllText;
+    var findInlineEdits;
+    
+    //Input values which can be used by all tests
+    var invitationText = "Click here to edit";
+    var singleChar = "a";
+    var letters = "aAbBcC";
+    var digits = "0123456789";
+    var symbols = "~`!@#$%^&*()_-+=|\\[]{}\'\": ;?/<>,.";
+    var manyNonSeperatedChars = "qqqqqqqqqqqqqwwwwwwwwwwwweeeeeeeeeeeeerrrrrrrrrrrrrrrrtttttttttttttttttyyyyyyyyyyyyyyyyyyyyy";
+    var manySeperatedChars = "qqqqqqqqqqqqq wwwwwwwwwwww eeeeeeeeeeeee rrrrrrrrrrrrrrrr ttttttttttttttttt yyyyyyyyyyyyyyyyyyyyy";
+    
+    //fill initialValues array
+    for (i = 0; i < numFields; i++) {
+        initialValues[i] = inlineEditFields.eq(i).text();
+    }
+    
+    /*
+     * Automated Tests
+     */
+    
+    //State Tests
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Mouse>>", 
+        name: "**Edit Text**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.mouseClick(inlineEditFields.eq(0));
+            fluid.test.typeString(singleChar);
+            fluid.test.mouseClick({left: 0, top: 0}, {adjustmentX: -2, adjustmentY: -2});
+        }, 
+        assertionFunction: function () {
+            fluid.test.assertEqual(initialValues[0] + singleChar, inlineEditFields.eq(0).text());
+        }
+    });
+   
+    fluid.test.testCase({
+        groupName: "<<State Tests: Mouse>>", 
+        name: "**Undo**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.mouseClick(undoLink.eq(0));
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(initialValues[0], inlineEditFields.eq(0).text());
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Mouse>>", 
+        name: "**Redo**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.mouseClick(redoLink.eq(0));
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(initialValues[0] + singleChar, inlineEditFields.eq(0).text());
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findInlineEdits();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Edit Text**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.tabTo(inlineEditFields.eq(1));
+            fluid.test.typeKeyCode(fluid.test.keys.ENTER);
+            fluid.test.typeString(singleChar);
+            fluid.test.typeKeyCode(fluid.test.keys.ENTER);
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(initialValues[1] + singleChar, inlineEditFields.eq(1).text());
+        }
+    });
+
+    fluid.test.testCase({
+            groupName: "<<State Tests: Keyboard>>", 
+            name: "**Undo**", 
+            timeout: 69000, 
+            actionFunction: function () {
+                fluid.test.typeKeyCode(fluid.test.keys.TAB);
+                fluid.test.typeKeyCode(fluid.test.keys.ENTER);
+            },
+            assertionFunction: function () {
+                fluid.test.assertEqual(initialValues[1], inlineEditFields.eq(1).text());
+            }
+        });
+
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Redo**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.typeKeyCode(fluid.test.keys.ENTER);
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(initialValues[1] + singleChar, inlineEditFields.eq(1).text());
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findInlineEdits();
+        }
+    });
+
+    
+    // Task Oriented Functional Tests
+    
+    fluid.test.testCase({
+        groupName: "<<Task Oriented Functional Tests>>", 
+        name: "**Edit with letters**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            var field = inlineEditFields.eq(0);
+            
+            fluid.test.mouseClick(field);
+            deleteAllText(field);
+            fluid.test.typeString(letters);
+            fluid.test.typeKeyCode(fluid.test.keys.ENTER);
+            
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(letters, inlineEditFields.eq(0).text());
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findInlineEdits();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Task Oriented Functional Tests>>", 
+        name: "**Edit with numbers**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            var field = inlineEditFields.eq(1);
+            
+            fluid.test.mouseClick(field);
+            deleteAllText(field);
+            fluid.test.typeString(digits);
+            fluid.test.typeKeyCode(fluid.test.keys.ENTER);
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(digits, inlineEditFields.eq(1).text());
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findInlineEdits();
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<Task Oriented Functional Tests>>", 
+        name: "**Edit with Symbols**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            var field = inlineEditFields.eq(2);
+            
+            fluid.test.mouseClick(field);
+            deleteAllText(field);
+            fluid.test.typeString(symbols);
+            fluid.test.typeKeyCode(fluid.test.keys.ENTER);
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(symbols, inlineEditFields.eq(2).text());
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findInlineEdits();
+        }
+    });
+
+    
+    //Boundary Tests
+    
+    fluid.test.testCase({
+        groupName: "<<Boundary tests>>", 
+        name: "**Empty Field**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            var field = inlineEditFields.eq(0);
+            
+            fluid.test.mouseClick(field);
+            deleteAllText(field);
+            fluid.test.typeKeyCode(fluid.test.keys.ENTER);
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(invitationText, inlineEditFields.eq(0).text());
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findInlineEdits();
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<Boundary tests>>", 
+        name: "**Many Characters (Not Seperated)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            var field = inlineEditFields.eq(2);
+            fluid.test.mouseClick(field);
+            deleteAllText(field);
+            fluid.test.typeString(manyNonSeperatedChars);
+            fluid.test.typeKeyCode(fluid.test.keys.ENTER, {delay: 2000});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(manyNonSeperatedChars, inlineEditFields.eq(2).text());
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findInlineEdits();
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<Boundary tests>>", 
+        name: "**Many Characters (Seperated)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            var field = inlineEditFields.eq(1);
+            fluid.test.mouseClick(field);
+            deleteAllText(field);
+            fluid.test.typeString(manySeperatedChars);
+            fluid.test.typeKeyCode(fluid.test.keys.ENTER, {delay: 2000});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(manySeperatedChars, inlineEditFields.eq(1).text());
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findInlineEdits();
+        }
+    });
+
+    
+    //runs the tests
+    fluid.test.run();
+    
+    //private functions
+    
+    /**
+     * Calls BACKSPACE.
+     * This is useful to empty an inline edit field
+     * 
+     * @param {Object} field is a specific inline edit field to empty
+     */
+    deleteAllText = function (field) {
+        var inlineField = field || $();
+        var numChars = inlineField.text().length;
+        
+        for (i = 0; i < numChars; i++) {
+            fluid.test.typeKeyCode(fluid.test.keys.BACKSPACE, {delay: 100});
+        }
+    };
+    
+    /**
+     * Recreates the set of inline edit fields
+     * 
+     * This should be called after a reset, to ensure that the set is current
+     */
+    findInlineEdits = function () {
+        inlineEditFields = iframeContents.find("span.editContainer").prev();
+    };
+    
+}, {iframe: "#testFrame", adjustmentX: 2, adjustmentY: 2});
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/layout-reorderer-automated.js
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/layout-reorderer-automated.js	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/layout-reorderer-automated.js	(revision 0)
@@ -0,0 +1,640 @@
+/*global jQuery, $, fluid*/
+fluid.test.runAutomatedTest(function () {   
+ 
+    //Variables which can be used by all tests
+    var iframe = $("#testFrame");
+    var iframeContents = iframe.contents();
+    var selectorMovable = "div[class*='movable']";
+    var selectorLocked =  "div[class*='locked']";
+    var movablePortlets = iframeContents.find(selectorMovable);
+    var lockedPortlets = iframeContents.find(selectorLocked).not("div[class*='toolbar']");
+    var numMovable = movablePortlets.length;
+    var idSelector = [];
+    var i;
+    var reset = function () {
+        $(window)[0].frames.testFrame.demo.initFluidComponents();
+    };
+    
+    //private functions
+    var itemIndex;
+    var dragBelowOffset;
+    var findPortlets;
+    
+    //fill arrays
+    for (i = 0; i < numMovable; i++) {
+        idSelector[i] = "div[id='" + movablePortlets.eq(i).attr("id") + "']";
+    }
+    
+    /*
+     * Automated Tests
+     */
+    
+    //State Tests
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Mouse>>", 
+        name: "**Drag and Drop**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.mouseDragAndDrop({node: movablePortlets.eq(0)}, {node: movablePortlets.eq(3)});
+        }, 
+        assertionFunction: function () {
+            fluid.test.assertEqual(3, itemIndex(idSelector[0]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    }); 
+
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (Up Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(1));
+            fluid.test.keyboardMovement({directionKey: fluid.test.keys.UP, distance: 2});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(2, itemIndex(idSelector[1]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (Down Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(1));
+            fluid.test.keyboardMovement({directionKey: fluid.test.keys.DOWN, distance: 2});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(2, itemIndex(idSelector[1]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (Left Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(1));
+            fluid.test.keyboardMovement({directionKey: fluid.test.keys.LEFT, distance: 2});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(2, itemIndex(idSelector[1]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (Right Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(1));
+            fluid.test.keyboardMovement({directionKey: fluid.test.keys.RIGHT, distance: 2});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(2, itemIndex(idSelector[1]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+ 
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (i)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(1));
+            fluid.test.keyboardMovement({directionKey: "i", distance: 2});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(2, itemIndex(idSelector[1]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (m)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(1));
+            fluid.test.keyboardMovement({directionKey: "m", distance: 3});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(2, itemIndex(idSelector[1]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (j)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(1));
+            fluid.test.keyboardMovement({directionKey: "j", distance: 2});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(2, itemIndex(idSelector[1]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (k)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(1));
+            fluid.test.keyboardMovement({directionKey: "k", distance: 3});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(2, itemIndex(idSelector[1]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+ 
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (Up Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(1));
+            fluid.test.keyboardDragAndDrop({directionKey: fluid.test.keys.UP, distance: 2});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(3, itemIndex(idSelector[1]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (Down Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(2));
+            fluid.test.keyboardDragAndDrop({directionKey: fluid.test.keys.DOWN, distance: 2});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(2, itemIndex(idSelector[2]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (Left Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(0));
+            fluid.test.keyboardDragAndDrop({directionKey: fluid.test.keys.LEFT, distance: 1});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(2, itemIndex(idSelector[0]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (Right Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(3));
+            fluid.test.keyboardDragAndDrop({directionKey: fluid.test.keys.RIGHT, distance: 1});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(2, itemIndex(idSelector[3]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (i)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(2));
+            fluid.test.keyboardDragAndDrop({directionKey: "i", distance: 2});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(4, itemIndex(idSelector[2]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (m)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(3));
+            fluid.test.keyboardDragAndDrop({directionKey: "m", distance: 1});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(2, itemIndex(idSelector[3]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (j)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(2));
+            fluid.test.keyboardDragAndDrop({directionKey: "j", distance: 1});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(2, itemIndex(idSelector[2]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (k)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(0));
+            fluid.test.keyboardDragAndDrop({directionKey: "k", distance: 1});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(2, itemIndex(idSelector[0]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+
+
+    fluid.test.testCase({
+        groupName: "<<Task Oriented Functional Tests>>", 
+        name: "**Move portlet below locked portlet**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            var offset = dragBelowOffset(lockedPortlets.eq(0));
+            fluid.test.mouseDragAndDrop({node: movablePortlets.eq(1)}, {node: lockedPortlets.eq(0), optionsObject: offset});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(1, itemIndex(idSelector[1]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Move to first position**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.mouseDragAndDrop({node: movablePortlets.eq(0)}, {node: movablePortlets.eq(1)});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(1, itemIndex(idSelector[0]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Move to last position**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            var offset = dragBelowOffset(movablePortlets.eq(3));
+            fluid.test.mouseDragAndDrop({node: movablePortlets.eq(2)}, {node: movablePortlets.eq(3), optionsObject: offset});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(4, itemIndex(idSelector[2]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Drop out of column**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.mouseDragAndDrop({node: movablePortlets.eq(0)}, {node: {top: 0, left: 0}});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(1, itemIndex(idSelector[0]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Move to an empty column - prep 1**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(1));
+            fluid.test.keyboardDragAndDrop({directionKey: "j", distance: 1});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(1, itemIndex(idSelector[1]));
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Move to an empty column - prep 2**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(2));
+            fluid.test.keyboardDragAndDrop({directionKey: "j", distance: 1});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(1, itemIndex(idSelector[2]));
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Move to an empty column - prep 3**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(3));
+            fluid.test.keyboardDragAndDrop({directionKey: "j", distance: 1});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(1, itemIndex(idSelector[3]));
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Move to an empty column - mouse**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.mouseDragAndDrop({node: movablePortlets.eq(0)}, {node: movablePortlets.eq(0), optionsObject: {left: 500}});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(4, itemIndex(idSelector[0]));
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Move to an empty column - prep 4**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(0));
+            fluid.test.keyboardDragAndDrop({directionKey: "j", distance: 1});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(1, itemIndex(idSelector[0]));
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Move to an empty column - keyboard**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(2));
+            fluid.test.keyboardDragAndDrop({directionKey: "j", distance: 1});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(4, itemIndex(idSelector[2]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Test-to-fail>>", 
+        name: "**Move above locked portlet - mouse**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.mouseDragAndDrop({node: movablePortlets.eq(1)}, {node: lockedPortlets.eq(0)});
+        },
+        assertionFunction: function () {
+            fluid.test.assertNotEqual(0, itemIndex(idSelector[1]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Test-to-fail>>", 
+        name: "**Move above locked portlet - keyboard**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(movablePortlets.eq(0));
+            fluid.test.keyboardDragAndDrop({directionKey: "i", distance: 1});
+        },
+        assertionFunction: function () {
+            fluid.test.assertNotEqual(0, itemIndex(idSelector[0]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Test-to-fail>>", 
+        name: "**Move above locked portlet - mouse**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.mouseDragAndDrop({node: lockedPortlets.eq(0)}, {node: movablePortlets.eq(1)});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(1, itemIndex(idSelector[0]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Test-to-fail>>", 
+        name: "**Move locked portlet - keyboard**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.shiftTabTo(lockedPortlets.eq(0));
+            fluid.test.keyboardDragAndDrop({directionKey: "k", distance: 1});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(1, itemIndex(idSelector[0]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findPortlets();
+        }
+    });
+
+    //runs the tests
+    fluid.test.run();
+    
+    //helper functions
+    
+    /**
+     * Determines the current index of an element
+     * It will take into account the iframe
+     * 
+     * @param {Object} selectorString a jQuery selector to find a single item
+     * @return {Object} an integer value of the index
+     */
+    itemIndex = function (selectorString) {
+        var itemSet = iframeContents.find(selectorLocked).not("div[class*='toolbar']").add(iframeContents.find(selectorMovable));
+        var index = itemSet.index(iframeContents.find(selectorString));
+        
+        return index;  
+    };
+    
+    /**
+     * Determines the vertical offset required to place a portlet below another one
+     * 
+     * @param {Object} portlet the portlet that you want to place another portlet below
+     * @param {Object} an integer value representing the adjustment if both portlets are in the same column
+     * This should be the height of the portlet being moved. The default value is 0
+     * 
+     * @returns {Object} an object {top} containing the key top with an integer value of the offset
+     * to apply to the mouse drag and drop operation 
+     */
+    dragBelowOffset = function (portlet, sameColumnAdjustment) {
+        var midPoint = {top: 0};
+        var adjustment = sameColumnAdjustment || 0;
+        
+        if (portlet) {
+            midPoint.top = (portlet.height() / 2) - adjustment;
+        } 
+        
+        return midPoint;
+    };
+    
+    /**
+     * Creates the sets of locked and movable portlets and thumbnails
+     * 
+     * This should be called after a reset, to ensure that the sets are current
+     */
+    findPortlets = function () {
+        movablePortlets = iframeContents.find(selectorMovable);
+        lockedPortlets = iframeContents.find(selectorLocked).not("div[class*='toolbar']");
+    };
+    
+}, {iframe: "#testFrame", adjustmentX: 5, adjustmentY: 5});
+
+
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/pager-automated.js
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/pager-automated.js	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/pager-automated.js	(revision 0)
@@ -0,0 +1,407 @@
+/*global jQuery, $, fluid*/
+fluid.test.runAutomatedTest(function () {   
+ 
+    //Variables which can be used by all tests
+    var iframe = $("#testFrame");
+    var iframeContents = iframe.contents();
+    
+    var selectorTop = "ul#pager-top li a";
+    var selectorBottom =  "ul#pager-bottom li a";
+    var selectorTable = "table";
+    var pagerLinksTop = iframeContents.find(selectorTop);
+    var pagerLinksBottom = iframeContents.find(selectorBottom);
+    var pagerTable = iframeContents.find(selectorTable);
+    var reset = function () {
+        $(window)[0].frames.testFrame.demo.initPager();
+    };
+    
+    //private functions
+    var isOnlyVisible;
+    var isPreviousEnabled;
+    var isNextEnabled;
+    var isOnlyCurrent;
+    var findSelectors;
+    
+    
+    /*
+     * Automated Tests
+     */
+    
+    //State Tests
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Initial state>>", 
+        name: "**Initial State**", 
+        timeout: 79000, 
+        actionFunction: function () {
+        }, 
+        assertionFunction: function () {
+            fluid.test.assertTrue(isOnlyVisible(pagerTable.eq(0)));
+            fluid.test.assertTrue(isNextEnabled());
+            fluid.test.assertFalse(isPreviousEnabled());
+            fluid.test.assertTrue(isOnlyCurrent(1));
+        }
+    }); 
+
+    fluid.test.testCase({
+        groupName: "<<State Tests: Mouse>>", 
+        name: "**Next (Top)**", 
+        timeout: 79000, 
+        actionFunction: function () {
+            var topNextParent = pagerLinksTop.parent("[class*='next']");
+            var topNext = topNextParent.children();
+            fluid.test.mouseClick(topNext);
+        }, 
+        assertionFunction: function () {
+            fluid.test.assertTrue(isOnlyVisible(pagerTable.eq(1)));
+            fluid.test.assertTrue(isNextEnabled());
+            fluid.test.assertTrue(isPreviousEnabled());
+            fluid.test.assertTrue(isOnlyCurrent(2));
+        }
+    }); 
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Mouse>>", 
+        name: "**Previous (Top)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            var topPreviousParent = pagerLinksTop.parent("[class*='previous']");
+            var topPrevious = topPreviousParent.children();
+            fluid.test.mouseClick(topPrevious);
+        }, 
+        assertionFunction: function () {
+            fluid.test.assertTrue(isOnlyVisible(pagerTable.eq(0)));
+            fluid.test.assertTrue(isNextEnabled());
+            fluid.test.assertFalse(isPreviousEnabled());
+            fluid.test.assertTrue(isOnlyCurrent(1));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findSelectors();
+        }
+    }); 
+
+    fluid.test.testCase({
+        groupName: "<<State Tests: Mouse>>", 
+        name: "**Next (Bottom)**", 
+        timeout: 79000, 
+        actionFunction: function () {
+            var bottomNextParent = pagerLinksBottom.parent("[class*='next']");
+            var bottomNext = bottomNextParent.children();
+            fluid.test.mouseClick(bottomNext);
+        }, 
+        assertionFunction: function () {
+            fluid.test.assertTrue(isOnlyVisible(pagerTable.eq(1)));
+            fluid.test.assertTrue(isNextEnabled());
+            fluid.test.assertTrue(isPreviousEnabled());
+            fluid.test.assertTrue(isOnlyCurrent(2));
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Mouse>>", 
+        name: "**Previous (Bottom)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            var bottomPreviousParent = pagerLinksBottom.parent("[class*='previous']");
+            var bottomPrevious = bottomPreviousParent.children();
+            fluid.test.mouseClick(bottomPrevious);
+        }, 
+        assertionFunction: function () {
+            fluid.test.assertTrue(isOnlyVisible(pagerTable.eq(0)));
+            fluid.test.assertTrue(isNextEnabled());
+            fluid.test.assertFalse(isPreviousEnabled());
+            fluid.test.assertTrue(isOnlyCurrent(1));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findSelectors();
+        }
+    }); 
+
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Next (Top)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            var topNextParent = pagerLinksTop.parent("[class*='next']");
+            var topNext = topNextParent.children();
+            fluid.test.tabTo(topNext);
+            fluid.test.typeKeyCode(fluid.test.keys.ENTER);
+        },
+        assertionFunction: function () {
+            fluid.test.assertTrue(isOnlyVisible(pagerTable.eq(1)));
+            fluid.test.assertTrue(isNextEnabled());
+            fluid.test.assertTrue(isPreviousEnabled());
+            fluid.test.assertTrue(isOnlyCurrent(2));
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Previous (Top)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            var topPreviousParent = pagerLinksTop.parent("[class*='previous']");
+            var topPrevious = topPreviousParent.children();
+            fluid.test.tabTo(topPrevious);
+            fluid.test.typeKeyCode(fluid.test.keys.ENTER);
+        },
+        assertionFunction: function () {
+            fluid.test.assertTrue(isOnlyVisible(pagerTable.eq(0)));
+            fluid.test.assertTrue(isNextEnabled());
+            fluid.test.assertFalse(isPreviousEnabled());
+            fluid.test.assertTrue(isOnlyCurrent(1));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findSelectors();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Next (Bottom)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            var bottomNextParent = pagerLinksBottom.parent("[class*='next']");
+            var bottomNext = bottomNextParent.children();
+            fluid.test.tabTo(bottomNext);
+            fluid.test.typeKeyCode(fluid.test.keys.ENTER);
+        },
+        assertionFunction: function () {
+            fluid.test.assertTrue(isOnlyVisible(pagerTable.eq(1)));
+            fluid.test.assertTrue(isNextEnabled());
+            fluid.test.assertTrue(isPreviousEnabled());
+            fluid.test.assertTrue(isOnlyCurrent(2));
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Previous (Bottom)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            var bottomPreviousParent = pagerLinksBottom.parent("[class*='previous']");
+            var bottomPrevious = bottomPreviousParent.children();
+            fluid.test.tabTo(bottomPrevious);
+            fluid.test.typeKeyCode(fluid.test.keys.ENTER);
+        },
+        assertionFunction: function () {
+            fluid.test.assertTrue(isOnlyVisible(pagerTable.eq(0)));
+            fluid.test.assertTrue(isNextEnabled());
+            fluid.test.assertFalse(isPreviousEnabled());
+            fluid.test.assertTrue(isOnlyCurrent(1));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findSelectors();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Task Oriented Functional Tests>>", 
+        name: "**Click Page (Top)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.mouseClick(pagerLinksTop.eq(4));
+        },
+        assertionFunction: function () {
+            fluid.test.assertTrue(isOnlyVisible(pagerTable.eq(4)));
+            fluid.test.assertTrue(isNextEnabled());
+            fluid.test.assertTrue(isPreviousEnabled());
+            fluid.test.assertTrue(isOnlyCurrent(5));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findSelectors();
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<Task Oriented Functional Tests>>", 
+        name: "**Click Page (Bottom)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.mouseClick(pagerLinksBottom.eq(2));
+        },
+        assertionFunction: function () {
+            fluid.test.assertTrue(isOnlyVisible(pagerTable.eq(2)));
+            fluid.test.assertTrue(isNextEnabled());
+            fluid.test.assertTrue(isPreviousEnabled());
+            fluid.test.assertTrue(isOnlyCurrent(3));
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Click First Page (Top)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.mouseClick(pagerLinksTop.eq(0));
+        },
+        assertionFunction: function () {
+            fluid.test.assertTrue(isOnlyVisible(pagerTable.eq(0)));
+            fluid.test.assertTrue(isNextEnabled());
+            fluid.test.assertFalse(isPreviousEnabled());
+            fluid.test.assertTrue(isOnlyCurrent(1));
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Click Previous while on first page (Top)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            var topPreviousParent = pagerLinksTop.parent("[class*='previous']");
+            var topPrevious = topPreviousParent.children();
+            fluid.test.mouseClick(topPrevious);
+        }, 
+        assertionFunction: function () {
+            fluid.test.assertTrue(isOnlyVisible(pagerTable.eq(0)));
+            fluid.test.assertTrue(isNextEnabled());
+            fluid.test.assertFalse(isPreviousEnabled());
+            fluid.test.assertTrue(isOnlyCurrent(1));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findSelectors();
+        }
+    }); 
+    
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Click Last Page (Top)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            fluid.test.mouseClick(pagerLinksTop.eq(6));
+        },
+        assertionFunction: function () {
+            fluid.test.assertTrue(isOnlyVisible(pagerTable.eq(6)));
+            fluid.test.assertFalse(isNextEnabled());
+            fluid.test.assertTrue(isPreviousEnabled());
+            fluid.test.assertTrue(isOnlyCurrent("7 (last)"));
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Click Next while on last page (Top)**", 
+        timeout: 79000, 
+        actionFunction: function () {
+            var topNextParent = pagerLinksTop.parent("[class*='next']");
+            var topNext = topNextParent.children();
+            fluid.test.mouseClick(topNext);
+        }, 
+        assertionFunction: function () {
+            fluid.test.assertTrue(isOnlyVisible(pagerTable.eq(6)));
+            fluid.test.assertFalse(isNextEnabled());
+            fluid.test.assertTrue(isPreviousEnabled());
+            fluid.test.assertTrue(isOnlyCurrent("7 (last)"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findSelectors();
+        }
+    }); 
+
+    //runs the tests
+    fluid.test.run();
+    
+    //helper functions
+    
+    /**
+     * determines if both of the previous links are enabled
+     * 
+     * @return {boolean} false if either are disabled, and true if they are both enabled
+     */
+    isPreviousEnabled = function () {
+        var prev = pagerLinksBottom.add(pagerLinksTop).parent("[class*='previous']");
+        var enabled = prev.not("[class*='disabled']");
+
+        if (enabled.length === 2) {
+            return true;
+        } else {
+            return false;
+        }
+    };
+    
+    /**
+     * determines if both of the next links are enabled
+     * 
+     * @return {boolean} false if either are disabled, and true if they are both enabled
+     */
+    isNextEnabled = function () {
+        var next = pagerLinksBottom.add(pagerLinksTop).parent("[class*='next']");
+        var enabled = next.not("[class*='disabled']");
+
+        if (enabled.length === 2) {
+            return true;
+        } else {
+            return false;
+        }
+    };
+    
+    /**
+     * deterimes if the passed table is the only one visible
+     * 
+     * @param {Object} table the only table that should be visible
+     * @return {boolean} false if it is hidden or there are other tables that are visible
+     */
+    isOnlyVisible = function (table) {
+        var notHidden = pagerTable.not("[class*='hidden']");
+        var result = false;
+        
+        if (notHidden.length === 1 && notHidden.eq(0)[0] === table[0]) {
+            result = true;
+        }
+        
+        return result;
+    };
+    
+    /**
+     * deterimes if the passed page number is the only one which is marked as current
+     * 
+     * @return {boolean} false if it is hidden or there are other page numbers which are marked as current
+     */
+    isOnlyCurrent = function (pageNumber) {
+        var links = pagerLinksBottom.add(pagerLinksTop);
+        var current = links.parent("[class*='current']");
+        var values  = current.children();
+        var result = false;
+        
+        if (values.length === 2 && values.eq(0).text() == pageNumber && values.eq(1).text() == pageNumber) {
+            result = true;
+        }
+        
+        return result;
+    };
+    
+    /**
+     * Creates the sets of the top page links, bottom page links, and tables
+     * 
+     * This should be called after a reset, to ensure that the sets are current
+     */
+    findSelectors = function () {
+        pagerLinksTop = iframeContents.find(selectorTop);
+        pagerLinksBottom = iframeContents.find(selectorBottom);
+        pagerTable = iframeContents.find(selectorTable);
+    };
+    
+}, {iframe: "#testFrame", adjustmentX: 5, adjustmentY: 5});
+
+
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/sortable-jquery-tabs-automated.js
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/sortable-jquery-tabs-automated.js	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/sortable-jquery-tabs-automated.js	(revision 0)
@@ -0,0 +1,340 @@
+/*global jQuery, $, fluid*/
+fluid.test.runAutomatedTest(function () {   
+ 
+    //Variables which can be used by all tests
+    var iframe = $("#testFrame");
+    var iframeContents = iframe.contents();
+    var selector = "li[id^='tab_']";
+    var tabs = iframeContents.find(selector);
+    var numTabs = tabs.length;
+    var currentPosition;
+    var locations = [];
+    var i;
+    var reset = function () {
+        $(window)[0].frames.testFrame.demo.initJqueryTabs();
+    };
+    
+    //private functions
+    var calculatedPosition;
+    var tabsIndex;
+    var findTabs;
+    
+    //Input values which can be used by all tests
+    
+    //fill array
+    for (i = 0; i < numTabs; i++) {
+        locations[i] = tabs.eq(i).offset(); 
+    }
+    
+    /*
+     * Automated Tests
+     */
+    
+    //State Tests
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Mouse>>", 
+        name: "**Drag and Drop**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = tabsIndex("li[id*='_1']");
+            fluid.test.mouseDragAndDrop({node: locations[1]}, {node: locations[3]});
+        }, 
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedPosition(currentPosition, 2), tabsIndex("li[id*='_1']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findTabs();
+        }
+    }); 
+
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (Right Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = tabsIndex("li[id*='_3']");
+            
+            tabs.eq(3).focus();
+//            fluid.test.shiftTabTo(tabs.eq(3));
+            fluid.test.keyboardMovement({directionKey: fluid.test.keys.RIGHT, distance: 4});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(currentPosition, tabsIndex("li[id*='_3']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findTabs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (Left Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = tabsIndex("li[id*='_3']");
+            
+            tabs.eq(3).focus();
+//            fluid.test.shiftTabTo(tabs.eq(3));
+            fluid.test.keyboardMovement({distance: 4});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(currentPosition, tabsIndex("li[id*='_3']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findTabs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (k)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = tabsIndex("li[id*='_3']");
+            
+            tabs.eq(3).focus();
+//            fluid.test.shiftTabTo(tabs.eq(3));
+            fluid.test.keyboardMovement({directionKey: "k", distance: 4});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(currentPosition, tabsIndex("li[id*='_3']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findTabs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = tabsIndex("li[id*='_3']");
+            
+            tabs.eq(3).focus();
+//            fluid.test.shiftTabTo(tabs.eq(3));
+            fluid.test.keyboardMovement({directionKey: "j", distance: 4});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(currentPosition, tabsIndex("li[id*='_3']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findTabs();
+        }
+    });
+ 
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (Right Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = tabsIndex("li[id*='_2']");
+            
+            tabs.eq(2).focus();
+//            fluid.test.shiftTabTo(tabs.eq(2));
+            fluid.test.keyboardDragAndDrop({directionKey: fluid.test.keys.RIGHT, distance: 3});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedPosition(currentPosition, 3), tabsIndex("li[id*='_2']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findTabs();
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (Left Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = tabsIndex("li[id*='_2']");
+            
+            tabs.eq(2).focus();
+//            fluid.test.shiftTabTo(tabs.eq(2));
+            fluid.test.keyboardDragAndDrop({directionKey: fluid.test.keys.LEFT, distance: 3});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedPosition(currentPosition, -3), tabsIndex("li[id*='_2']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findTabs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (k)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = tabsIndex("li[id*='_2']");
+            
+            tabs.eq(2).focus();
+//            fluid.test.shiftTabTo(tabs.eq(2));
+            fluid.test.keyboardDragAndDrop({directionKey: "k", distance: 3});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedPosition(currentPosition, 3), tabsIndex("li[id*='_2']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findTabs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (j)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = tabsIndex("li[id*='_2']");
+            
+            tabs.eq(2).focus();
+//            fluid.test.shiftTabTo(tabs.eq(3));
+            fluid.test.keyboardDragAndDrop({directionKey: "j", distance: 3});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedPosition(currentPosition, -3), tabsIndex("li[id*='_2']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findTabs();
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Move to first position**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = tabsIndex("li[id*='_3']");
+            fluid.test.mouseDragAndDrop({node: locations[3]}, {node: locations[0]});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedPosition(currentPosition, -3), tabsIndex("li[id*='_3']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findTabs();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Move to last position**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = tabsIndex("li[id*='_2']");
+            fluid.test.mouseDragAndDrop({node: locations[2]}, {node: locations[4]});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedPosition(currentPosition, 2), tabsIndex("li[id*='_2']"));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findTabs();
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Drop on white space**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = tabsIndex("li[id*='_4']");
+            fluid.test.mouseDragAndDrop({node: locations[4]}, {node: {top: 0, left: 0}});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedPosition(currentPosition, -4), tabsIndex("li[id*='_4']")); 
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findTabs();
+        }
+    });
+
+    //runs the tests
+    fluid.test.run();
+    
+    //helper functions
+    
+    /**
+     * Determines the current index of an element
+     * It will take into account the iframe
+     * 
+     * @param {Object} selectorString a jQuery selector to find a single item in the DOM
+     * @return {int} value of its index
+     */
+    tabsIndex = function (selectorString) {
+        var tabSet = iframeContents.find(selector);
+        var index = tabSet.index(iframeContents.find(selectorString));
+        
+        return index;  
+    };
+    
+    /**
+     * Calculates what the new position should be
+     * 
+     * @param {Object} current an integer value of the current position
+     * @param {Object} change an integer value representing the number of positions moved
+     * They represent the current index location and the number of positions moved
+     * Positions moved is passed as a positive integer for moving right and negative for left
+     * 
+     * @return {int} value of the new position
+     */
+    calculatedPosition = function (current, change) {
+        var newPosition;
+        var result;
+        
+        newPosition = current + change;
+        
+        result = newPosition % numTabs;
+        if (result < 0) {
+            result += numTabs;
+        }
+        
+        return result;
+        
+    };
+    
+    /**
+     * Creates the set of tabs
+     * 
+     * This should be called after a reset, to ensure that the set is current
+     */
+    findTabs = function () {
+        tabs = iframeContents.find(selector);
+    };
+    
+}, {iframe: "#testFrame", adjustmentX: 5, adjustmentY: 5});
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/sortable-vertical-list-automated.js
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/sortable-vertical-list-automated.js	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/js/sortable-vertical-list-automated.js	(revision 0)
@@ -0,0 +1,339 @@
+/*global jQuery, $, fluid*/
+fluid.test.runAutomatedTest(function () {   
+ 
+    //Variables which can be used by all tests
+    var iframe = $("#testFrame");
+    var iframeContents = iframe.contents();
+    var selector = "li[id^='myUniquePrefix.']";
+    var listItems = iframeContents.find(selector);
+    var numListItems = listItems.length;
+    var idSelector = [];
+    var currentPosition;
+    var i;
+    var reset = function () {
+        $(window)[0].frames.testFrame.demo.initTodoList();
+    };
+    
+    //private functions
+    var listItemsIndex;
+    var calculatedPosition;
+    var findListItems;
+    
+    //fill array
+    for (i = 0; i < numListItems; i++) {
+        idSelector[i] = "li[id='" + listItems.eq(i).attr("id") + "']";
+    }
+    
+    /*
+     * Automated Tests
+     */
+    
+    //State Tests
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Mouse>>", 
+        name: "**Drag and Drop**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = listItemsIndex(idSelector[1]);
+            fluid.test.mouseDragAndDrop({node: listItems.eq(1)}, {node: listItems.eq(7)});
+        }, 
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedPosition(currentPosition, 6), listItemsIndex(idSelector[1]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findListItems();
+        }
+    }); 
+
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (Up Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = listItemsIndex(idSelector[2]);
+            
+            listItems.eq(2).focus();
+//            fluid.test.shiftTabTo(listItems.eq(2));
+            fluid.test.keyboardMovement({directionKey: fluid.test.keys.UP, distance: 4});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(currentPosition, listItemsIndex(idSelector[2]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findListItems();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (Down Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = listItemsIndex(idSelector[8]);
+            
+            listItems.eq(8).focus();
+//            fluid.test.shiftTabTo(listItems.eq(8));
+            fluid.test.keyboardMovement({directionKey: fluid.test.keys.DOWN, distance: 4});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(currentPosition, listItemsIndex(idSelector[8]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findListItems();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (i)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = listItemsIndex(idSelector[2]);
+            
+            listItems.eq(2).focus();
+//            fluid.test.shiftTabTo(listItems.eq(2));
+            fluid.test.keyboardMovement({directionKey: "i", distance: 4});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(currentPosition, listItemsIndex(idSelector[2]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findListItems();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Selection (m)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = listItemsIndex(idSelector[8]);
+            
+            listItems.eq(8).focus();
+//            fluid.test.shiftTabTo(listItems.eq(8));
+            fluid.test.keyboardMovement({directionKey: "m", distance: 4});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(currentPosition, listItemsIndex(idSelector[8]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findListItems();
+        }
+    });
+ 
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (Up Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = listItemsIndex(idSelector[3]);
+            
+            listItems.eq(3).focus();
+//            fluid.test.shiftTabTo(listItems.eq(3));
+            fluid.test.keyboardDragAndDrop({directionKey: fluid.test.keys.UP, distance: 5});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedPosition(currentPosition, -5), listItemsIndex(idSelector[3]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findListItems();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (Down Arrow)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = listItemsIndex(idSelector[7]);
+            
+            listItems.eq(7).focus();
+//            fluid.test.shiftTabTo(listItems.eq(7));
+            fluid.test.keyboardDragAndDrop({directionKey: fluid.test.keys.DOWN, distance: 5});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedPosition(currentPosition, 5), listItemsIndex(idSelector[7]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findListItems();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (i)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = listItemsIndex(idSelector[3]);
+            
+            listItems.eq(3).focus();
+//            fluid.test.shiftTabTo(listItems.eq(3));
+            fluid.test.keyboardDragAndDrop({directionKey: "i", distance: 5});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedPosition(currentPosition, -5), listItemsIndex(idSelector[3]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findListItems();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<State Tests: Keyboard>>", 
+        name: "**Drag and Drop (m)**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = listItemsIndex(idSelector[7]);
+            
+            listItems.eq(7).focus();
+//            fluid.test.shiftTabTo(listItems.eq(7));
+            fluid.test.keyboardDragAndDrop({directionKey: "m", distance: 5});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedPosition(currentPosition, 5), listItemsIndex(idSelector[7]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findListItems();
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Move to first position**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = listItemsIndex(idSelector[8]);
+            fluid.test.mouseDragAndDrop({node: listItems.eq(8)}, {node: listItems.eq(0)});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedPosition(currentPosition, -8), listItemsIndex(idSelector[8]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findListItems();
+        }
+    });
+    
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Move to last position**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = listItemsIndex(idSelector[2]);
+            fluid.test.mouseDragAndDrop({node: listItems.eq(2)}, {node: listItems.eq(9)});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedPosition(currentPosition, 7), listItemsIndex(idSelector[2]));
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findListItems();
+        }
+    });
+
+    fluid.test.testCase({
+        groupName: "<<Boundary Tests>>", 
+        name: "**Drop on white space**", 
+        timeout: 69000, 
+        actionFunction: function () {
+            currentPosition = listItemsIndex(idSelector[6]);
+            fluid.test.mouseDragAndDrop({node: listItems.eq(6)}, {node: {top: 0, left: 0}});
+        },
+        assertionFunction: function () {
+            fluid.test.assertEqual(calculatedPosition(currentPosition, -6), listItemsIndex(idSelector[6])); 
+        },
+        tearDown: function () {
+            fluid.test.refreshIframe(function () {
+                reset();
+            });
+            findListItems();
+        }
+    });
+    
+
+    //runs the tests
+    fluid.test.run();
+    
+    //helper functions
+    
+    /**
+     * Determines the current index of an element
+     * It will take into account the iframe
+     * 
+     * @param {String} selectorString a jQuery selector to find a single item in the DOM
+     * @return {int} value of its index
+     */
+    listItemsIndex = function (selectorString) {
+        var listItemSet = iframeContents.find(selector);
+        var index = listItemSet.index(iframeContents.find(selectorString));
+        return index;  
+    };
+    
+    /**
+     * Calculates what the new position should be
+     * 
+     * @param {Object} current an integer value of the current position
+     * @param {Object} change an integer value representing the number of positions moved
+     * They represent the current index location and the number of positions moved
+     * Positions moved is passed as a positive integer for moving down and negative for up
+     * 
+     * @return {int} value of the new position
+     */
+    calculatedPosition = function (current, change) {
+        var newPosition;
+        var result;
+        
+        newPosition = current + change;
+        
+        result = newPosition % numListItems;
+        if (result < 0) {
+            result += numListItems;
+        }
+        
+        return result;
+        
+    };
+    
+    /**
+     * Creates the set of list items
+     * 
+     * This should be called after a reset, to ensure that the set is current
+     */
+    findListItems = function () {
+        listItems = iframeContents.find(selector);
+    };
+    
+}, {iframe: "#testFrame", adjustmentX: 2, adjustmentY: 2});
+
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/.DS_Store
===================================================================
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream

Property changes on: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/.DS_Store
___________________________________________________________________
Name: svn:mime-type
   + application/octet-stream

Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/image-reorderer-automated.html
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/image-reorderer-automated.html	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/image-reorderer-automated.html	(revision 0)
@@ -0,0 +1,21 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+	<head>
+		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+        <link href="../css/tests.css" type="text/css" rel="stylesheet" media="all" />
+        
+        <script type="text/javascript" src="../../../../fluid-components/js/jquery/jquery-1.2.6.js"></script>
+        <script type ="text/javascript" src="../doh/runner.js"></script>
+        <script type ="text/javascript" src="../doh/robot.js"></script>
+        <script type="text/javascript" src="../js/AutomatedTestRunner.js"></script>
+        <script type="text/javascript" src="../js/image-reorderer-automated.js"></script>
+        
+		<title>Automated Robot Test</title>
+	</head>
+	<body>
+        <div id="activate">
+            <button id="activateRobot">Activate Robot</button>
+        </div>	    
+        <iframe id="testFrame" name="testFrame" class="width-6-thumbs" src ="../../../../sample-code/reorderer/image-reorderer/image-reorderer.html"></iframe>
+	</body>
+</html>
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/inline-edit-automated.html
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/inline-edit-automated.html	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/inline-edit-automated.html	(revision 0)
@@ -0,0 +1,21 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+	<head>
+		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+        <link href="../css/tests.css" type="text/css" rel="stylesheet" media="all" />
+        
+        <script type="text/javascript" src="../../../../fluid-components/js/jquery/jquery-1.2.6.js"></script>
+        <script type ="text/javascript" src="../doh/runner.js"></script>
+        <script type ="text/javascript" src="../doh/robot.js"></script>
+        <script type="text/javascript" src="../js/AutomatedTestRunner.js"></script>
+        <script type="text/javascript" src="../js/inline-edit-automated.js"></script>
+        
+		<title>Automated Robot Test</title>
+	</head>
+	<body>
+        <div id="activate">
+            <button id="activateRobot">Activate Robot</button>
+        </div>
+	    <iframe id="testFrame" name="testFrame" src ="../../../../sample-code/inline-edit/announcements/announcements.html"></iframe>
+	</body>
+</html>
\ No newline at end of file
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/layout-reorderer-automated.html
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/layout-reorderer-automated.html	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/layout-reorderer-automated.html	(revision 0)
@@ -0,0 +1,21 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+	<head>
+		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+        <link href="../css/tests.css" type="text/css" rel="stylesheet" media="all" />
+        
+        <script type="text/javascript" src="../../../../fluid-components/js/jquery/jquery-1.2.6.js"></script>
+        <script type ="text/javascript" src="../doh/runner.js"></script>
+        <script type ="text/javascript" src="../doh/robot.js"></script>
+        <script type="text/javascript" src="../js/AutomatedTestRunner.js"></script>
+        <script type="text/javascript" src="../js/layout-reorderer-automated.js"></script>
+        
+		<title>Automated Robot Test</title>
+	</head>
+	<body>
+        <div id="activate">
+            <button id="activateRobot">Activate Robot</button>
+        </div>
+	    <iframe id="testFrame" name="testFrame" src ="../../../../sample-code/shared/portal/portal.html"></iframe>
+	</body>
+</html>
\ No newline at end of file
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/pager-automated.html
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/pager-automated.html	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/pager-automated.html	(revision 0)
@@ -0,0 +1,21 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+	<head>
+		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+        <link href="../css/tests.css" type="text/css" rel="stylesheet" media="all" />
+        
+        <script type="text/javascript" src="../../../../fluid-components/js/jquery/jquery-1.2.6.js"></script>
+        <script type ="text/javascript" src="../doh/runner.js"></script>
+        <script type ="text/javascript" src="../doh/robot.js"></script>
+        <script type="text/javascript" src="../js/AutomatedTestRunner.js"></script>
+        <script type="text/javascript" src="../js/pager-automated.js"></script>
+        
+		<title>Automated Robot Test</title>
+	</head>
+	<body>
+        <div id="activate">
+            <button id="activateRobot">Activate Robot</button>
+        </div>	    
+        <iframe id="testFrame" name="testFrame" class="width-6-thumbs" src ="../../../../sample-code/pager/basic/pager.html"></iframe>
+	</body>
+</html>
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/sortable-jquery-tabs-automated.html
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/sortable-jquery-tabs-automated.html	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/sortable-jquery-tabs-automated.html	(revision 0)
@@ -0,0 +1,21 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+	<head>
+		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+        <link href="../css/tests.css" type="text/css" rel="stylesheet" media="all" />
+        
+        <script type="text/javascript" src="../../../../fluid-components/js/jquery/jquery-1.2.6.js"></script>
+        <script type ="text/javascript" src="../doh/runner.js"></script>
+        <script type ="text/javascript" src="../doh/robot.js"></script>
+        <script type="text/javascript" src="../js/AutomatedTestRunner.js"></script>
+        <script type="text/javascript" src="../js/sortable-jquery-tabs-automated.js"></script>
+        
+		<title>Automated Robot Test</title>
+	</head>
+	<body>
+        <div id="activate">
+            <button id="activateRobot">Activate Robot</button>
+        </div>
+	    <iframe id="testFrame" name="testFrame" class="tabs-min-width" src ="../../../../sample-code/reorderer/jquery-tabs/jquery-tabs.html"></iframe>
+	</body>
+</html>
\ No newline at end of file
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/sortable-vertical-list-automated.html
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/sortable-vertical-list-automated.html	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/sortable-vertical-list-automated.html	(revision 0)
@@ -0,0 +1,21 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+	<head>
+		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+        <link href="../css/tests.css" type="text/css" rel="stylesheet" media="all" />
+        
+        <script type="text/javascript" src="../../../../fluid-components/js/jquery/jquery-1.2.6.js"></script>
+        <script type ="text/javascript" src="../doh/runner.js"></script>
+        <script type ="text/javascript" src="../doh/robot.js"></script>
+        <script type="text/javascript" src="../js/AutomatedTestRunner.js"></script>
+        <script type="text/javascript" src="../js/sortable-vertical-list-automated.js"></script>
+        
+		<title>Automated Robot Test</title>
+	</head>
+	<body>
+        <div id="activate">
+            <button id="activateRobot">Activate Robot</button>
+        </div>
+	    <iframe id="testFrame" name="testFrame" src ="../../../../sample-code/reorderer/todo-list/sortable-styled-todo-list.html"></iframe>
+	</body>
+</html>
\ No newline at end of file
Index: /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/uploader-automated.html
===================================================================
--- /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/uploader-automated.html	(revision 0)
+++ /Users/justin/Documents/Aptana Studio/fluid-components/src/webapp/tests/fluid-tests/automated/tests/uploader-automated.html	(revision 0)
@@ -0,0 +1,19 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
+<html>
+	<head>
+		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
+        <link href="../css/tests.css" type="text/css" rel="stylesheet" media="all" />
+        
+        <script type="text/javascript" src="../../../../fluid-components/js/jquery/jquery-1.2.6.js"></script>
+        <script type ="text/javascript" src="../doh/runner.js"></script>
+        <script type ="text/javascript" src="../doh/robot.js"></script>
+        <script type="text/javascript" src="../js/AutomatedTestRunner.js"></script>
+        <script type="text/javascript" src="../js/uploader-automated.js"></script>
+        
+		<title>Automated Robot Test</title>
+	</head>
+	<body>
+        <button id="activateRobot">Activate Robot</button>
+	    <iframe id="testFrame" name="testFrame" src =""></iframe>
+	</body>
+</html>
\ No newline at end of file