Subversion-Projekte lars-tiefland.prado

/*

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

 *

 */

// TODO: stop navigating this.browserbot.document() ... it breaks encapsulation

var storedVars = new Object();

function Selenium(browserbot) {

    /**

     * Defines an object that runs Selenium commands.

     *

     * <h3><a name="locators"></a>Element Locators</h3>

     * <p>

     * Element Locators tell Selenium which HTML element a command refers to.

     * The format of a locator is:</p>

     * <blockquote>

     * <em>locatorType</em><strong>=</strong><em>argument</em>

     * </blockquote>

     *

     * <p>

     * We support the following strategies for locating elements:

     * </p>

     *

     * <ul>

     * <li><strong>identifier</strong>=<em>id</em>:

     * Select the element with the specified @id attribute. If no match is

     * found, select the first element whose &#64;name attribute is <em>id</em>.

     * (This is normally the default; see below.)</li>

     * <li><strong>id</strong>=<em>id</em>:

     * Select the element with the specified &#64;id attribute.</li>

     *

     * <li><strong>name</strong>=<em>name</em>:

     * Select the first element with the specified @name attribute.

     * <ul class="first last simple">

     * <li>username</li>

     * <li>name=username</li>

     * </ul>

     *

     * <p>The name may optionally be followed by one or more <em>element-filters</em>, separated from the name by whitespace.  If the <em>filterType</em> is not specified, <strong>value</strong> is assumed.</p>

     *

     * <ul class="first last simple">

     * <li>name=flavour value=chocolate</li>

     * </ul>

     * </li>

     * <li><strong>dom</strong>=<em>javascriptExpression</em>:

     *

     * Find an element by evaluating the specified string.  This allows you to traverse the HTML Document Object

     * Model using JavaScript.  Note that you must not return a value in this string; simply make it the last expression in the block.

     * <ul class="first last simple">

     * <li>dom=document.forms['myForm'].myDropdown</li>

     * <li>dom=document.images[56]</li>

     * <li>dom=function foo() { return document.links[1]; }; foo();</li>

     * </ul>

     *

     * </li>

     *

     * <li><strong>xpath</strong>=<em>xpathExpression</em>:

     * Locate an element using an XPath expression.

     * <ul class="first last simple">

     * <li>xpath=//img[&#64;alt='The image alt text']</li>

     * <li>xpath=//table[&#64;id='table1']//tr[4]/td[2]</li>

     * <li>xpath=//a[contains(&#64;href,'#id1')]</li>

     * <li>xpath=//a[contains(&#64;href,'#id1')]/&#64;class</li>

     * <li>xpath=(//table[&#64;class='stylee'])//th[text()='theHeaderText']/../td</li>

     * <li>xpath=//input[&#64;name='name2' and &#64;value='yes']</li>

     * <li>xpath=//*[text()="right"]</li>

     *

     * </ul>

     * </li>

     * <li><strong>link</strong>=<em>textPattern</em>:

     * Select the link (anchor) element which contains text matching the

     * specified <em>pattern</em>.

     * <ul class="first last simple">

     * <li>link=The link text</li>

     * </ul>

     *

     * </li>

     *

     * <li><strong>css</strong>=<em>cssSelectorSyntax</em>:

     * Select the element using css selectors. Please refer to <a href="http://www.w3.org/TR/REC-CSS2/selector.html">CSS2 selectors</a>, <a href="http://www.w3.org/TR/2001/CR-css3-selectors-20011113/">CSS3 selectors</a> for more information. You can also check the TestCssLocators test in the selenium test suite for an example of usage, which is included in the downloaded selenium core package.

     * <ul class="first last simple">

     * <li>css=a[href="#id3"]</li>

     * <li>css=span#firstChild + span</li>

     * </ul>

     * <p>Currently the css selector locator supports all css1, css2 and css3 selectors except namespace in css3, some pseudo classes(:nth-of-type, :nth-last-of-type, :first-of-type, :last-of-type, :only-of-type, :visited, :hover, :active, :focus, :indeterminate) and pseudo elements(::first-line, ::first-letter, ::selection, ::before, ::after). </p>

     * </li>

     * </ul>

     *

     * <p>

     * Without an explicit locator prefix, Selenium uses the following default

     * strategies:

     * </p>

     *

     * <ul class="simple">

     * <li><strong>dom</strong>, for locators starting with &quot;document.&quot;</li>

     * <li><strong>xpath</strong>, for locators starting with &quot;//&quot;</li>

     * <li><strong>identifier</strong>, otherwise</li>

     * </ul>

     *

     * <h3><a name="element-filters">Element Filters</a></h3>

     * <blockquote>

     * <p>Element filters can be used with a locator to refine a list of candidate elements.  They are currently used only in the 'name' element-locator.</p>

     * <p>Filters look much like locators, ie.</p>

     * <blockquote>

     * <em>filterType</em><strong>=</strong><em>argument</em></blockquote>

     *

     * <p>Supported element-filters are:</p>

     * <p><strong>value=</strong><em>valuePattern</em></p>

     * <blockquote>

     * Matches elements based on their values.  This is particularly useful for refining a list of similarly-named toggle-buttons.</blockquote>

     * <p><strong>index=</strong><em>index</em></p>

     * <blockquote>

     * Selects a single element based on its position in the list (offset from zero).</blockquote>

     * </blockquote>

     *

     * <h3><a name="patterns"></a>String-match Patterns</h3>

     *

     * <p>

     * Various Pattern syntaxes are available for matching string values:

     * </p>

     * <ul>

     * <li><strong>glob:</strong><em>pattern</em>:

     * Match a string against a "glob" (aka "wildmat") pattern. "Glob" is a

     * kind of limited regular-expression syntax typically used in command-line

     * shells. In a glob pattern, "*" represents any sequence of characters, and "?"

     * represents any single character. Glob patterns match against the entire

     * string.</li>

     * <li><strong>regexp:</strong><em>regexp</em>:

     * Match a string using a regular-expression. The full power of JavaScript

     * regular-expressions is available.</li>

     * <li><strong>exact:</strong><em>string</em>:

     *

     * Match a string exactly, verbatim, without any of that fancy wildcard

     * stuff.</li>

     * </ul>

     * <p>

     * If no pattern prefix is specified, Selenium assumes that it's a "glob"

     * pattern.

     * </p>

     */

    this.browserbot = browserbot;

    this.optionLocatorFactory = new OptionLocatorFactory();

    // DGF for backwards compatibility

    this.page = function() {

        return browserbot;

    };

    this.defaultTimeout = Selenium.DEFAULT_TIMEOUT;

    this.mouseSpeed = 10;

}

