RubyGems - rubinium - Versions diffs - 0.1.1 - Mend

rubinium 0.1.1

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>