RubyGems - rubinium - Versions diffs - 0.1.1 - Mend

rubinium 0.1.1

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 (161) hide show

data/vendor/selenium-0.6.0/selenium/tests/browserbot/pagebot-locator-tests-include.html ADDED

@@ -0,0 +1,33 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<!--
+Copyright 2004 ThoughtWorks, Inc
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+     http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<html>
+  <head>
+	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <title>JsUnit Utility Tests</title>
+  </head>
+  <body>
+    <a id="id1" href="#id1">this is the first element</a>
+    <a id="id2" name="name1" href="#id2">this is the second element</a>
+    <a id="id3" name="name1" href="#id3">this is the third element</a>
+    <a id="id4" name="id3" href="#id4">this is the fourth element</a>
+    <p id="document.links[0]" name="name1" class="pstyle">dummy element</p>
+  </body>
+</html>

data/vendor/selenium-0.6.0/selenium/tests/browserbot/pagebot-locator-tests.html ADDED

@@ -0,0 +1,258 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<!--
+Copyright 2004 ThoughtWorks, Inc
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+     http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<html>
+  <head>
+	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <title>JsUnit Utility Tests</title>
+    <link rel="stylesheet" type="text/css" href="/jsunit/css/jsUnitStyle.css">
+<script language="JavaScript" type="text/javascript" src="/jsunit/app/jsUnitCore.js"></script>
+<script language="JavaScript" type="text/javascript" src="/jsmock/mock.js"></script>
+<script language="JavaScript" type="text/javascript" src="/html-xpath/html-xpath-patched.js"></script>
+<script language="JavaScript" type="text/javascript" src="/selenium-browserbot.js"></script>
+<script language="JavaScript" type="text/javascript" src="/htmlutils.js"></script>
+<script language="JavaScript" type="text/javascript">
+function setUp() {
+    // To be realistic, the elements are located in a separate IFrame.
+    var iframe = document.getElementById("testIframe");
+    var iWindow = iframe.contentWindow.window;
+    frameDocument = iWindow.document;
+    pageBot = PageBot.createForWindow(iWindow);
+    element1 = iWindow.document.getElementById("id1");
+    element2 = iWindow.document.getElementById("id2");
+    element3 = iWindow.document.getElementById("id3");
+    element4 = iWindow.document.getElementById("document.links[0]");
+}
+//
+// Tests for "id" locator
+//
+function testIdLocatorReturnsNullIfElementNotPresent() {
+    assertNull(pageBot.findElementBy('id','noSuchElement', frameDocument));
+}
+function testIdLocatorReturnsElementWithMatchingId() {
+    assertEquals(element3, pageBot.findElementBy('id','id3', frameDocument));
+}
+function testIdLocatorDoesNotReturnElementWithMatchingName() {
+    assertNull(pageBot.findElementBy('id','name1', frameDocument));
+}
+//
+// Tests for "name" locator
+//
+function testNameLocatorReturnsNullIfElementNotPresent() {
+    assertNull(pageBot.findElementBy('name','noSuchElement', frameDocument));
+}
+function testNameLocatorDoesNotReturnElementWithMatchingId() {
+    assertNull(pageBot.findElementBy('name','id2', frameDocument));
+}
+function testNameLocatorReturnsElementWithMatchingName() {
+    assertEquals(element2, pageBot.findElementBy('name','name1', frameDocument));
+}
+//
+// Tests for "identifier" locator
+//
+function testIdentifierLocatorReturnsNullIfElementNotPresent() {
+    assertNull(pageBot.findElementBy('identifier','noSuchElement', frameDocument));
+}
+function testIdentifierLocatorReturnsHtmlElementWithMatchingId() {
+    assertEquals(element3, pageBot.findElementBy('identifier','id3', frameDocument));
+}
+function testIdentifierLocatorReturnsFirstElementWithMatchingName() {
+    assertEquals(element2, pageBot.findElementBy('identifier','name1', frameDocument));
+}
+//
+// Tests for "dom" locator
+//
+function testLocateElementByDomTraversal() {
+    assertEquals(element2,
+                 pageBot.findElementBy('dom',"document.links[1]", frameDocument));
+}
+function testLocateElementByDomTraversalReturnsNullForNoMatchingElement() {
+}
+function testLocateElementByDomTraversalFailsWithInvalidDomString() {
+    try {
+        pageBot.findElementBy('dom',"document.foo.bar", frameDocument);
+        fail("Should have thrown exception");
+    }
+    catch (e) {
+        // Expected
+    }
+}
+//
+// Tests for "xpath" locator
+//
+function testLocateElementByXPathWithTagNameOnly() {
+    assertEquals(element4,
+                 pageBot.findElementBy('xpath',"//p", frameDocument));
+}
+function testLocateElementByXPathWithAttributeOnly() {
+    assertEquals(element4,
+                 pageBot.findElementBy('xpath',"//*[@class='pstyle']", frameDocument));
+}
+function testLocateElementByXPathWithTagNameAndAttribute() {
+    assertEquals(element4,
+                 pageBot.findElementBy('xpath',"//p[@name='name1']", frameDocument));
+}
+function testLocateElementByXPathReturnsFirstMatchingElement() {
+    assertEquals(element2,
+                 pageBot.findElementBy('xpath',"//*[@name='name1']", frameDocument));
+}
+//
+// Tests for "link" locator
+//
+function testLocateLinkReturnsNullIfLocatorIsNotLinkLocator() {
+    assertNull(pageBot.findElementBy('link','//NotALinkLocator', frameDocument));
+}
+function testLocateLinkReturnsNullIfLinkNotPresent() {
+    assertNull(pageBot.findElementBy('link','No Such Link', frameDocument));
+}
+function testLinkElementReturnsLinkWithMatchingText() {
+    assertEquals(element3, pageBot.findElementBy('link','this is the third element', frameDocument));
+}
+function testLinkElementWithGlob() {
+    assertEquals(element3, pageBot.findElementBy('link','this * third element', frameDocument));
+}
+function testLinkElementWithRegex() {
+    assertEquals(element3, pageBot.findElementBy('link','regexp:this [aeiou]s the third element', frameDocument));
+}
+//
+// Tests for PageBot.findElement()
+//
+function testFindElementWithNoLocatorPrefixUsesImplicitStrategy() {
+    var calls = new Array();
+    pageBot.locationStrategies['implicit'] = function(locator) { calls.push(locator); return "bar";};
+    var element = pageBot.findElement("foo");
+    assertEquals("bar", element);
+    assertEquals("foo", calls.join());
+}
+function testFindElementThrowsExceptionIfNoElementFound() {
+    var calls = new Array();
+    pageBot.locationStrategies['implicit'] = function(locator) { calls.push(locator); return null;};
+    var element = null;
+    var failureMessage = null;
+    try {
+        element = pageBot.findElement("foo");
+    } catch (e) {
+        failureMessage = e.message;
+    }
+    assertNull(element);
+    assertEquals("Element foo not found", failureMessage);
+    assertEquals("foo", calls.join());
+}
+function testFindElementWithLocatorPrefixUsesSpecifiedStrategy() {
+    var calls = new Array();
+    pageBot.locationStrategies["anotherlocator"] = function(locator) { calls.push(locator); return "bar";};
+    element = pageBot.findElement("anotherlocator=foo");
+    assertEquals("bar", element);
+    assertEquals("foo", calls.join());
+}
+function testFindElementWithUnknownLocatorPrefixThrowsException() {
+    var calls = new Array();
+    pageBot.locationStrategies['implicit'] = function(locator) { calls.push(locator); return "bar";};
+    var element = null;
+    var failureMessage = null;
+    try {
+        element = pageBot.findElement("bogus=foo");
+    } catch (e) {
+        failureMessage = e.message;
+    }
+    assertNull(element);
+    assertEquals("Unrecognised locator type: 'bogus'", failureMessage);
+    assertEquals("", calls.join());
+}
+function testFindElementReturnsElementWithMatchingIdentifier() {
+    assertEquals(element2, pageBot.findElement("id2"));
+}
+function testFindElementReturnsMatchingName() {
+    assertEquals(element2, pageBot.findElement("name1"));
+}
+function testFindElementTriesDomTraversalBeforeId() {
+    assertEquals(element1, pageBot.findElement("document.links[0]"));
+    assertEquals(element4, pageBot.findElement("id=document.links[0]"));
+}
+function testFindElementHandlesLinkLocators() {
+    assertEquals(element3, pageBot.findElement('link=this is the third element'));
+}
+function testUnknownElementWithoutDomTraversal() {
+    try {
+        pageBot.findElement("unknownElement");
+        fail("Should have failed for element not found");
+    }
+    catch (e) {
+        // expected
+    }
+}
+function testUnknownElementWithDomTraversal() {
+    try {
+        pageBot.findElement("document.foo");
+        fail("Should have failed for element not found");
+    }
+    catch (e) {
+        // expected
+    }
+}
+function testFindElementHandlesDomTraversal() {
+    assertEquals(element3, pageBot.findElement("document.links[2]"));
+}
+</script>
+  </head>
+  <body>
+    <iframe id="testIframe" src="./pagebot-locator-tests-include.html"/>
+  </body>
+</html>