Selenium.DEFAULT_TIMEOUT = 30 * 1000;

Selenium.DEFAULT_MOUSE_SPEED = 10;

Selenium.decorateFunctionWithTimeout = function(f, timeout) {

    if (f == null) {

        return null;

    }

    var timeoutValue = parseInt(timeout);

    if (isNaN(timeoutValue)) {

        throw new SeleniumError("Timeout is not a number: '" + timeout + "'");

    }

    var now = new Date().getTime();

    var timeoutTime = now + timeoutValue;

    return function() {

        if (new Date().getTime() > timeoutTime) {

            throw new SeleniumError("Timed out after " + timeoutValue + "ms");

        }

        return f();

    };

}

Selenium.createForWindow = function(window, proxyInjectionMode) {

    if (!window.location) {

        throw "error: not a window!";

    }

    return new Selenium(BrowserBot.createForWindow(window, proxyInjectionMode));

};

Selenium.prototype.reset = function() {

    this.defaultTimeout = Selenium.DEFAULT_TIMEOUT;

    // todo: this.browserbot.reset()

    this.browserbot.selectWindow("null");

    this.browserbot.resetPopups();

};

Selenium.prototype.doClick = function(locator) {

    /**

   * Clicks on a link, button, checkbox or radio button. If the click action

   * causes a new page to load (like a link usually does), call

   * waitForPageToLoad.

   *

   * @param locator an element locator

   *

   */

   var element = this.browserbot.findElement(locator);

   this.browserbot.clickElement(element);

};

Selenium.prototype.doDoubleClick = function(locator) {

    /**

   * Double clicks on a link, button, checkbox or radio button. If the double click action

   * causes a new page to load (like a link usually does), call

   * waitForPageToLoad.

   *

   * @param locator an element locator

   *

   */

   var element = this.browserbot.findElement(locator);

   this.browserbot.doubleClickElement(element);

};

