RubyGems - javascriptmvc - Versions diffs - 3.0.0.pre15 - Mend

javascriptmvc 3.0.0.pre15

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (550) hide show

data/lib/javascriptmvc/funcunit/envjs ADDED

@@ -0,0 +1,13 @@
+#!/bin/sh
+CP=selenium/selenium-java-client-driver.jar:selenium/js.jar
+ARGS=[
+for arg
+do
+  if [ $arg != $0 ]
+  then
+    ARGS=$ARGS"'$arg'",
+  fi
+done
+ARGS=$ARGS]
+java -Xss1024k -cp $CP org.mozilla.javascript.tools.shell.Main -e _args=$ARGS -opt -1 -e 'load('"'"selenium/run.js"'"')'

data/lib/javascriptmvc/funcunit/envjs.bat ADDED

@@ -0,0 +1,28 @@
+@echo off
+SETLOCAL ENABLEDELAYEDEXPANSION
+set BASE=%0
+set BASE=%BASE:envjs=%
+if not "%BASE%" == "" ( set BASE=%BASE:\=/% )
+:: trim spaces
+for /f "tokens=1*" %%A in ("%BASE%") do SET BASE=%%A
+SET CP=%BASE%java/selenium-java-client-driver.jar;%BASE%../steal/rhino/js.jar
+SET ARGS=[
+for /f "tokens=1,2,3,4,5,6 delims= " %%a in ("%*") do SET ARGS=!ARGS!'%%a','%%b','%%c','%%d','%%e','%%f'
+for %%a in (",''=") do ( call set ARGS=%%ARGS:%%~a%% )
+for /f "tokens=1*" %%A in ("%ARGS%") do SET ARGS=%%A
+SET ARGS=%ARGS%,'%BASE%']
+set ARGS=%ARGS:\=/%
+java -Xss1024k -cp %CP% org.mozilla.javascript.tools.shell.Main -opt -1 -e _args=%ARGS% -e load('%BASE%scripts/run.js')

data/lib/javascriptmvc/funcunit/funcunit.html ADDED

@@ -0,0 +1,20 @@
+<html>
+    <head>
+        <link rel="stylesheet" type="text/css" href="../funcunit/qunit/qunit.css" />
+        <title>FuncUnit Test</title>
+        <style>
+            body  {
+                margin: 0px; padding: 0px;
+            }
+        </style>
+</head>
+    <body>
+        <h1 id="qunit-header">funcunit Test Suite</h1>
+    	<h2 id="qunit-banner"></h2>
+    	<div id="qunit-testrunner-toolbar"></div>
+    	<h2 id="qunit-userAgent"></h2>
+        <ol id="qunit-tests"></ol>
+		<script type='text/javascript' src='../steal/steal.js?steal[app]=funcunit/test/funcunit'></script>
+    </body>
+</html>

data/lib/javascriptmvc/funcunit/funcunit.js ADDED