data/vendor/selenium-0.6.0/selenium/tests/browserbot/pagebot-property-tests.html ADDED

@@ -0,0 +1,49 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<!--
+Copyright 2004 ThoughtWorks, Inc
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+     http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<html>
+  <head>
+	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <title>PageBot Property Tests</title>
+    <link rel="stylesheet" type="text/css" href="/jsunit/css/jsUnitStyle.css">
+<script language="JavaScript" type="text/javascript" src="/jsunit/app/jsUnitCore.js"></script>
+<script language="JavaScript" type="text/javascript" src="/jsmock/mock.js"></script>
+<script language="JavaScript" type="text/javascript" src="/selenium-browserbot.js"></script>
+<script language="JavaScript" type="text/javascript" src="/htmlutils.js"></script>
+<script language="JavaScript" type="text/javascript">
+function setUp() {
+    pageBot = PageBot.createForWindow(window);
+}
+function testTitleProperty() {
+    assertEquals("PageBot Property Tests", pageBot.title());
+}
+function testLocationProperty() {
+    assertEquals("/tests/browserbot/pagebot-property-tests.html", pageBot.location.pathname);
+}
+function testBodyText() {
+    assertEquals("Selenium Browserbot Tests", pageBot.bodyText());
+}
+</script>
+  </head>
+  <body>Selenium Browserbot Tests</body>
+</html>