Selenium.prototype.doClickAt = function(locator, coordString) {

    /**

   * Clicks on a link, button, checkbox or radio button. If the click action

   * causes a new page to load (like a link usually does), call

   * waitForPageToLoad.

   *

   * @param locator an element locator

   * @param coordString specifies the x,y position (i.e. - 10,20) of the mouse

   *      event relative to the element returned by the locator.

   *

   */

    var element = this.browserbot.findElement(locator);

    var clientXY = getClientXY(element, coordString)

    this.browserbot.clickElement(element, clientXY[0], clientXY[1]);

};

Selenium.prototype.doDoubleClickAt = function(locator, coordString) {

    /**

   * Doubleclicks on a link, button, checkbox or radio button. If the action

   * causes a new page to load (like a link usually does), call

   * waitForPageToLoad.

   *

   * @param locator an element locator

   * @param coordString specifies the x,y position (i.e. - 10,20) of the mouse

   *      event relative to the element returned by the locator.

   *

   */

    var element = this.browserbot.findElement(locator);

    var clientXY = getClientXY(element, coordString)

    this.browserbot.doubleClickElement(element, clientXY[0], clientXY[1]);

};

Selenium.prototype.doFireEvent = function(locator, eventName) {

    /**

   * Explicitly simulate an event, to trigger the corresponding &quot;on<em>event</em>&quot;

   * handler.

   *

   * @param locator an <a href="#locators">element locator</a>

   * @param eventName the event name, e.g. "focus" or "blur"

   */

    var element = this.browserbot.findElement(locator);

    triggerEvent(element, eventName, false);

};

Selenium.prototype.doKeyPress = function(locator, keySequence) {

    /**

   * Simulates a user pressing and releasing a key.

   *

   * @param locator an <a href="#locators">element locator</a>

   * @param keySequence Either be a string("\" followed by the numeric keycode

   *  of the key to be pressed, normally the ASCII value of that key), or a single

   *  character. For example: "w", "\119".

   */

    var element = this.browserbot.findElement(locator);

    triggerKeyEvent(element, 'keypress', keySequence, true,

        this.browserbot.controlKeyDown,

        this.browserbot.altKeyDown,

            this.browserbot.shiftKeyDown,

            this.browserbot.metaKeyDown);

};

Selenium.prototype.doShiftKeyDown = function() {

    /**

   * Press the shift key and hold it down until doShiftUp() is called or a new page is loaded.

   *

   */

   this.browserbot.shiftKeyDown = true;

};

Selenium.prototype.doShiftKeyUp = function() {

    /**

   * Release the shift key.

   *

   */

   this.browserbot.shiftKeyDown = false;

};

Selenium.prototype.doMetaKeyDown = function() {

    /**

   * Press the meta key and hold it down until doMetaUp() is called or a new page is loaded.

   *

   */

   this.browserbot.metaKeyDown = true;

};

Selenium.prototype.doMetaKeyUp = function() {

    /**

   * Release the meta key.

   *

   */

   this.browserbot.metaKeyDown = false;

};

Selenium.prototype.doAltKeyDown = function() {

    /**

   * Press the alt key and hold it down until doAltUp() is called or a new page is loaded.

   *

   */

   this.browserbot.altKeyDown = true;

};

Selenium.prototype.doAltKeyUp = function() {

    /**

   * Release the alt key.

   *

   */

   this.browserbot.altKeyDown = false;

};

Selenium.prototype.doControlKeyDown = function() {

    /**

   * Press the control key and hold it down until doControlUp() is called or a new page is loaded.

   *

   */

   this.browserbot.controlKeyDown = true;

};

Selenium.prototype.doControlKeyUp = function() {

    /**

   * Release the control key.

   *

   */

   this.browserbot.controlKeyDown = false;

};

Selenium.prototype.doKeyDown = function(locator, keySequence) {

    /**

   * Simulates a user pressing a key (without releasing it yet).

   *

   * @param locator an <a href="#locators">element locator</a>

   * @param keySequence Either be a string("\" followed by the numeric keycode

   *  of the key to be pressed, normally the ASCII value of that key), or a single

   *  character. For example: "w", "\119".

   */

    var element = this.browserbot.findElement(locator);

    triggerKeyEvent(element, 'keydown', keySequence, true,

        this.browserbot.controlKeyDown,

            this.browserbot.altKeyDown,

            this.browserbot.shiftKeyDown,

            this.browserbot.metaKeyDown);

};