@@ -0,0 +1,1509 @@
+//what we need from javascriptmvc or other places
+steal.plugins('funcunit/qunit',
+	'funcunit/qunit/rhino')
+	.then('resources/jquery','resources/json')
+	.plugins('funcunit/synthetic')
+//Now describe FuncUnit
+.then(function(){
+//this gets the global object, even in rhino
+var window = (function(){return this }).call(null),
+//if there is an old FuncUnit, use that for settings
+	oldFunc = window.FuncUnit;
+/**
+ * @constructor FuncUnit
+ * @tag core
+ * @test test.html
+ * @download http://github.com/downloads/jupiterjs/funcunit/funcunit-beta-4.zip
+ * FuncUnit provides powerful functional testing as an add on to [http://docs.jquery.com/QUnit QUnit].
+ * The same tests can be run
+ * in the browser, or with Selenium.  It also lets you automate basic
+ * QUnit tests in [http://www.envjs.com/ EnvJS] (a command line browser).
+ *
+ * <h2>Example:</h2>
+ * The following tests that an AutoSuggest returns 5 results.
+ * <a href='funcunit/autosuggest/funcunit.html'>See it in action!</a> (Make sure
+ * you turn off your popup blocker!).
+@codestart
+module("autosuggest",{
+  setup: function() {
+    S.open('autosuggest.html')
+  }
+});
+test("JavaScript results",function(){
+  S('input').click().type("JavaScript")
+  // wait until we have some results
+  S('.autocomplete_item').visible(function(){
+    equal( S('.autocomplete_item').size(), 5, "there are 5 results")
+  })
+});
+@codeend
+ *
+ * <h2>Basic Setup</h2>
+ * <h3>Setup with JavaScriptMVC</h3>
+ * If you're setting up FuncUnit with JavaScriptMVC,
+ * use [steal.static.plugins] to get the funcunit plugin.  If you used
+ * JavaScriptMVC's generators, it will setup a testing skeleton for you.
+ * <h3>Setup with Stand-alone funcunit.js</h3>
+ * Lets say you want to test <code>pages/mypage.html</code> and
+ * you've installed funcunit in test/funcunit.</br>
+ * Steps:
+ * <ol>
+ *  <li>Create a HTML file (pages/mypage_test.html) that loads
+ *  <code><b>qunit.css</b></code>, <code><b>funcunit.js</b></code>,
+ *  and <code><b>mypage_test.js</b></code>.  We'll create mypage_test.js in step #2.
+@codestart html
+&lt;html>
+  &lt;head>
+    &lt;link   href='../funcunit/<b>qunit.css</b>'
+            type='text/css'
+            rel='stylesheet' />
+    &lt;script src='../funcunit/<b>funcunit.js</b>'
+            type='text/javascript' ></script>
+    &lt;script src='<b>mypage_test.js</b>'
+            type='text/javascript'></script>
+    &lt;title>MyPage Test Suite&lt;/title>
+  &lt;/head>
+  &lt;body>
+    &lt;h1 id="qunit-header">MyPage Test Suite&lt;/h1>
+    &lt;h2 id="qunit-banner">&lt;/h2>
+    &lt;div id="qunit-testrunner-toolbar">&lt;/div>
+    &lt;h2 id="qunit-userAgent">&lt;/h2>
+    &lt;ol id="qunit-tests">&lt;/ol>
+  &lt;/body>
+&lt;/html>
+@codeend
+ * </li>
+ * 	<li>Create a JS file (<code>pages/mypage_test.js</code>) for your tests.  The skeleton should like:
+@codestart
+module("APPNAME", {
+  setup: function() {
+    // opens the page you want to test
+    $.open("myPage.html");
+  }
+})
+test("page has content", function(){
+  ok( S("body *").size(), "There be elements in that there body")
+})
+@codeend
+ *  </li>
+ *  <li>Open your html page (<code>mytest.html</code>) in a browser.  Did it pass?
+ *  If not check the paths.
+ *  <div class='whisper'>P.S. Your page and test files don't have to be in the same folder; however,
+ *  on the filesystem, Firefox and Chrome don't let you access parent folders.  We wanted the
+ *  demo to work without having to host these files.
+ *  </div>
+ *
+ *  </li>
+ *  <li>Now run your test in Selenium.  In windows:
+@codestart text
+> envjs ../../pages/mypage_test.html
+@codeend
+In Linux / Mac:
+@codestart text
+> ./envjs ../../pages/mypage_test.html
+@codeend
+<div class='whisper'>This will run mytest.html on the filesystem.  To run it served, just
+pass in the url of your test page: <pre>envjs http://localhost/pages/mypage_test.html</pre>.
+</div>
+</li>
+ * </ol>
+ * <h2>Writing Tests</h2>
+ * <p>Writing tests is super easy and follows this pattern:</p>
+<ol>
+  <li>Open a page with [FuncUnit.static.open S.open].
+@codestart
+S.open("//myapp/myapp.html")
+@codeend
+  </li>
+  <li>Do some things
+@codestart
+//click something
+S('#myButton').click()
+//type something
+S('#myInput').type("hello")
+@codeend
+  </li>
+  <li>Wait for the page to change:
+@codestart
+//Wait until it is visible
+S('#myMenu').visible()
+//wait until something exists
+S('#myArea').exists()
+//waits a second
+S.wait(1000);
+@codeend
+  </li>
+  <li>Check your page in a callback:
+@codestart
+S('#myMenu').visible(function(){
+  //check that offset is right
+  equals(S('#myMenu').offset().left,
+         500,
+         "menu is in the right spot");
+})
+@codeend
+  </li>
+</ol>
+<h2>Actions, Waits, and Getters</h2>
+<p>FuncUnit supports three types of commands: asynchronous actions and waits,
+and synchronous getters.</p>
+<p><b>Actions</b> are used to simulate user behavior such as clicking, typing, moving the mouse.</p>
+<p><b>Waits</b> are used to pause the test script until a condition has been met.</p>
+<p><b>Getters</b> are used to get information about elements in the page</p>
+<p>Typically, a test looks like a series of action and wait commands followed by qUnit test of
+the result of a getter command.  Getter commands are almost always in a action or wait callback.</p>
+<h3>Actions</h3>
+Actions simulate user behavior.  FuncUnit provides the following actions:
+<ul>
+	<li><code>[FuncUnit.static.open open]</code> - Opens a page.</li>
+	<li><code>[FuncUnit.prototype.click click]</code> - clicks an element (mousedown, mouseup, click).</li>
+	<li><code>[FuncUnit.prototype.dblclick dblclick]</code> - two clicks followed by a dblclick.</li>
+	<li><code>[FuncUnit.prototype.rightClick rightClick]</code> - a right mousedown, mouseup, and contextmenu.</li>
+	<li><code>[FuncUnit.prototype.type type]</code> - Types characters into an element.</li>
+	<li><code>[FuncUnit.prototype.move move]</code> - mousemove, mouseover, and mouseouts from one element to another.</li>
+	<li><code>[FuncUnit.prototype.drag drag]</code> - a drag motion from one element to another.</li>
+	<li><code>[FuncUnit.prototype.scroll scroll]</code> - scrolls an element.</li>
+</ul>
+<p>Actions run asynchronously, meaning they do not complete all their events immediately.
+However, each action is queued so that you can write actions (and waits) linearly.</p>
+<p>The following might simulate typing and resizing a "resizable" textarea plugin:</p>
+@codestart
+S.open('resizableTextarea.html');
+S('textarea').click().type("Hello World");
+S('.resizer').drag("+20 +20");
+@codeend
+<h3>Getters</h3>
+Getters are used to test the conditions of the page.  Most getter commands correspond to a jQuery
+method of the same name.  The following getters are provided:
+<table style='font-family: monospace'>
+<tr>
+	<th colspan='2'>Dimensions</th> <th>Attributes</th> <th>Position</th> <th>Selector</th> <th>Style</th>
+</tr>
+<tr>
+	<td>[FuncUnit.prototype.width width]</td>
+	<td>[FuncUnit.prototype.height height]</td>
+	<td>[FuncUnit.prototype.attr attr]</td>
+	<td>[FuncUnit.prototype.position position]</td>
+	<td>[FuncUnit.prototype.size size]</td>
+	<td>[FuncUnit.prototype.css css]</td>
+</tr>
+<tr>
+	<td>[FuncUnit.prototype.innerWidth innerWidth]</td>
+	<td>[FuncUnit.prototype.innerHeight innerHeight]</td>
+	<td>[FuncUnit.prototype.hasClass hasClass]</td>
+	<td>[FuncUnit.prototype.offset offset]</td>
+	<td>[FuncUnit.prototype.exists exists]</td>
+	<td>[FuncUnit.prototype.visible visible]</td>
+</tr>
+<tr>
+	<td>[FuncUnit.prototype.outerWidth outerWidth]</td>
+	<td>[FuncUnit.prototype.outerHeight outerHeight]</td>
+	<td>[FuncUnit.prototype.val val]</td>
+	<td>[FuncUnit.prototype.scrollLeft scrollLeft]</td>
+	<td>[FuncUnit.prototype.missing missing]</td>
+	<td>[FuncUnit.prototype.invisible invisible]</td>
+</tr>
+<tr>
+	<td colspan='2'></td>
+	<td>[FuncUnit.prototype.text text]</td>
+	<td>[FuncUnit.prototype.scrollTop scrollTop]</td>
+</tr>
+<tr>
+	<td colspan='2'></td>
+	<td>[FuncUnit.prototype.html html]</td>
+</tr>
+</table>
+<p>
+As getters return synchronously, it's important that they happen after the action or wait command completes.
+This is why getters are typically found in an action or wait command's callback:
+</p>
+The following checks that the textarea is 20 pixels taller after the drag.
+@codestart
+    //save textarea reference
+var txtarea = S('textarea'),
+    // save references to width and height
+    startingWidth = txtarea.width(),
+    startingHeight = txtarea.height();
+S.open('resizableTextarea.html');
+S('textarea').click().type("Hello World");
+S('.resizer').drag("+20 +20", function(){
+  equals(txtarea.width(),
+         startingWidth,
+         "width stays the same");
+  equals(txtarea.height(),
+         startingHeight+20,
+         "height got bigger");
+});
+@codeend
+<h3>Waits</h3>
+<p>Waits are used to wait for a specific condition to be met before continuing to the next wait or
+action command.  Every getter commands can become a wait command when given a check value or function.
+For
+example, the following waits until the width of an element is 200 pixels and tests its offset.
+</p>
+@codestart
+var sm = S("#sliderMenu");
+sm.width( 200, function(){
+  var offset = sm.offset();
+  equals( offset.left, 200)
+  equals( offset.top, 200)
+})
+@codeend
+<p>You can also provide a test function that when true, continues to the next action or wait command.
+The following is equivalent to the previous example:
+</p>
+@codestart
+var sm = S("#sliderMenu");
+sm.width(
+  function( width ) {
+    return width == 200;
+  },
+  function(){
+    var offset = sm.offset();
+    equals( offset.left, 200)
+    equals( offset.top, 200)
+  }
+)
+@codeend
+<div class='whisper'>Notice that the test function is provided the width of the element to use to check.</div>
+<p>In addition to all the getter functions, FuncUnit provides:
+</p>
+<ul>
+  <li>[FuncUnit.static.wait S.wait] - waits a timeout before continuing.</li>
+  <li>[FuncUnit.prototype.wait S().wait] - waits a timeout before continuing.</li>
+  <li>[FuncUnit S(function(){})] - code runs between actions (like a wait with timeout = 0).</li>
+</ul>
+<h2>Automated Testing with Selenium</h2>
+<p>FuncUnit has a command line mode, which allows you to run your tests as part of a checkin script or nightly build.
+The Selenium server is used to automate opening browsers, and FuncUnit commands are sent to the test window via Selenium RC.</p>
+<p>The envjs script (written for both Windows and OS X/Linux), is used to load your test page (the
+same one that runs tests in the browser) in Env.js, a simulated browser running on Rhino.  The
+test page recognizes its running in the Rhino context and issues commands to Selenium accordingly.</p>
+<p>Running these command line tests is simple:</p>
+@codestart
+my\path\to\envjs my\path\to\funcunit.html
+@codeend
+<p>Configuring settings for the command line mode will be covered next.</p>
+<h3>Configuration</h3>
+<p>FuncUnit loads a settings.js file every time it is runs in Selenium mode.  This file defines
+configuration that tells Selenium how to run.  You can change which browsers run, their location,
+the domain to serve from, and the speed of test execution.</p>
+<p>FuncUnit looks first in the same directory as the funcunit page you're running tests from for
+settings.js.  For example if you're running FuncUnit like this:</p>
+@codestart
+funcunit\envjs phui\combobox\funcunit.html
+@codeend
+<p>It will look first for phui/combobox/settings.js.</p>
+<p>Then it looks in its own root directory, where a default settings.js exists.
+This is to allow you to create different settings for different projects.</p>
+<h3>Setting Browsers</h3>
+<p>FuncUnit.browsers is an array that defines which browsers Selenium opens and runs your tests in.
+This is defined in settings.js.  If this null it will default to a standard set of browsers for your OS
+(FF and IE on Windows, FF on everything else).  You populate it with strings like the following:</p>
+@codestart
+browsers: ["*firefox", "*iexplore", "*safari", "*googlechrome"]
+@codeend
+<p>To define a custom path to a browser, put this in the string following the browser name like this:</p>
+@codestart
+browsers: ["*custom /path/to/my/browser"]
+@codeend
+<p>See the
+[http://release.seleniumhq.org/selenium-remote-control/0.9.0/doc/java/com/thoughtworks/selenium/DefaultSelenium.html#DefaultSelenium Selenium docs]
+for more information on customizing browsers and other settings.</p>
+<h3>Filesystem for Faster Tests</h3>
+<p>You might want to use envjs to open local funcunit pages, but test pages on your server.  This is possible, you
+just have to change FuncUnit.href or FuncUnit.jmvcRoot.  This file can load locally while everything else is
+using a server because it is a static file and loads static script files.</p>
+<p>Set jmvcRoot to point to the location you want your pages to load from, like this:</p>
+@codestart
+jmvcRoot: "localhost:8000"
+@codeend
+<p>Then make sure your test paths contain // in them to signify something relative to the jmvcRoot.
+For example, S.open("//funcunit/test/myapp.html") would open a page at
+http://localhost:8000/funcunit/test/myapp.html.</p>
+<p>To load the command page from filesystem, start your test like you normally do:</p>
+@codestart
+funcunit\envjs path\to\funcunit.html
+@codeend
+<h3>Running Served Pages</h3>
+<p>Certain browsers, like Safari and Chrome, don't run Selenium tests from filesystem because
+of security resrictions.  To get around this you have to run pages served from a server.  The
+downside of this is the test takes longer to start up, compared to loading from filesystem.</p>
+<p>To do this, provide an absolute path in your envjs path, like this:</p>
+@codestart
+funcunit\envjs http://localhost:8000/path/to/funcunit.html
+@codeend
+<p>and set jmvcRoot and your paths as directed in the previous section.  This will cause the command page
+and the test pages to load from your server.</p>
+<h3>Slow Mode</h3>
+<p>You can slow down the amount of time between tests by setting FuncUnit.speed.  By default, FuncUnit commands
+in Selenium will run as soon as the previous command is complete.  If you set FuncUnit.speed to "slow" this
+becomes 500ms between commands.  You may also provide a number of milliseconds.
+Slow mode is useful while debugging.</p>
+<h2>Limitations</h2>
+<ul>
+	<li>Selenium doesn't run Chrome/Opera/Safari on the filesystem.</li>
+</ul>
+ *
+ * @init
+ * selects something in the other page
+ * @param {String|Function|Object} selector FuncUnit behaves differently depending if
+ * the selector is a string, a function, or an object.
+ * <h5>String</h5>
+ * The selector is treated as a css selector.
+ * jQuery/Sizzle is used as the selector so any selector it understands
+ * will work with funcUnit.  FuncUnit does not perform the selection until a
+ * command is called upon this selector.  This makes aliasing the selectors to
+ * JavaScript variables a great technique.
+ * <h5>Function</h5>
+ * If a function is provided, it will add that function to the action queue to be run
+ * after previous actions and waits.
+ * <h5>Object</h5>
+ * If you want to reference the window or document, pass <code>S.window</code>
+ * or <code>S.window.document</code> to the selector.
+ *
+ * @param {Number} [context] If provided, the context is the frame number in the
+ * document.frames array to use as the context of the selector.
+ */
+FuncUnit = function(selector, context){
+	if(typeof selector == "function"){
+		return FuncUnit.wait(0, selector)
+	}
+	return new FuncUnit.init(selector, context)
+}
+/**
+ * @Static
+ */
+window.jQuery.extend(FuncUnit,oldFunc)
+window.jQuery.extend(FuncUnit,{
+	//move jquery and clear it out
+	jquery : jQuery.noConflict(true),
+/**
+ * @attribute href
+ * The location of the page running the tests on the server and where relative paths passed in to [FuncUnit.static.open] will be
+ * referenced from.
+ * <p>This is typically where the test page runs on the server.  It can be set before calls to [FuncUnit.static.open]:</p>
+@codestart
+test("opening something", function(){
+  S.href = "http://localhost/tests/mytest.html"
+  S.open("../myapp")
+  ...
+})
+@codeend
+ */
+// href comes from settings
+/**
+ * @attribute jmvcRoot
+ * jmvcRoot should be set to url of JMVC's root folder.
+ * <p>This is used to calculate JMVC style paths (paths that begin with  //).
+ * This is the prefered method of referencing pages if
+ * you want to test on the filesystem and test on the server.</p>
+ * <p>This is usually set in the global config file in <code>funcunit/settings.js</code> like:</p>
+@codestart
+FuncUnit = {jmvcRoot: "http://localhost/script/" }
+@codeend
+ */
+// jmvcRoot comes from settings
+/**
+ * Opens a page.  It will error if the page can't be opened before timeout.
+ * <h3>Example</h3>
+@codestart
+//a full url
+S.open("http://localhost/app/app.html")
+//from jmvc root (FuncUnit.jmvcRoot must be set)
+S.open("//app/app.html")
+@codeend
+ * <h3>Paths in Selenium</h3>
+ * Selenium runs the testing page from the filesystem and by default will look for pages on the filesystem unless provided a full
+ * url or information that can translate a partial path into a full url. FuncUnit uses [FuncUnit.static.jmvcRoot]
+ * and [FuncUnit.static.href] to
+ * translate partial paths.
+<table>
+  <tr>
+  	<th>path</th>
+  	<th>jmvcRoot</th>
+  	<th>href</th>
+  	<th>resulting url</th>
+  </tr>
+  <tr>
+    <td>//myapp/mypage.html</td>
+    <td>null</td>
+    <td>null</td>
+    <td>file:///C:/development/cookbook/public/myapp/mypage.html</td>
+  </tr>
+  <tr>
+    <td>//myapp/mypage.html</td>
+    <td>http://localhost/</td>
+    <td></td>
+    <td>http://localhost/myapp/mypage.html</td>
+  </tr>
+  <tr>
+    <td>http://foo.com</td>
+    <td></td>
+    <td></td>
+    <td>http://foo.com</td>
+  </tr>
+  <tr>
+  	<td>../mypage.html</td>
+    <td></td>
+    <td>http://localhost/myapp/funcunit.html</td>
+    <td>http://localhost/mypage.html</td>
+  </tr>
+</table>
+ *
+ * @param {String} path a full or partial url to open.  If a partial is given,
+ * @param {Function} callback
+ * @param {Number} timeout
+ */
+open: function( path, callback, timeout ) {
+	var fullPath = FuncUnit.getAbsolutePath(path),
+	temp;
+	if(typeof callback != 'function'){
+		timeout = callback;
+		callback = undefined;
+	}
+	FuncUnit.add(function(success, error){ //function that actually does stuff, if this doesn't call success by timeout, error will be called, or can call error itself
+		steal.dev.log("Opening "+path)
+		FuncUnit._open(fullPath, error);
+		FuncUnit._onload(function(){
+			FuncUnit._opened();
+			success()
+		}, error);
+	}, callback, "Page " + path + " not loaded in time!", timeout || 30000);
+},
+/**
+ * @hide
+ * Gets a path, will use steal if present
+ * @param {String} path
+ */
+getAbsolutePath: function( path ) {
+	if(typeof(steal) == "undefined"){
+		return path;
+	}
+	var fullPath,
+		root = FuncUnit.jmvcRoot || steal.root.path;
+	if (/^\/\//.test(path)) {
+		fullPath = new steal.File(path.substr(2)).joinFrom(root);
+	}
+	else {
+		fullPath = path;
+	}
+	if(/^http/.test(path))
+		fullPath = path;
+	return fullPath;
+},
+/**
+ * @attribute browsers
+ * Used to configure the browsers selenium uses to run FuncUnit tests.
+ * If you need to learn how to configure selenium, and we haven't filled in this page,
+ * post a note on the forum and we will fill this out right away.
+ */
+// for feature detection
+support : {},
+/**
+ * @attribute window
+ * Use this to refer to the window of the application page.  You can also
+ * reference window.document.
+ * @codestart
+ * S(S.window).innerWidth(function(w){
+ *   ok(w > 1000, "window is more than 1000 px wide")
+ * })
+ * @codeend
+ */
+window : {
+	document: {}
+},
+_opened: function() {}
+});
+(function(){
+	//the queue of commands waiting to be run
+	var queue = [],
+		//are we in a callback function (something we pass to a FuncUnit plugin)
+		incallback = false,
+		//where we should add things in a callback
+		currentPosition = 0;
+	FuncUnit.
+	/**
+	 * @hide
+	 * Adds a function to be called in the queue.
+	 * @param {Function} f The function to be called.  It will be provided a success and error function.
+	 * @param {Function} callback a callback to be called after the function is done
+	 * @param {Object} error an error statement if the command fails
+	 * @param {Object} timeout the length of time until success should be called.
+	 */
+	add = function(f, callback, error, timeout, stopper){
+		//if we are in a callback, add to the current position
+		if (incallback) {
+			queue.splice(currentPosition,0,{
+				method: f,
+				callback: callback,
+				error: error,
+				timeout: timeout,
+				stop : stopper
+			})
+			currentPosition++;
+		}
+		else {
+			//add to the end
+			queue.push({
+				method: f,
+				callback: callback,
+				error: error,
+				timeout: timeout
+			});
+		}
+		//if our queue has just started, stop qunit
+		//call done to call the next command
+        if (queue.length == 1 && ! incallback) {
+			stop();
+            setTimeout(FuncUnit._done, 13)
+        }
+	}
+	//this is called after every command
+	// it gets the next function from the queue
+	FuncUnit._done = function(){
+		var next,
+			timer,
+			speed = 0;
+		if(FuncUnit.speed == "slow"){
+			speed = 500;
+		}
+		else if (FuncUnit.speed){
+			speed = FuncUnit.speed;
+		}
+		if (queue.length > 0) {
+			next = queue.shift();
+			currentPosition = 0;
+			// set a timer that will error
+			//call next method
+			setTimeout(function(){
+				timer = setTimeout(function(){
+						next.stop && next.stop();
+						ok(false, next.error);
+						FuncUnit._done();
+					},
+					(next.timeout || 10000) + speed)
+				next.method(	//success
+					function(){
+						//make sure we don't create an error
+						clearTimeout(timer);
+						//mark in callback so the next set of add get added to the front
+						incallback = true;
+						if (next.callback)
+							next.callback.apply(null, arguments);
+						incallback = false;
+						FuncUnit._done();
+					}, //error
+					function(message){
+						clearTimeout(timer);
+						ok(false, message);
+						FuncUnit._done();
+					})
+			}, speed);
+		}
+		else {
+			start();
+		}
+	}
+	FuncUnit.
+	/**
+	 * Waits a timeout before running the next command.  Wait is an action and gets
+	 * added to the queue.
+	 * @codestart
+	 * S.wait(100, function(){
+	 *   equals( S('#foo').innerWidth(), 100, "innerWidth is 100");
+	 * })
+	 * @codeend
+	 * @param {Number} [time] The timeout in milliseconds.  Defaults to 5000.
+	 * @param {Function} [callback] A callback that will run
+	 * 		after the wait has completed,
+	 * 		but before any more queued actions.
+	 */
+	wait = function(time, callback){
+		if(typeof time == 'function'){
+			callback = time;
+			time = undefined;
+		}
+		time = time != null ? time : 5000
+		FuncUnit.add(function(success, error){
+			steal.dev.log("Waiting "+time)
+			setTimeout(success, time)
+		}, callback, "Couldn't wait!", time + 1000);
+		return this;
+	}
+	/**
+	 * @hide
+	 * @function repeat
+	 * Takes a function that will be called over and over until it is successful.
+	 */
+	FuncUnit.repeat = function(checker, callback, error, timeout){
+		var interval,
+			stopped = false	,
+			stop = function(){
+				clearTimeout(interval)
+				stopped = true;
+			};
+		FuncUnit.add(function(success, error){
+			interval = setTimeout(function(){
+				var result = null;
+				try {
+					result = checker()
+				}
+				catch (e) {
+					//should we throw this too error?
+				}
+				if (result) {
+					success();
+				}else if(!stopped){
+					interval = setTimeout(arguments.callee, 10)
+				}
+			}, 10);
+		}, callback, error, timeout, stop)
+	}
+	FuncUnit.makeArray = function(arr){
+		var narr = [];
+		for (var i = 0; i < arr.length; i++) {
+			narr[i] = arr[i]
+		}
+		return narr;
+	}
+	FuncUnit.
+	/**
+	 * @hide
+	 * Converts a string into a Native JS type.
+	 * @param {Object} str
+	 */
+	convert = function(str){
+		//if it is an object and not null, eval it
+		if (str !== null && typeof str == "object") {
+			return object;
+		}
+		str = String(str);
+		switch (str) {
+			case "false":
+				return false;
+			case "null":
+				return null;
+			case "true":
+				return true;
+			case "undefined":
+				return undefined;
+			default:
+				if (/^\d+\.\d+$/.test(str) || /^\d+$/.test(str)) {
+					return 1 * str;
+				}
+				return str;
+		}
+	}
+})();
+/**
+ * @prototype
+ */
+FuncUnit.init = function(s, c){
+	this.selector = s;
+	this.context = c == null ? FuncUnit.window.document : c;
+}
+FuncUnit.init.prototype = {
+	/**
+	 * Types text into an element.  This makes use of [Syn.prototype.type] and works in
+	 * a very similar way.
+	 * <h3>Quick Examples</h3>
+	 * @codestart
+	 * //types hello world
+	 * S('#bar').type('hello world')
+	 *
+	 * //submits a form by typing \r
+	 * S("input[name=age]").type("27\r")
+	 *
+	 * //types FuncUnit, then deletes the Unit
+	 * S('#foo').type("FuncUnit\b\b\b\b")
+	 *
+	 * //types JavaScriptMVC, then removes the MVC
+	 * S('#zar').type("JavaScriptMVC[left][left][left]"+
+	 *                      "[delete][delete][delete]")
+	 *
+	 * //types JavaScriptMVC, then selects the MVC and
+	 * //deletes it
+	 * S('#zar').type("JavaScriptMVC[shift]"+
+	 *                "[left][left][left]"+
+	 *                "[shift-up][delete]")
+	 * @codeend
+	 * <h2>Characters</h2>
+	 * You can type the characters found in [Syn.static.keycodes].
+	 *
+	 * @param {String} text the text you want to type
+	 * @param {Function} [callback] a callback that is run after typing, but before the next action.
+	 * @return {FuncUnit} returns the funcUnit for chaining.
+	 */
+	type: function( text, callback ) {
+		var selector = this.selector,
+			context = this.context;
+		FuncUnit.add(function(success, error){
+			steal.dev.log("Typing "+text+" on "+selector)
+			FuncUnit.$(selector, context, "triggerSyn", "_type", text, success)
+		}, callback, "Could not type " + text + " into " + this.selector);
+		return this;
+	},
+	/**
+	 * Waits until an element exists before running the next action.
+	 * @codestart
+	 * //waits until #foo exists before clicking it.
+	 * S("#foo").exists().click()
+	 * @codeend
+	 * @param {Function} [callback] a callback that is run after the selector exists, but before the next action.
+	 * @return {FuncUnit} returns the funcUnit for chaining.
+	 */
+	exists: function( callback ) {
+		if(true){
+			return this.size(function(size){
+				return size > 0;
+			}, callback)
+		}
+		return this.size() == 0;
+	},
+	/**
+	 * Waits until no elements are matched by the selector.  Missing is equivalent to calling
+	 * <code>.size(0, callback);</code>
+	 * @codestart
+	 * //waits until #foo leaves before continuing to the next action.
+	 * S("#foo").missing()
+	 * @codeend
+	 * @param {Function} [callback] a callback that is run after the selector exists, but before the next action
+	 * @return {FuncUnit} returns the funcUnit for chaining.
+	 */
+	missing: function( callback ) {
+		return this.size(0, callback)
+	},
+	/**
+	 * Waits until the funcUnit selector is visible.
+	 * @codestart
+	 * //waits until #foo is visible.
+	 * S("#foo").visible()
+	 * @codeend
+	 * @param {Function} [callback] a callback that runs after the funcUnit is visible, but before the next action.
+	 * @return [funcUnit] returns the funcUnit for chaining.
+	 */
+	visible: function( callback ) {
+		var self = this,
+			sel = this.selector,
+			ret;
+		this.selector += ":visible"
+		if(true){
+			return this.size(function(size){
+				return size > 0;
+			}, function(){
+				self.selector = sel;
+				callback && callback();
+			})
+		}else{
+			ret = this.size() > 0;
+			this.selector = sel;
+			return ret;
+		}
+	},
+	/**
+	 * Waits until the selector is invisible.
+	 * @codestart
+	 * //waits until #foo is invisible.
+	 * S("#foo").invisible()
+	 * @codeend
+	 * @param {Function} [callback] a callback that runs after the selector is invisible, but before the next action.
+	 * @return [funcUnit] returns the funcUnit selector for chaining.
+	 */
+	invisible: function( callback ) {
+		var self = this,
+			sel = this.selector,
+			ret;
+		if(true){
+			this.selector += ":visible"
+			return this.size(0, function(){
+				self.selector = sel;
+				callback && callback();
+			})
+		}else{
+			ret = this.size() == 0;
+			this.selector = sel;
+			return ret;
+		}
+	},
+	/**
+	 * Drags an element into another element or coordinates.
+	 * This takes the same paramameters as [Syn.prototype.move move].
+	 * @param {String|Object} options A selector or coordinates describing the motion of the drag.
+	 * <h5>Options as a Selector</h5>
+	 * Passing a string selector to drag the mouse.  The drag runs to the center of the element
+	 * matched by the selector.  The following drags from the center of #foo to the center of #bar.
+	 * @codestart
+	 * S('#foo').drag('#bar')
+	 * @codeend
+	 * <h5>Options as Coordinates</h5>
+	 * You can pass in coordinates as clientX and clientY:
+	 * @codestart
+	 * S('#foo').drag('100x200')
+	 * @codeend
+	 * Or as pageX and pageY
+	 * @codestart
+	 * S('#foo').drag('100X200')
+	 * @codeend
+	 * Or relative to the start position
+	 * S('#foo').drag('+10 +20')
+	 * <h5>Options as an Object</h5>
+	 * You can configure the duration, start, and end point of a drag by passing in a json object.
+	 * @codestart
+	 * //drags from 0x0 to 100x100 in 2 seconds
+	 * S('#foo').drag({
+	 *   from: "0x0",
+	 *   to: "100x100",
+	 *   duration: 2000
+	 * })
+	 * @codeend
+	 * @param {Function} [callback] a callback that runs after the drag, but before the next action.
+	 * @return {funcUnit} returns the funcunit selector for chaining.
+	 */
+	drag: function( options, callback ) {
+		if(typeof options == 'string'){
+			options = {to: options}
+		}
+		options.from = this.selector;
+		var selector = this.selector,
+			context = this.context;
+		FuncUnit.add(function(success, error){
+			steal.dev.log("dragging "+selector)
+			FuncUnit.$(selector, context, "triggerSyn", "_drag", options, success)
+		}, callback, "Could not drag " + this.selector)
+		return this;
+	},
+		/**
+	 * Moves an element into another element or coordinates.  This will trigger mouseover
+	 * mouseouts accordingly.
+	 * This takes the same paramameters as [Syn.prototype.move move].
+	 * @param {String|Object} options A selector or coordinates describing the motion of the move.
+	 * <h5>Options as a Selector</h5>
+	 * Passing a string selector to move the mouse.  The move runs to the center of the element
+	 * matched by the selector.  The following moves from the center of #foo to the center of #bar.
+	 * @codestart
+	 * S('#foo').move('#bar')
+	 * @codeend
+	 * <h5>Options as Coordinates</h5>
+	 * You can pass in coordinates as clientX and clientY:
+	 * @codestart
+	 * S('#foo').move('100x200')
+	 * @codeend
+	 * Or as pageX and pageY
+	 * @codestart
+	 * S('#foo').move('100X200')
+	 * @codeend
+	 * Or relative to the start position
+	 * S('#foo').move('+10 +20')
+	 * <h5>Options as an Object</h5>
+	 * You can configure the duration, start, and end point of a move by passing in a json object.
+	 * @codestart
+	 * //drags from 0x0 to 100x100 in 2 seconds
+	 * S('#foo').move({
+	 *   from: "0x0",
+	 *   to: "100x100",
+	 *   duration: 2000
+	 * })
+	 * @codeend
+	 * @param {Function} [callback] a callback that runs after the drag, but before the next action.
+	 * @return {funcUnit} returns the funcunit selector for chaining.
+	 */
+	move: function( options, callback ) {
+		if(typeof options == 'string'){
+			options = {to: options}
+		}
+		options.from = this.selector;
+		var selector = this.selector,
+			context = this.context;
+		FuncUnit.add(function(success, error){
+			steal.dev.log("moving "+selector)
+			FuncUnit.$(selector, context, "triggerSyn", "_move", options, success)
+		}, callback, "Could not move " + this.selector)
+		return this;
+	},
+	/**
+	 * Scrolls an element in a particular direction by setting the scrollTop or srollLeft.
+	 * @param {String} direction "left" or "top"
+	 * @param {Number} amount number of pixels to scroll
+	 * @param {Function} callback
+	 */
+	scroll: function( direction, amount, callback ) {
+		var selector = this.selector,
+			context = this.context,
+			direction = /left|right|x/i.test(direction)? "Left" : "Right";
+		FuncUnit.add(function(success, error){
+			steal.dev.log("setting "+selector+ " scroll"+direction+" "+amount+" pixels")
+			FuncUnit.$(selector, context, "scroll"+direction, amount)
+			success();
+		}, callback, "Could not scroll " + this.selector)
+		return this;
+	},
+	/**
+	 * Waits a timeout before calling the next action.  This is the same as
+	 * [FuncUnit.prototype.wait].
+	 * @param {Number} [timeout]
+	 * @param {Object} callback
+	 */
+	wait: function( timeout, callback ) {
+		FuncUnit.wait(timeout, callback)
+	}
+};
+var clicks = [
+/**
+ * @function click
+ * Clicks an element.  This uses [Syn.prototype.click] to issue a:
+ * <ul>
+ * 	<li><code>mousedown</code></li>
+ *  <li><code>focus</code> - if the element is focusable</li>
+ *  <li><code>mouseup</code></li>
+ *  <li><code>click</code></li>
+ * </ul>
+ * If no clientX/Y or pageX/Y is provided as options, the click happens at the
+ * center of the element.
+ * <p>For a right click or double click use [FuncUnit.prototype.rightClick] or
+ *   [FuncUnit.prototype.dblclick].</p>
+ * <h3>Example</h3>
+ * @codestart
+ * //clicks the bar element
+ * S("#bar").click()
+ * @codeend
+ * @param {Object} [options] options to pass to the click event.  Typically, this is clientX/Y or pageX/Y like:
+ * @codestart
+ * $('#foo').click({pageX: 200, pageY: 100});
+ * @codeend
+ * You can pass it any of the serializable parameters you'd send to :
+ * [http://developer.mozilla.org/en/DOM/event.initMouseEvent initMouseEvent], but command keys are
+ * controlled by [FuncUnit.prototype.type].
+ * @param {Function} [callback] a callback that runs after the click, but before the next action.
+ * @return {funcUnit} returns the funcunit selector for chaining.
+ */
+'click',
+/**
+ * @function dblclick
+ * Double clicks an element by [FuncUnit.prototype.click clicking] it twice and triggering a dblclick event.
+ * @param {Object} options options to add to the mouse events.  This works
+ * the same as [FuncUnit.prototype.click]'s options.
+ * @param {Function} [callback] a callback that runs after the double click, but before the next action.
+ * @return {funcUnit} returns the funcunit selector for chaining.
+ */
+'dblclick',
+/**
+ * @function rightClick
+ * Right clicks an element.  This typically results in a contextmenu event for browsers that
+ * support it.
+ * @param {Object} options options to add to the mouse events.  This works
+ * the same as [FuncUnit.prototype.click]'s options.
+ * @param {Function} [callback] a callback that runs after the click, but before the next action.
+ * @return {funcUnit} returns the funcunit selector for chaining.
+ */
+'rightClick'],
+	makeClick = function(name){
+		FuncUnit.init.prototype[name] = function(options, callback){
+			if(typeof options == 'function'){
+				callback = options;
+				options = {};
+			}
+			var selector = this.selector,
+				context = this.context;
+			FuncUnit.add(function(success, error){
+				options = options || {}
+				steal.dev.log("Clicking "+selector)
+				FuncUnit.$(selector, context, "triggerSyn", "_"+name, options, success)
+			}, callback, "Could not "+name+" " + this.selector)
+			return this;
+		}
+	}
+for(var i=0; i < clicks.length; i++){
+	makeClick(clicks[i])
+}
+//list of jQuery functions we want, number is argument index
+//for wait instead of getting value
+FuncUnit.funcs = {
+/**
+ * @function size
+ * Gets the number of elements matched by the selector or
+ * waits until the the selector is size.  You can also
+ * provide a function that continues to the next action when
+ * it returns true.
+ * @codestart
+ * S(".recipe").size() //gets the number of recipes
+ *
+ * S(".recipe").size(2) //waits until there are 2 recipes
+ *
+ * //waits until size is count
+ * S(".recipe").size(function(size){
+ *   return size == count;
+ * })
+ * @codeend
+ * @param {Number|Function} [size] number or a checking function.
+ * @param {Function} a callback that will run after this action completes.
+ * @return {Number} if the size parameter is not provided, size returns the number
+ * of elements matched.
+ */
+'size' : 0,
+/**
+ * @attr data
+ * Gets data from jQuery.data or waits until data
+ * equals some value.
+ * @codestart
+ * S("#something").data("abc") //gets the abc data
+ *
+ * S("#something").data("abc","some") //waits until the data == some
+ * @codeend
+ * @param {String} data The data to get, or wait for.
+ * @param {Object|Function} [value] If provided uses this as a check before continuing to the next action.
+ * @param {Function} a callback that will run after this action completes.
+ * @return {Object} if the size parameter is not provided, returns
+ * the object.
+ */
+'data': 1,
+/**
+ * @function attr
+ * Gets the value of an attribute from an element or waits until the attribute
+ * equals the attr param.
+ * @codestart
+ *  //gets the abc attribute
+ * S("#something").attr("abc")
+ *
+ * //waits until the abc attribute == some
+ * S("#something").attr("abc","some")
+ * @codeend
+ * @param {String} data The attribute to get, or wait for.
+ * @param {String|Function} [value] If provided uses this as a check before continuing to the next action.
+ * @param {Function} a callback that will run after this action completes.
+ * @return {Object} if the attr parameter is not provided, returns
+ * the attribute.
+ */
+'attr' : 1,
+/**
+ * @function hasClass
+ * @codestart
+ * //returns if the element has the class in its className
+ * S("#something").hasClass("selected");
+ *
+ * //waits until #something has selected in its className
+ * S("#something").hasClass("selected",true);
+ *
+ * //waits until #something does not have selected in its className
+ * S("#something").hasClass("selected",false);
+ * @codeend
+ * @param {String} className The part of the className to search for.
+ * @param {Boolean|Function} [value] If provided uses this as a check before continuing to the next action.
+ * @param {Function} [callback] a callback that will run after this action completes.
+ * @return {Boolean|funcUnit} if the value parameter is not provided, returns
+ * if the className is found in the element's className.  If a value paramters is provided, returns funcUnit for chaining.
+ */
+'hasClass' : 1, //makes wait
+/**
+ * @function html
+ * Gets the [http://api.jquery.com/html/ html] from an element or waits until the html is a certain value.
+ * @codestart
+ * //checks foo's html has "JupiterJS"
+ * ok( /JupiterJS/.test( S('#foo').html() ) )
+ *
+ * //waits until bar's html has JupiterJS
+ * S('#foo').html(/JupiterJS/)
+ *
+ * //waits until bar's html is JupiterJS
+ * S('#foo').html("JupiterJS")
+ * @codeend
+ *
+ * @param {String|Function} [html] If provided uses this as a check before continuing to the next action.
+ * @param {Function} [callback] a callback that will run after this action completes.
+ * @return {String|funcUnit} if the html parameter is provided,
+ * returns the funcUnit selector for chaining, otherwise returns the html of the selector.
+ */
+'html' : 0,
+/**
+ * @function text
+ * Gets the [http://api.jquery.com/text/ text] from an element or waits until the text is a certain value.
+ * @codestart
+ * //checks foo's text has "JupiterJS"
+ * ok( /JupiterJS/.test( S('#foo').text() ) )
+ *
+ * //waits until bar's text has JupiterJS
+ * S('#foo').text(/JupiterJS/)
+ *
+ * //waits until bar's text is JupiterJS
+ * S('#foo').text("JupiterJS")
+ * @codeend
+ *
+ * @param {String|Function} [text] If provided uses this as a check before continuing to the next action.
+ * @param {Function} [callback] a callback that will run after this action completes.
+ * @return {String|funcUnit} if the text parameter is provided,
+ * returns the funcUnit selector for chaining, otherwise returns the html of the selector.
+ */
+'text' : 0,
+/**
+ * @function val
+ * Gets the [http://api.jquery.com/val/ val] from an element or waits until the val is a certain value.
+ * @codestart
+ * //checks foo's val has "JupiterJS"
+ * ok( /JupiterJS/.test( S('input#foo').val() ) )
+ *
+ * //waits until bar's val has JupiterJS
+ * S('input#foo').val(/JupiterJS/)
+ *
+ * //waits until bar's val is JupiterJS
+ * S('input#foo').val("JupiterJS")
+ * @codeend
+ *
+ * @param {String|Function} [val] If provided uses this as a check before continuing to the next action.
+ * @param {Function} [callback] a callback that will run after this action completes.
+ * @return {String|funcUnit} if the val parameter is provided,
+ * returns the funcUnit selector for chaining, otherwise returns the html of the selector.
+ */
+'val' : 0,
+/**
+ * @function css
+ * Gets a [http://api.jquery.com/css/ css] property from an element or waits until the property is
+ * a specified value.
+ * @codestart
+ * // gets the color
+ * S("#foo").css("color")
+ *
+ * // waits until the color is red
+ * S("#foo").css("color","red")
+ * @codeend
+ *
+ * @param {String} prop A css property to get or wait until it is a specified value.
+ * @param {String|Function} [val] If provided uses this as a check before continuing to the next action.
+ * @param {Function} [callback] a callback that will run after this action completes.
+ * @return {String|funcUnit} if the val parameter is provided,
+ * returns the funcUnit selector for chaining, otherwise returns the css of the selector.
+ */
+'css': 1,
+/**
+ * @function offset
+ * Gets an element's [http://api.jquery.com/offset/ offset] or waits until
+ * the offset is a specified value.
+ * @codestart
+ * // gets the offset
+ * S("#foo").offset();
+ *
+ * // waits until the offset is 100, 200
+ * S("#foo").offset({top: 100, left: 200})
+ * @codeend
+ *
+ * @param {Object|Function} [offset] If provided uses this as a check before continuing to the next action.  Or you can
+ * provide a function that returns true to continue to the next action.
+ * @param {Function} [callback] a callback that will run after this action completes.
+ * @return {String|funcUnit} if the offset parameter is provided,
+ * returns the funcUnit selector for chaining, otherwise returns the css of the selector.
+ */
+'offset' : 0,
+/**
+ * @function position
+ * Gets an element's [http://api.jquery.com/position/ position] or waits until
+ * the position is a specified value.
+ * @codestart
+ * // gets the position
+ * S("#foo").position();
+ *
+ * // waits until the position is 100, 200
+ * S("#foo").position({top: 100, left: 200})
+ * @codeend
+ *
+ * @param {Object|Function} [position] If provided uses this as a check before continuing to the next action.  Or you can
+ * provide a function that returns true to continue to the next action.
+ * @param {Function} [callback] a callback that will run after this action completes.
+ * @return {String|funcUnit} if the position parameter is provided,
+ * returns the funcUnit selector for chaining, otherwise returns the offset of the selector.
+ */
+'position' : 0,
+/**
+ * @function scrollTop
+ * Gets an element's [http://api.jquery.com/scrollTop/ scrollTop] or waits until
+ * it equals a specified value.
+ * @codestart
+ * // gets the scrollTop
+ * S("#foo").scrollTop();
+ *
+ * // waits until the scrollTop is 100
+ * S("#foo").scrollTop(100)
+ * @codeend
+ *
+ * @param {Number|Function} [scrollTop] If provided uses this as a check before continuing to the next action.  Or you can
+ * provide a function that returns true to continue to the next action.
+ * @param {Function} [callback] a callback that will run after this action completes.
+ * @return {String|funcUnit} if scrollTop is provided,
+ * returns the funcUnit selector for chaining, otherwise returns the scrollTop of the selector.
+ */
+'scrollTop' : 0,
+/**
+ * @function scrollLeft
+ * Gets an element's [http://api.jquery.com/scrollLeft/ scrollLeft] or waits until
+ * it equals a specified value.
+ * @codestart
+ * // gets the scrollLeft
+ * S("#foo").scrollLeft();
+ *
+ * // waits until the scrollLeft is 100
+ * S("#foo").scrollLeft(100)
+ * @codeend
+ *
+ * @param {Number|Function} [scrollLeft] If provided uses this as a check before continuing to the next action.  Or you can
+ * provide a function that returns true to continue to the next action.
+ * @param {Function} [callback] a callback that will run after this action completes.
+ * @return {String|funcUnit} if scrollLeft is provided,
+ * returns the funcUnit selector for chaining, otherwise returns the scrollLeft of the selector.
+ */
+'scrollLeft' : 0,
+/**
+ * @function height
+ * Gets an element's [http://api.jquery.com/height/ height] or waits until
+ * it equals a specified value.
+ * @codestart
+ * // gets the height
+ * S("#foo").height();
+ *
+ * // waits until the height is 100
+ * S("#foo").height(100)
+ * @codeend
+ *
+ * @param {Number|Function} [height] If provided uses this as a check before continuing to the next action.  Or you can
+ * provide a function that returns true to continue to the next action.
+ * @param {Function} [callback] a callback that will run after this action completes.
+ * @return {String|funcUnit} if height is provided,
+ * returns the funcUnit selector for chaining, otherwise returns the height of the selector.
+ */
+'height' : 0,
+/**
+ * @function width
+ * Gets an element's [http://api.jquery.com/width/ width] or waits until
+ * it equals a specified value.
+ * @codestart
+ * // gets the width
+ * S("#foo").width();
+ *
+ * // waits until the width is 100
+ * S("#foo").width(100)
+ * @codeend
+ *
+ * @param {Number|Function} [width] If provided uses this as a check before continuing to the next action.  Or you can
+ * provide a function that returns true to continue to the next action.
+ * @param {Function} [callback] a callback that will run after this action completes.
+ * @return {String|funcUnit} if width is provided,
+ * returns the funcUnit selector for chaining, otherwise returns the width of the selector.
+ */
+'width' : 0,
+/**
+ * @function innerHeight
+ * Gets an element's [http://api.jquery.com/innerHeight/ innerHeight] or waits until
+ * it equals a specified value.
+ * @codestart
+ * // gets the innerHeight
+ * S("#foo").innerHeight();
+ *
+ * // waits until the innerHeight is 100
+ * S("#foo").innerHeight(100)
+ * @codeend
+ *
+ * @param {Number|Function} [innerHeight] If provided uses this as a check before continuing to the next action.  Or you can
+ * provide a function that returns true to continue to the next action.
+ * @param {Function} [callback] a callback that will run after this action completes.
+ * @return {String|funcUnit} if innerHeight is provided,
+ * returns the funcUnit selector for chaining, otherwise returns the innerHeight of the selector.
+ */
+'innerHeight' : 0,
+/**
+ * @function innerWidth
+ * Gets an element's [http://api.jquery.com/innerWidth/ innerWidth] or waits until
+ * it equals a specified value.
+ * @codestart
+ * // gets the innerWidth
+ * S("#foo").innerWidth();
+ *
+ * // waits until the innerWidth is 100
+ * S("#foo").innerWidth(100)
+ * @codeend
+ *
+ * @param {Number|Function} [innerWidth] If provided uses this as a check before continuing to the next action.  Or you can
+ * provide a function that returns true to continue to the next action.
+ * @param {Function} [callback] a callback that will run after this action completes.
+ * @return {String|funcUnit} if innerWidth is provided,
+ * returns the funcUnit selector for chaining, otherwise returns the innerWidth of the selector.
+ */
+'innerWidth' : 0,
+/**
+ * @function outerHeight
+ * Gets an element's [http://api.jquery.com/outerHeight/ outerHeight] or waits until
+ * it equals a specified value.
+ * @codestart
+ * // gets the outerHeight
+ * S("#foo").outerHeight();
+ *
+ * // waits until the outerHeight is 100
+ * S("#foo").outerHeight(100)
+ * @codeend
+ *
+ * @param {Number|Function} [outerHeight] If provided uses this as a check before continuing to the next action.  Or you can
+ * provide a function that returns true to continue to the next action.
+ * @param {Function} [callback] a callback that will run after this action completes.
+ * @return {String|funcUnit} if outerHeight is provided,
+ * returns the funcUnit selector for chaining, otherwise returns the outerHeight of the selector.
+ */
+'outerHeight' : 0,
+/**
+ * @function outerWidth
+ * Gets an element's [http://api.jquery.com/outerWidth/ outerWidth] or waits until
+ * it equals a specified value.
+ * @codestart
+ * // gets the outerWidth
+ * S("#foo").outerWidth();
+ *
+ * // waits until the outerWidth is 100
+ * S("#foo").outerWidth(100)
+ * @codeend
+ *
+ * @param {Number|Function} [outerWidth] If provided uses this as a check before continuing to the next action.  Or you can
+ * provide a function that returns true to continue to the next action.
+ * @param {Function} [callback] a callback that will run after this action completes.
+ * @return {String|funcUnit} if outerWidth is provided,
+ * returns the funcUnit selector for chaining, otherwise returns the outerWidth of the selector.
+ */
+'outerWidth' : 0}
+//makes a jQuery like command.
+FuncUnit.makeFunc = function(fname, argIndex){
+	//makes a read / wait function
+	FuncUnit.init.prototype[fname] = function(){
+		//assume last arg is callback
+		var args = FuncUnit.makeArray(arguments),
+			callback,
+			isWait = args.length > argIndex,
+			callback;
+		args.unshift(this.selector,this.context,fname)
+		if(isWait){
+			//get the args greater and equal to argIndex
+			var tester = args[argIndex+3],
+				timeout = args[argIndex+4],
+				callback = args[argIndex+5],
+				testVal = tester,
+				errorMessage = "waiting for "+fname +" on " + this.selector;
+			if(typeof timeout == 'function'){
+				callback = timeout;
+				timeout = undefined;
+			}
+			args.splice(argIndex+3, args.length- argIndex - 3);
+			if(typeof tester != 'function'){
+				errorMessage += " !== "+testVal
+				tester = function(val){
+					return QUnit.equiv(val, testVal) ||
+						(testVal instanceof RegExp && testVal.test(val) );
+				}
+			}
+			FuncUnit.repeat(function(){
+					var ret = FuncUnit.$.apply(FuncUnit.$, args);
+					return tester(ret);
+				}, callback, errorMessage, timeout)
+			return this;
+		}else{
+			//get the value
+			steal.dev.log("Getting "+fname+" on "+this.selector)
+			return FuncUnit.$.apply(FuncUnit.$, args);
+		}
+	}
+}
+for (var prop in FuncUnit.funcs) {
+	FuncUnit.makeFunc(prop, FuncUnit.funcs[prop]);
+}
+S = FuncUnit;
+})
+//now add drivers
+.then('resources/selenium_start',
+'drivers/selenium',
+'drivers/standard')