data/vendor/selenium-0.6.0/selenium/tests/browserbot/pattern-matcher-tests.html ADDED

@@ -0,0 +1,66 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<!--
+Copyright 2004 ThoughtWorks, Inc
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+     http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<html>
+  <head>
+	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <title>PatternMatcher tests</title>
+    <link rel="stylesheet" type="text/css" href="/jsunit/css/jsUnitStyle.css">
+<script language="JavaScript" type="text/javascript" src="/jsunit/app/jsUnitCore.js"></script>
+<script language="JavaScript" type="text/javascript" src="/jsmock/mock.js"></script>
+<script language="JavaScript" type="text/javascript" src="/htmlutils.js"></script>
+<script language="JavaScript" type="text/javascript" src="/selenium-executionloop.js"></script>
+<script language="JavaScript" type="text/javascript" src="/selenium-api.js"></script>
+<script language="JavaScript" type="text/javascript">
+function testRegexpFromGlob() {
+    var regexpFromGlob = PatternMatcher.regexpFromGlob;
+    assertEquals("^(.|[\r\n])*$", regexpFromGlob("*"));
+    assertEquals("^(.|[\r\n])$", regexpFromGlob("?"));
+    assertEquals("^a(.|[\r\n])*b$", regexpFromGlob("a*b"));
+    assertEquals("^\\.\\|\\^\\$\\(\\)\\[\\]\\{\\}$", regexpFromGlob(".|^$()[]{}"));
+    assertEquals("^(.|[\r\n])*/foo/bar(.|[\r\n])*$", regexpFromGlob("*/foo/bar*"));
+}
+function testCanMatchUsingGlob() {
+    assertTrue(new PatternMatcher("glob:a*e").matches("apple"));
+    assertFalse(new PatternMatcher("glob:a*z").matches("apple"));
+}
+function testMatchUsingGlobByDefault() {
+    assertTrue(new PatternMatcher("a*e").matches("apple"));
+    assertFalse(new PatternMatcher("a*z").matches("apple"));
+}
+function testCanMatchUsingRegexp() {
+    assertTrue(new PatternMatcher("regexp:pp").matches("apple"));
+    assertFalse(new PatternMatcher("regexp:^pp").matches("apple"));
+    assertTrue(new PatternMatcher("regexp:[a-z]$").matches("apple"));
+}
+function testCanDoExactMatch() {
+    assertTrue(new PatternMatcher("exact:abc").matches("abc"));
+    assertFalse(new PatternMatcher("exact:a*c").matches("abc"));
+    assertTrue(new PatternMatcher("exact:a*c").matches("a*c"));
+}
+</script>
+  </head>
+  <body>PatternMatcher Tests</body>
+</html>