Selenium.prototype.doKeyUp = function(locator, keySequence) {

    /**

   * Simulates a user releasing a key.

   *

   * @param locator an <a href="#locators">element locator</a>

   * @param keySequence Either be a string("\" followed by the numeric keycode

   *  of the key to be pressed, normally the ASCII value of that key), or a single

   *  character. For example: "w", "\119".

   */

    var element = this.browserbot.findElement(locator);

    triggerKeyEvent(element, 'keyup', keySequence, true,

        this.browserbot.controlKeyDown,

            this.browserbot.altKeyDown,

        this.browserbot.shiftKeyDown,

        this.browserbot.metaKeyDown);

};

function getClientXY(element, coordString) {

   // Parse coordString

   var coords = null;

   var x;

   var y;

   if (coordString) {

      coords = coordString.split(/,/);

      x = Number(coords[0]);

      y = Number(coords[1]);

   }

   else {

      x = y = 0;

   }

   // Get position of element,

   // Return 2 item array with clientX and clientY

   return [Selenium.prototype.getElementPositionLeft(element) + x, Selenium.prototype.getElementPositionTop(element) + y];

}

Selenium.prototype.doMouseOver = function(locator) {

    /**

   * Simulates a user hovering a mouse over the specified element.

   *

   * @param locator an <a href="#locators">element locator</a>

   */

    var element = this.browserbot.findElement(locator);

    this.browserbot.triggerMouseEvent(element, 'mouseover', true);

};

Selenium.prototype.doMouseOut = function(locator) {

   /**

   * Simulates a user moving the mouse pointer away from the specified element.

   *

   * @param locator an <a href="#locators">element locator</a>

   */

    var element = this.browserbot.findElement(locator);

    this.browserbot.triggerMouseEvent(element, 'mouseout', true);

};

Selenium.prototype.doMouseDown = function(locator) {

    /**

   * Simulates a user pressing the mouse button (without releasing it yet) on

   * the specified element.

   *

   * @param locator an <a href="#locators">element locator</a>

   */

   var element = this.browserbot.findElement(locator);

   this.browserbot.triggerMouseEvent(element, 'mousedown', true);

};

Selenium.prototype.doMouseDownAt = function(locator, coordString) {

    /**

   * Simulates a user pressing the mouse button (without releasing it yet) on

   * the specified element.

   *

   * @param locator an <a href="#locators">element locator</a>

   * @param coordString specifies the x,y position (i.e. - 10,20) of the mouse

   *      event relative to the element returned by the locator.

   */

    var element = this.browserbot.findElement(locator);

    var clientXY = getClientXY(element, coordString)

    this.browserbot.triggerMouseEvent(element, 'mousedown', true, clientXY[0], clientXY[1]);

};

Selenium.prototype.doMouseUp = function(locator) {

    /**

   * Simulates a user pressing the mouse button (without releasing it yet) on

   * the specified element.

   *

   * @param locator an <a href="#locators">element locator</a>

   */

   var element = this.browserbot.findElement(locator);

   this.browserbot.triggerMouseEvent(element, 'mouseup', true);

};

Selenium.prototype.doMouseUpAt = function(locator, coordString) {

    /**

   * Simulates a user pressing the mouse button (without releasing it yet) on

   * the specified element.

   *

   * @param locator an <a href="#locators">element locator</a>

   * @param coordString specifies the x,y position (i.e. - 10,20) of the mouse

   *      event relative to the element returned by the locator.

   */

    var element = this.browserbot.findElement(locator);

    var clientXY = getClientXY(element, coordString)

    this.browserbot.triggerMouseEvent(element, 'mouseup', true, clientXY[0], clientXY[1]);

};

Selenium.prototype.doMouseMove = function(locator) {

    /**

   * Simulates a user pressing the mouse button (without releasing it yet) on

   * the specified element.

   *

   * @param locator an <a href="#locators">element locator</a>

   */

   var element = this.browserbot.findElement(locator);

   this.browserbot.triggerMouseEvent(element, 'mousemove', true);

};

Selenium.prototype.doMouseMoveAt = function(locator, coordString) {

    /**

   * Simulates a user pressing the mouse button (without releasing it yet) on

   * the specified element.

   *

   * @param locator an <a href="#locators">element locator</a>

   * @param coordString specifies the x,y position (i.e. - 10,20) of the mouse

   *      event relative to the element returned by the locator.

   */

    var element = this.browserbot.findElement(locator);

    var clientXY = getClientXY(element, coordString)

    this.browserbot.triggerMouseEvent(element, 'mousemove', true, clientXY[0], clientXY[1]);

};

Selenium.prototype.doType = function(locator, value) {

    /**

   * Sets the value of an input field, as though you typed it in.

   *

   * <p>Can also be used to set the value of combo boxes, check boxes, etc. In these cases,

   * value should be the value of the option selected, not the visible text.</p>

   *

   * @param locator an <a href="#locators">element locator</a>

   * @param value the value to type

   */

   if (this.browserbot.controlKeyDown || this.browserbot.altKeyDown || this.browserbot.metaKeyDown) {

        throw new SeleniumError("type not supported immediately after call to controlKeyDown() or altKeyDown() or metaKeyDown()");

    }

        // TODO fail if it can't be typed into.

    var element = this.browserbot.findElement(locator);

    if (this.browserbot.shiftKeyDown) {

        value = new String(value).toUpperCase();

    }

    this.browserbot.replaceText(element, value);

};

Selenium.prototype.doTypeKeys = function(locator, value) {

    /**

    * Simulates keystroke events on the specified element, as though you typed the value key-by-key.

    *

    * <p>This is a convenience method for calling keyDown, keyUp, keyPress for every character in the specified string;

    * this is useful for dynamic UI widgets (like auto-completing combo boxes) that require explicit key events.</p>

    *

    * <p>Unlike the simple "type" command, which forces the specified value into the page directly, this command

    * may or may not have any visible effect, even in cases where typing keys would normally have a visible effect.

    * For example, if you use "typeKeys" on a form element, you may or may not see the results of what you typed in

    * the field.</p>

    * <p>In some cases, you may need to use the simple "type" command to set the value of the field and then the "typeKeys" command to

    * send the keystroke events corresponding to what you just typed.</p>

    *

    * @param locator an <a href="#locators">element locator</a>

    * @param value the value to type

    */

    var keys = new String(value).split("");

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

        var c = keys[i];

        this.doKeyDown(locator, c);

        this.doKeyUp(locator, c);

        this.doKeyPress(locator, c);

    }

};

Selenium.prototype.doSetSpeed = function(value) {

 /**

 * Set execution speed (i.e., set the millisecond length of a delay which will follow each selenium operation).  By default, there is no such delay, i.e.,

 * the delay is 0 milliseconds.

   *

   * @param value the number of milliseconds to pause after operation

   */

   throw new SeleniumError("this operation is only implemented in selenium-rc, and should never result in a request making it across the wire");

};

Selenium.prototype.doGetSpeed = function() {

 /**

 * Get execution speed (i.e., get the millisecond length of the delay following each selenium operation).  By default, there is no such delay, i.e.,

 * the delay is 0 milliseconds.

   *

   * See also setSpeed.

   */

   throw new SeleniumError("this operation is only implemented in selenium-rc, and should never result in a request making it across the wire");

};

Selenium.prototype.findToggleButton = function(locator) {

    var element = this.browserbot.findElement(locator);

    if (element.checked == null) {

        Assert.fail("Element " + locator + " is not a toggle-button.");

    }

    return element;

}

Selenium.prototype.doCheck = function(locator) {

    /**

   * Check a toggle-button (checkbox/radio)

   *

   * @param locator an <a href="#locators">element locator</a>

   */

    this.findToggleButton(locator).checked = true;

};

Selenium.prototype.doUncheck = function(locator) {

    /**

   * Uncheck a toggle-button (checkbox/radio)

   *

   * @param locator an <a href="#locators">element locator</a>

   */

    this.findToggleButton(locator).checked = false;

};