data/vendor/selenium-0.6.0/selenium/tests/browserbot/selenium-api-tests.html ADDED

@@ -0,0 +1,412 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
+"http://www.w3.org/TR/html4/loose.dtd">
+<!--
+Copyright 2004 ThoughtWorks, Inc
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+     http://www.apache.org/licenses/LICENSE-2.0
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+<html>
+  <head>
+	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
+    <title>BrowserBot tests</title>
+    <link rel="stylesheet" type="text/css" href="/jsunit/css/jsUnitStyle.css">
+<script language="JavaScript" type="text/javascript" src="/jsunit/app/jsUnitCore.js"></script>
+<script language="JavaScript" type="text/javascript" src="/jsmock/mock.js"></script>
+<script language="JavaScript" type="text/javascript" src="/htmlutils.js"></script>
+<script language="JavaScript" type="text/javascript" src="/selenium-executionloop.js"></script>
+<script language="JavaScript" type="text/javascript" src="/selenium-api.js"></script>
+<script language="JavaScript" type="text/javascript">
+function setUp() {
+    mockPageBot = new Mock();
+    mockBrowserBot = new Mock();
+    mockBrowserBot.getCurrentPage = function() { return mockPageBot; };
+    selenium = new Selenium(mockBrowserBot);
+    assertEquals(mockPageBot, selenium.page());
+}
+function verifyMocks() {
+    mockBrowserBot.verify();
+    mockPageBot.verify();
+}
+// Tests for Element actions
+function testClickElementWithoutCallback() {
+    mockPageBot.expects("findElement", "id").returns("elementToClick");
+    mockPageBot.expects("clickElement", "elementToClick");
+    selenium.doClick("id");
+    verifyMocks();
+}
+function testType() {
+    mockPageBot.expects("findElement", "id").returns("elementToType");
+    mockPageBot.expects("replaceText", "elementToType", "new text");
+    selenium.doType("id", "new text");
+    verifyMocks();
+}
+function testSelect() {
+    var mockOptionLocatorFactory = new Mock();
+    selenium.optionLocatorFactory = mockOptionLocatorFactory;
+    var mockSelect = new Mock();
+    // The doSelect() method checks the options property exists as a way
+    // of ensuring that the element is a Select element.  Hence the following expectation.
+    mockSelect.expectsProperty("options").returns("some options");
+    mockPageBot.expects("findElement", "id").returns(mockSelect);
+    var mockOptionLocator = new Mock();
+    mockOptionLocatorFactory.expects("fromLocatorString", "Option One").returns(mockOptionLocator);
+    var option = new Object();
+    mockOptionLocator.expects("findOption", mockSelect).returns(option);
+    mockPageBot.expects("selectOption", mockSelect, option);
+    selenium.doSelect("id", "Option One");
+    mockOptionLocatorFactory.verify();
+    mockOptionLocator.verify();
+    mockSelect.verify();
+    verifyMocks();
+}
+// Browser actions
+function testOpen() {
+    mockBrowserBot.expects("openLocation", "new/location");
+    selenium.doOpen("new/location");
+    verifyMocks();
+}
+function testSelectWindow() {
+    mockBrowserBot.expects("selectWindow", "windowName");
+    selenium.doSelectWindow("windowName");
+    verifyMocks();
+}
+// Verify functions
+function testVerifyLocationSuccess() {
+    var mockLocation = {pathname:'http://page/path', search:'?foo=bar'};
+    mockPageBot.expectsProperty("location").returns(mockLocation);
+    selenium.assertLocation("path");
+    selenium.assertLocation("page/path");
+    selenium.assertLocation("http://page/path");
+    selenium.assertLocation("page/path?foo=bar");
+    selenium.assertLocation("http://page/path?foo=bar");
+    verifyMocks();
+}
+function testVerifyLocationFailed() {
+    var mockLocation = {pathname:'http://page/path', search:'?foo=bar'};
+    mockPageBot.expectsProperty("location").returns(mockLocation);
+    assertCallFails("Verify location should have failed",
+                    function() {selenium.assertLocation("bar");});
+    assertCallFails("Verify location should have failed",
+                    function() {selenium.assertLocation("http://page/");});
+    assertCallFails("Verify location should have failed",
+                    function() {selenium.assertLocation("http://page/path?foo");});
+    verifyMocks();
+}
+function testGetTitleReturnsTheTitle() {
+    mockPageBot.expects("title").returns("foo");
+    assertEquals("foo", selenium.getTitle());
+    verifyMocks();
+}
+function testGetValueOfText() {
+    var mockTextControl = Object();
+    mockTextControl.type = "TEXT";
+    mockTextControl.value = "the value";
+    mockPageBot.expects("findElement", "id").returns(mockTextControl);
+    assertEquals("the value", selenium.getValue("id"));
+    verifyMocks();
+}
+function testGetValueOfCheckbox() {
+    var mockControl = Object();
+    mockControl.type = "CHECKBOX";
+    mockControl.value = "the value";
+    mockControl.checked = true;
+    mockPageBot.expects("findElement", "id").returns(mockControl);
+    assertEquals("on", selenium.getValue("id"));
+    verifyMocks();
+}
+function testGetText() {
+    var mockElement = new Object();
+    mockElement.textContent = " foo ";
+    mockPageBot.expects("findElement", "id").returns(mockElement);
+    assertEquals("foo", selenium.getText("id"));
+    verifyMocks();
+}
+function getMockTable() {
+    var mockTable = new Object();
+    var row1 = new Object();
+    row1.cells = [textCell("foo"), textCell("bar")];
+    var row2 = new Object();
+    row2.cells = [textCell("fuz"), textCell("buz")];
+    mockTable.rows = [row1, row2];
+    return mockTable;
+}
+function textCell(val) {
+   var cell = new Object();
+   cell.textContent = val;
+   return cell;
+}
+function testGetTableSuccess() {
+    mockPageBot.expects("findElement", "table").returns(getMockTable());
+    assertEquals("buz", selenium.getTable("table.1.1"));
+    verifyMocks();
+}
+function testGetTableInvalidLocator() {
+    assertCallErrors("VerifyTable should have failed for invalid locator",
+                    function() {selenium.getTable("foo");},
+                    "Invalid target format. Correct format is tableName.rowNum.columnNum");
+    verifyMocks();
+}
+function testGetTableNoSuchRow() {
+    var mockTable = getMockTable();
+    mockPageBot.expects("findElement", "table").returns(mockTable);
+    assertCallFails("VerifyTable should have failed for no such row",
+                    function() {selenium.getTable("table.11.0", "bar");},
+                    "Cannot access row 11 - table has 2 rows");
+    verifyMocks();
+}
+function testGetTableNoSuchColumn() {
+    var mockTable = getMockTable();
+    mockPageBot.expects("findElement", "table").returns(mockTable);
+    assertCallFails("VerifyTable should have failed for no such column",
+                    function() {selenium.getTable("table.0.11", "bar");},
+                    "Cannot access column 11 - table row has 2 columns");
+    verifyMocks();
+}
+function testVerifyTextPresentSuccess() {
+    mockPageBot.expects("bodyText").returns("this is some foo text");
+    selenium.assertTextPresent("foo");
+    verifyMocks();
+}
+function testVerifyTextPresentFailed() {
+    mockPageBot.expects("bodyText").returns("this is some foo text");
+    assertCallFails("Verify text should have failed",
+                    function() { selenium.assertTextPresent("bar");});
+    verifyMocks();
+}
+function testVerifyElementPresentSuccess() {
+    mockPageBot.expects("findElement", "id").returns("foo");
+    selenium.assertElementPresent("id");
+    verifyMocks();
+}
+function testVerifyElementPresentFailure() {
+    mockPageBot.expects("findElement", "id").andThrows("foo");
+    assertCallFails("VerifyElementPresent should have failed",
+                    function() {selenium.assertElementPresent("id");});
+    verifyMocks();
+}
+function testVerifyElementNotPresentSuccess() {
+    mockPageBot.expects("findElement", "id").andThrows("foo");
+    selenium.assertElementNotPresent("id");
+    verifyMocks();
+}
+function testGetAllButtonsShouldCallPageBot() {
+    mockPageBot.expects("getAllButtons").returns("foo");
+    selenium.getAllButtons();
+    verifyMocks();
+}
+function testGetAllFieldsShouldCallPageBot() {
+    mockPageBot.expects("getAllFields").returns("foo");
+    selenium.getAllFields();
+    verifyMocks();
+}
+function testGetAllLinksShouldCallPageBot() {
+    mockPageBot.expects("getAllLinks").returns("foo");
+    selenium.getAllLinks();
+    verifyMocks();
+}
+function testVerifyElementNotPresentFailure() {
+    mockPageBot.expects("findElement", "id").returns("foo");
+    assertCallFails("VerifyElementNotPresent should have failed",
+                    function() { selenium.assertElementNotPresent("id"); });
+    verifyMocks();
+}
+function testShouldFailIfTryToGetAlertWhenThereAreNone() {
+    mockBrowserBot.expects("hasAlerts").returns(false);
+    assertCallFails("getAlert should have failed",
+                    function() {selenium.getAlert(); },
+                    "There were no alerts");
+    verifyMocks();
+}
+function testGetAlertReturnsNextAlert() {
+    mockBrowserBot.expects("hasAlerts").returns(true);
+    mockBrowserBot.expects("getNextAlert").returns("The real alert");
+    assertEquals("The real alert", selenium.getAlert());
+    verifyMocks();
+}
+function testShouldFailIfTryToVerifyConfirmationWhenThereAreNone() {
+    mockBrowserBot.expects("hasConfirmations").returns(false);
+    assertCallFails("verifyConfirmation should have failed",
+                    function() {selenium.getConfirmation();},
+                    "There were no confirmations");
+    verifyMocks();
+}
+function testGetConfirmationReturnsNextConfirmation() {
+      mockBrowserBot.expects("hasConfirmations").returns(true);
+      mockBrowserBot.expects("getNextConfirmation").returns("The real confirmation");
+     assertEquals("The real confirmation", selenium.getConfirmation());
+     verifyMocks();
+}
+function testShouldTellBroswerBotIfAskedToCancelNextConfirmation() {
+     mockBrowserBot.expects("cancelNextConfirmation");
+     selenium.doChooseCancelOnNextConfirmation();
+     verifyMocks();
+}
+function testVerifySelectedSuccess() {
+    var mockTextControl = Object();
+    mockTextControl.selectedIndex = 1;
+    mockTextControl.options = [{text: "option0"},{text: "option1"},{text: "option2"}];
+    mockPageBot.expects("findElement", "id").returns(mockTextControl);
+    selenium.assertSelected("id", "option1");
+    verifyMocks();
+}
+function testVerifySelectedFailed() {
+    var mockTextControl = Object();
+    mockTextControl.selectedIndex = 1;
+    mockTextControl.options = [{text: "option0"},{text: "option1"},{text: "option2"}];
+    mockPageBot.expects("findElement", "id").returns(mockTextControl);
+    assertCallFails("Verify selected should have failed.",
+                    function() {selenium.assertSelected("id", "option2");});
+    verifyMocks();
+}
+function testVerifySelectOptionsSuccess() {
+    var mockTextControl = Object();
+    mockTextControl.options = [{text: "option0"},{text: "option1"},{text: "option2"}];
+    mockPageBot.expects("findElement", "id").returns(mockTextControl);
+    selenium.assertSelectOptions("id", "option0,option1,option2");
+    verifyMocks();
+}
+function testVerifySelectOptionsFailed() {
+    var mockTextControl = Object();
+    mockTextControl.options = [{text: "option0"},{text: "option1"},{text: "option2"}];
+    mockPageBot.expects("findElement", "id").returns(mockTextControl);
+    assertCallFails("Verify select options failed.",
+                    function() { selenium.assertSelectOptions("id", "option0"); });
+    verifyMocks();
+}
+function testVerifySelectOptionsWithCommasEscaped() {
+    var mockTextControl = Object();
+    mockTextControl.options = [{text: "option,0"},{text: "option.1"}];
+    mockPageBot.expects("findElement", "id").returns(mockTextControl);
+    selenium.assertSelectOptions("id", "option\\,0,option.1");
+    verifyMocks();
+}
+function testGetAttributeWithId() {
+    mockPageBot.expects("findAttribute", "id@attribute").returns("foo");
+    assertEquals("foo", selenium.getAttribute("id@attribute"));
+    verifyMocks();
+}
+function testWaitForCreatesWaitForConditionOnTestLoop() {
+    var mockElement = new Object();
+    mockElement.value = "oldValue";
+    mockPageBot.expects("findElement", "id").returns(mockElement);
+    testLoop = new Object();
+    assertEquals(undefined, testLoop.waitForCondition);
+    selenium.doWaitForValue("id", "newValue");
+    assertNotEquals(undefined, testLoop.waitForCondition);
+    assertFalse("Wait condition should not yet be true",
+                 testLoop.waitForCondition());
+    mockElement.value = "newValue";
+    assertTrue( "Wait condition should now be true",
+               testLoop.waitForCondition());
+}
+function assertCallFails(message, theCall, expectedFailureMessage) {
+    try {
+        theCall();
+    } catch (e) {
+        if (!e.isAssertionFailedError) {
+            throw e;
+        }
+        if (expectedFailureMessage) {
+            assertEquals(expectedFailureMessage, e.failureMessage);
+        }
+        return;
+    }
+    fail(message);
+}
+function assertCallErrors(message, theCall, expectedFailureMessage) {
+    try {
+        theCall();
+    } catch (e) {
+        if (expectedFailureMessage) {
+            assertEquals(expectedFailureMessage, e.message);
+        }
+        return;
+    }
+    fail(message);
+}
+</script>
+  </head>
+  <body>Selenium API Tests</body>
+</html>