Selenium.prototype.doSelect = function(selectLocator, optionLocator) {

    /**

   * Select an option from a drop-down using an option locator.

   *

   * <p>

   * Option locators provide different ways of specifying options of an HTML

   * Select element (e.g. for selecting a specific option, or for asserting

   * that the selected option satisfies a specification). There are several

   * forms of Select Option Locator.

   * </p>

   * <ul>

   * <li><strong>label</strong>=<em>labelPattern</em>:

   * matches options based on their labels, i.e. the visible text. (This

   * is the default.)

   * <ul class="first last simple">

   * <li>label=regexp:^[Oo]ther</li>

   * </ul>

   * </li>

   * <li><strong>value</strong>=<em>valuePattern</em>:

   * matches options based on their values.

   * <ul class="first last simple">

   * <li>value=other</li>

   * </ul>

   *

   *

   * </li>

   * <li><strong>id</strong>=<em>id</em>:

   *

   * matches options based on their ids.

   * <ul class="first last simple">

   * <li>id=option1</li>

   * </ul>

   * </li>

   * <li><strong>index</strong>=<em>index</em>:

   * matches an option based on its index (offset from zero).

   * <ul class="first last simple">

   *

   * <li>index=2</li>

   * </ul>

   * </li>

   * </ul>

   * <p>

   * If no option locator prefix is provided, the default behaviour is to match on <strong>label</strong>.

   * </p>

   *

   *

   * @param selectLocator an <a href="#locators">element locator</a> identifying a drop-down menu

   * @param optionLocator an option locator (a label by default)

   */

    var element = this.browserbot.findElement(selectLocator);

    if (!("options" in element)) {

        throw new SeleniumError("Specified element is not a Select (has no options)");

    }

    var locator = this.optionLocatorFactory.fromLocatorString(optionLocator);

    var option = locator.findOption(element);

    this.browserbot.selectOption(element, option);

};

Selenium.prototype.doAddSelection = function(locator, optionLocator) {

    /**

   * Add a selection to the set of selected options in a multi-select element using an option locator.

   *

   * @see #doSelect for details of option locators

   *

   * @param locator an <a href="#locators">element locator</a> identifying a multi-select box

   * @param optionLocator an option locator (a label by default)

   */

    var element = this.browserbot.findElement(locator);

    if (!("options" in element)) {

        throw new SeleniumError("Specified element is not a Select (has no options)");

    }

    var locator = this.optionLocatorFactory.fromLocatorString(optionLocator);

    var option = locator.findOption(element);

    this.browserbot.addSelection(element, option);

};

Selenium.prototype.doRemoveSelection = function(locator, optionLocator) {

    /**

   * Remove a selection from the set of selected options in a multi-select element using an option locator.

   *

   * @see #doSelect for details of option locators

   *

   * @param locator an <a href="#locators">element locator</a> identifying a multi-select box

   * @param optionLocator an option locator (a label by default)

   */

    var element = this.browserbot.findElement(locator);

    if (!("options" in element)) {

        throw new SeleniumError("Specified element is not a Select (has no options)");

    }

    var locator = this.optionLocatorFactory.fromLocatorString(optionLocator);

    var option = locator.findOption(element);

    this.browserbot.removeSelection(element, option);

};

Selenium.prototype.doRemoveAllSelections = function(locator) {

    /**

    * Unselects all of the selected options in a multi-select element.

    *

    * @param locator an <a href="#locators">element locator</a> identifying a multi-select box

    */

    var element = this.browserbot.findElement(locator);

    if (!("options" in element)) {

        throw new SeleniumError("Specified element is not a Select (has no options)");

    }

    for (var i = 0; i < element.options.length; i++) {

        this.browserbot.removeSelection(element, element.options[i]);

    }

}

Selenium.prototype.doSubmit = function(formLocator) {

    /**

   * Submit the specified form. This is particularly useful for forms without

   * submit buttons, e.g. single-input "Search" forms.

   *

   * @param formLocator an <a href="#locators">element locator</a> for the form you want to submit

   */

    var form = this.browserbot.findElement(formLocator);

    return this.browserbot.submit(form);

};

Selenium.prototype.makePageLoadCondition = function(timeout) {

    if (timeout == null) {

        timeout = this.defaultTimeout;

    }

    return Selenium.decorateFunctionWithTimeout(fnBind(this._isNewPageLoaded, this), timeout);

};

Selenium.prototype.doOpen = function(url) {

    /**

   * Opens an URL in the test frame. This accepts both relative and absolute

   * URLs.

   *

   * The "open" command waits for the page to load before proceeding,

   * ie. the "AndWait" suffix is implicit.

   *

   * <em>Note</em>: The URL must be on the same domain as the runner HTML

   * due to security restrictions in the browser (Same Origin Policy). If you

   * need to open an URL on another domain, use the Selenium Server to start a

   * new browser session on that domain.

   *

   * @param url the URL to open; may be relative or absolute

   */

    this.browserbot.openLocation(url);

    return this.makePageLoadCondition();

};

Selenium.prototype.doOpenWindow = function(url, windowID) {

    /**

   * Opens a popup window (if a window with that ID isn't already open).

   * After opening the window, you'll need to select it using the selectWindow

   * command.

   *

   * <p>This command can also be a useful workaround for bug SEL-339.  In some cases, Selenium will be unable to intercept a call to window.open (if the call occurs during or before the "onLoad" event, for example).

   * In those cases, you can force Selenium to notice the open window's name by using the Selenium openWindow command, using

   * an empty (blank) url, like this: openWindow("", "myFunnyWindow").</p>

   *

   * @param url the URL to open, which can be blank

   * @param windowID the JavaScript window ID of the window to select

   */

   this.browserbot.openWindow(url, windowID);

};

Selenium.prototype.doSelectWindow = function(windowID) {

    /**

   * Selects a popup window; once a popup window has been selected, all

   * commands go to that window. To select the main window again, use null

   * as the target.

   *

   * <p>Selenium has several strategies for finding the window object referred to by the "windowID" parameter.</p>

   *

   * <p>1.) if windowID is null, then it is assumed the user is referring to the original window instantiated by the browser).</p>

   * <p>2.) if the value of the "windowID" parameter is a JavaScript variable name in the current application window, then it is assumed

   * that this variable contains the return value from a call to the JavaScript window.open() method.</p>

   * <p>3.) Otherwise, selenium looks in a hash it maintains that maps string names to window objects.  Each of these string

   * names matches the second parameter "windowName" past to the JavaScript method  window.open(url, windowName, windowFeatures, replaceFlag)

   * (which selenium intercepts).</p>

   *

   * <p>If you're having trouble figuring out what is the name of a window that you want to manipulate, look at the selenium log messages

   * which identify the names of windows created via window.open (and therefore intercepted by selenium).  You will see messages

   * like the following for each window as it is opened:</p>

   *

   * <p><code>debug: window.open call intercepted; window ID (which you can use with selectWindow()) is "myNewWindow"</code></p>

   *

   * <p>In some cases, Selenium will be unable to intercept a call to window.open (if the call occurs during or before the "onLoad" event, for example).

   * (This is bug SEL-339.)  In those cases, you can force Selenium to notice the open window's name by using the Selenium openWindow command, using

   * an empty (blank) url, like this: openWindow("", "myFunnyWindow").</p>

   *

   * @param windowID the JavaScript window ID of the window to select

   */

    this.browserbot.selectWindow(windowID);

};

Selenium.prototype.doSelectFrame = function(locator) {

    /**

    * Selects a frame within the current window.  (You may invoke this command

    * multiple times to select nested frames.)  To select the parent frame, use

    * "relative=parent" as a locator; to select the top frame, use "relative=top".

    *

    * <p>You may also use a DOM expression to identify the frame you want directly,

    * like this: <code>dom=frames["main"].frames["subframe"]</code></p>

    *

    * @param locator an <a href="#locators">element locator</a> identifying a frame or iframe

    */

        this.browserbot.selectFrame(locator);

};

Selenium.prototype.getLogMessages = function() {

    /**

        * Return the contents of the log.

    *

        * <p>This is a placeholder intended to make the code generator make this API

        * available to clients.  The selenium server will intercept this call, however,

        * and return its recordkeeping of log messages since the last call to this API.

        * Thus this code in JavaScript will never be called.</p>

        *

        * <p>The reason I opted for a servercentric solution is to be able to support

        * multiple frames served from different domains, which would break a

        * centralized JavaScript logging mechanism under some conditions.</p>

    *

        * @return string all log messages seen since the last call to this API

    */

        return "getLogMessages should be implemented in the selenium server";

};

Selenium.prototype.getWhetherThisFrameMatchFrameExpression = function(currentFrameString, target) {

    /**

     * Determine whether current/locator identify the frame containing this running code.

     *

     * <p>This is useful in proxy injection mode, where this code runs in every

     * browser frame and window, and sometimes the selenium server needs to identify

     * the "current" frame.  In this case, when the test calls selectFrame, this

     * routine is called for each frame to figure out which one has been selected.

     * The selected frame will return true, while all others will return false.</p>

     *

     * @param currentFrameString starting frame

     * @param target new frame (which might be relative to the current one)

     * @return boolean true if the new frame is this code's window

     */

    var isDom = false;

    if (target.indexOf("dom=") == 0) {

        target = target.substr(4);

        isDom = true;

    }

    var t;

    try {

        eval("t=" + currentFrameString + "." + target);

    } catch (e) {

    }

    var autWindow = this.browserbot.getCurrentWindow();

    if (t != null) {

        if (t.window == autWindow) {

            return true;

        }

        return false;

    }

    if (isDom) {

        return false;

    }

    var currentFrame;

    eval("currentFrame=" + currentFrameString);

    if (target == "relative=up") {

        if (currentFrame.window.parent == autWindow) {

            return true;

        }

        return false;

    }

    if (target == "relative=top") {

        if (currentFrame.window.top == autWindow) {

            return true;

        }

        return false;

    }

    if (autWindow.name == target && currentFrame.window == autWindow.parent) {

        return true;

    }

    return false;

};

Selenium.prototype.getWhetherThisWindowMatchWindowExpression = function(currentWindowString, target) {

    /**

    * Determine whether currentWindowString plus target identify the window containing this running code.

     *

     * <p>This is useful in proxy injection mode, where this code runs in every

     * browser frame and window, and sometimes the selenium server needs to identify

     * the "current" window.  In this case, when the test calls selectWindow, this

     * routine is called for each window to figure out which one has been selected.

     * The selected window will return true, while all others will return false.</p>

     *

     * @param currentWindowString starting window

     * @param target new window (which might be relative to the current one, e.g., "_parent")

     * @return boolean true if the new window is this code's window

     */

     if (window.opener!=null && window.opener[target]!=null && window.opener[target]==window) {

         return true;

     }

     return false;

};

Selenium.prototype.doWaitForPopUp = function(windowID, timeout) {

    /**

    * Waits for a popup window to appear and load up.

    *

    * @param windowID the JavaScript window ID of the window that will appear

    * @param timeout a timeout in milliseconds, after which the action will return with an error

    */

    var popupLoadedPredicate = function () {

        var targetWindow = selenium.browserbot.getWindowByName(windowID, true);

        if (!targetWindow) return false;

        if (!targetWindow.location) return false;

        if ("about:blank" == targetWindow.location) return false;

        if (browserVersion.isKonqueror) {

            if ("/" == targetWindow.location.href) {

                // apparently Konqueror uses this as the temporary location, instead of about:blank

                return false;

            }

        }

        if (browserVersion.isSafari) {

            if(targetWindow.location.href == selenium.browserbot.buttonWindow.location.href) {

                // Apparently Safari uses this as the temporary location, instead of about:blank

                // what a world!

                LOG.debug("DGF what a world!");

                return false;

            }

        }

        if (!targetWindow.document) return false;

        if (!selenium.browserbot.getCurrentWindow().document.readyState) {

            // This is Firefox, with no readyState extension

            return true;

        }

        if ('complete' != targetWindow.document.readyState) return false;

        return true;

    };

    return Selenium.decorateFunctionWithTimeout(popupLoadedPredicate, timeout);

}

Selenium.prototype.doWaitForPopUp.dontCheckAlertsAndConfirms = true;

Selenium.prototype.doChooseCancelOnNextConfirmation = function() {

    /**

   * By default, Selenium's overridden window.confirm() function will

   * return true, as if the user had manually clicked OK.  After running

   * this command, the next call to confirm() will return false, as if

   * the user had clicked Cancel.

   *

   */

    this.browserbot.cancelNextConfirmation();

};

Selenium.prototype.doAnswerOnNextPrompt = function(answer) {

    /**

   * Instructs Selenium to return the specified answer string in response to

   * the next JavaScript prompt [window.prompt()].

   *

   *

   * @param answer the answer to give in response to the prompt pop-up

   */

    this.browserbot.setNextPromptResult(answer);

};

Selenium.prototype.doGoBack = function() {

    /**

     * Simulates the user clicking the "back" button on their browser.

     *

     */

    this.browserbot.goBack();

};

Selenium.prototype.doRefresh = function() {

    /**

     * Simulates the user clicking the "Refresh" button on their browser.

     *

     */

    this.browserbot.refresh();

};

Selenium.prototype.doClose = function() {

    /**

     * Simulates the user clicking the "close" button in the titlebar of a popup

     * window or tab.

     */

    this.browserbot.close();

};

Selenium.prototype.ensureNoUnhandledPopups = function() {

    if (this.browserbot.hasAlerts()) {

        throw new SeleniumError("There was an unexpected Alert! [" + this.browserbot.getNextAlert() + "]");

    }

    if ( this.browserbot.hasConfirmations() ) {

        throw new SeleniumError("There was an unexpected Confirmation! [" + this.browserbot.getNextConfirmation() + "]");

    }

};