S/W Testing Experience: 2009

Monday, October 12, 2009

DefaultSelenium Class
Defines an object that runs Selenium commands.
Element Locators

Element Locators tell Selenium which HTML element a command refers to. The format of a locator is:

locatorType=argument

We support the following strategies for locating elements:

* identifier=id: Select the element with the specified @id attribute. If no match is found, select the first element whose @name attribute is id. (This is normally the default; see below.)
* id=id: Select the element with the specified @id attribute.
* name=name: Select the first element with the specified @name attribute.
o username
o name=username

The name may optionally be followed by one or more element-filters, separated from the name by whitespace. If the filterType is not specified, value is assumed.
o name=flavour value=chocolate
* dom=javascriptExpression: 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.
o dom=document.forms['myForm'].myDropdown
o dom=document.images[56]
o dom=function foo() { return document.links[1]; }; foo();
* xpath=xpathExpression: Locate an element using an XPath expression.
o xpath=//img[@alt='The image alt text']
o xpath=//table[@id='table1']//tr[4]/td[2]
o xpath=//a[contains(@href,'#id1')]
o xpath=//a[contains(@href,'#id1')]/@class
o xpath=(//table[@class='stylee'])//th[text()='theHeaderText']/../td
o xpath=//input[@name='name2' and @value='yes']
o xpath=//*[text()="right"]
* link=textPattern: Select the link (anchor) element which contains text matching the specified pattern.
o link=The link text
* css=cssSelectorSyntax: Select the element using css selectors. Please refer to CSS2 selectors,http://www.w3.org/TR/2001/CR-css3-selectors-20011113/ CSS3 selectors 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.
o css=a[href="#id3"]
o css=span#firstChild + span

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

Without an explicit locator prefix, Selenium uses the following default strategies:

* dom, for locators starting with "document."
* xpath, for locators starting with "//"
* identifier, otherwise

Element Filters

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.

Filters look much like locators, ie.

filterType=argument

Supported element-filters are:

value=valuePattern

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

index=index

Selects a single element based on its position in the list (offset from zero).

String-match Patterns

Various Pattern syntaxes are available for matching string values:

* glob:pattern: 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.
* regexp:regexp: Match a string using a regular-expression. The full power of JavaScript regular-expressions is available.
* exact:string: Match a string exactly, verbatim, without any of that fancy wildcard stuff.

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

For a list of all members of this type, see DefaultSelenium Members.

System.Object

Wednesday, October 7, 2009

Commads for attributes

To store Source url of an image
storeAttribute //img[@alt='My Photo']@src imagePath
open ${imagePath}
Ex:

storeAttribute
//img[@alt='My Photo']@src
imagePath

open
${imagePath}
-------------------------------

1. Identified Element by its text using Contains

Ex. //a[contains(text(),'Documentation')]

storeAttribute

//a[contains(text(),'Documentation')]

Documentation
2. Get attribute of Element using storeAttribute function

Ex. //a[contains(text(),'Classic Home')]@href

storeAttribute

//a[contains(text(),'Classic Home')]@href

Documentation

Ex. //div[@id='guser']/nobr/a[2]@href

storeAttribute

//div[@id='guser']/nobr/a[2]@href

Documentation
3. Identified Element by its Atrribute

Ex. //a[@onclick='']

Ex. //div[@id='guser']/nobr/a[2]

Ex. //div/div[position()='1' and@style='font-size: 80%;']/a[position()='2' and @href='/search']

Ex. //input[@id='q' and @type ='text']
4. Locating by Identifier

This is probably the most common method of locating elements and is the catch-all default when no recognised locator type is used. With this strategy, the first element with the id attribute value matching the location will be used. If no element has a matching id attribute, then the first element with an name attribute matching the location will be used.

For instance, your page source could have id and name attributes as follows:
1 html

2 body

3 form id="loginForm"

4 input name="username" type="text" /

5 input name="password" type="password" /

6 input name="password" type="password" /

7 input name="continue" type="submit" value="Login" /

8 input name="continue" type="button" value="Clear" /

9 /form

10 /body

11 html

The following locator strategies would return the elements from the HTML snippet above indicated by line number:

* identifier=loginForm (3)
* identifier=username (4)
* identifier=continue (5)
* continue (5)

Since the identifier type of locator is the default, the identifier= in the first three examples above is not necessary.
Locating by Id¶

This type of locator is more limited than the identifier locator type, but also more explicit. Use this when you know an element’s id attribute.

1 html

2 body

3 form id="loginForm"

4 input name="username" type="text" /

5 input name="password" type="password" /

6 input name="password" type="password" /

7 input name="continue" type="submit" value="Login" /

8 input name="continue" type="button" value="Clear" /

9 /form

10 /body

11 html

* id=loginForm (3)

Locating by Name¶

The name locator type will locate the first element with a matching name attribute. If multiple elements have the same value for a name attribute, then you can use filters to further refine your location strategy. The default filter type is value (matching the value attribute).

1 html

2 body

3 form id="loginForm"

4 input name="username" type="text" /

5 input name="password" type="password" /

6 input name="password" type="password" /

7 input name="continue" type="submit" value="Login" /

8 input name="continue" type="button" value="Clear" /

9 /form

10 /body

11 html

* name=username (4)
* name=continue value=Clear (8)
* name=continue Clear (8)
* name=continue type=button (7)

Note

Unlike some types of XPath and DOM locators, the three types of locators above allow Selenium to test a UI element independent of its location on the page. So if the page structure and organization is altered, the test will still pass. One may or may not want to also test whether the page structure changes. In the case where web designers frequently alter the page, but its functionality must be regression tested, testing via id and name attributes, or really via any HTML property, becomes very important.
Locating UI element by XPath

XPath is the language used for locating nodes in an XML document. As HTML can be an implementation of XML (XHTML), Selenium users can leverage this powerful language to target elements in their web applications. XPath extends beyond (as well as supporting) the simple methods of locating by id or name attributes, and opens up all sorts of new possibilities such as locating the third checkbox on the page.

One of the main reasons for using XPath is when you don’t have a suitable id or name attribute for the element you wish to locate. You can use XPath to either locate the element in absolute terms (not advised), or relative to an element that does have an id or name attribute. XPath locators can also be used to specify elements via attributes other than id and name.

Absolute XPaths contain the location of all elements from the root (html) and as a result are likely to fail with only the slightest adjustment to the application. By finding a nearby element with an id or name attribute (ideally a parent element) you can locate your target element based on the relationship. This is much less likely to change and can make your tests more robust.

Since only xpath locators start with “//”, it is not necessary to include the xpath= label when specifying an XPath locator.
1 html

2 body

3 form id="loginForm"

4 input name="username" type="text" /

5 input name="password" type="password" /

6 input name="password" type="password" /

7 input name="continue" type="submit" value="Login" /

8 input name="continue" type="button" value="Clear" /

9 /form

10 /body

11 html

* xpath=/html/body/form[1] (3) – Absolute path (would break if the HTML was changed only slightly)
* //form[1] (3) – First form element in the HTML
* xpath=//form[@id='loginForm'] (3) – The form element with @id of ‘loginForm’
* xpath=//form[input/\@name='username'] (4) – First form element with an input child element with @name of ‘username’
* //input[@name='username'] (4) – First input element with @name of ‘username’
* //form[@id='loginForm']/input[1] (4) – First input child element of the form element with @id of ‘loginForm’
* //input[@name='continue'][@type='button'] (7) – Input with @name ‘continue’ and @type of ‘button’
* //form[@id='loginForm']/input[4] (7) – Fourth input child element of the form element with @id of ‘loginForm’
* Expresion in square brackets can further specify an element. A number in the brackets gives the position of the element in the selected set. The function last() selects the last element in the selection.

Locating elment using XPath

XPath is the language used for locating nodes in an XML document. As HTML can be an implementation of XML (XHTML), Selenium users can leverage this powerful language to target elements in their web applications. XPath extends beyond (as well as supporting) the simple methods of locating by id or name attributes, and opens up all sorts of new possibilities such as locating the third checkbox on the page.

One of the main reasons for using XPath is when you don’t have a suitable id or name attribute for the element you wish to locate. You can use XPath to either locate the element in absolute terms (not advised), or relative to an element that does have an id or name attribute. XPath locators can also be used to specify elements via attributes other than id and name.

Absolute XPaths contain the location of all elements from the root (html) and as a result are likely to fail with only the slightest adjustment to the application. By finding a nearby element with an id or name attribute (ideally a parent element) you can locate your target element based on the relationship. This is much less likely to change and can make your tests more robust.

Since only xpath locators start with “//”, it is not necessary to include the xpath= label when specifying an XPath locator.

1

2

3

4

5

6

7

8

9

10

* xpath=/html/body/form[1] (3) – Absolute path (would break if the HTML was changed only slightly)
* //form[1] (3) – First form element in the HTML
* xpath=//form[@id='loginForm'] (3) – The form element with @id of ‘loginForm’
* xpath=//form[input/\@name='username'] (4) – First form element with an input child element with @name of ‘username’
* //input[@name='username'] (4) – First input element with @name of ‘username’
* //form[@id='loginForm']/input[1] (4) – First input child element of the form element with @id of ‘loginForm’
* //input[@name='continue'][@type='button'] (7) – Input with @name ‘continue’ and @type of ‘button’
* //form[@id='loginForm']/input[4] (7) – Fourth input child element of the form element with @id of ‘loginForm’
* Expresion in square brackets can further specify an element. A number in the brackets gives the position of the element in the selected set. The function last() selects the last element in the selection.

/AAA/BBB[1]
Select the first BBB child of element AAA

/AAA/BBB[last()]
Select the last BBB child of element AAA

Attributes are specified by @ prefix.

//@id
Select all attributes @id

//BBB[@id]
Select BBB elements which have attribute id

//BBB[@name]
Select BBB elements which have attribute name

//BBB[@*]
Select BBB elements which have any attribute

//BBB[not(@*)]
Select BBB elements without an attribute

Values of attributes can be used as selection criteria. Function normalize-space removes leading and trailing spaces and replaces sequences of whitespace characters by a single space.

//BBB[@id='b1']
Select BBB elements which have attribute id with value b1

//BBB[normalize-space(@name)='bbb']
Select BBB elements which have attribute name with value bbb, leading and trailing spaces are removed before comparison

Function count() counts the number of selected elements

//*[count(BBB)=2]
Select elements which have two children BBB

//*[count(*)=2]
Select elements which have 2 children

Function name() returns name of the element, the starts-with function returns true if the first argument string starts with the second argument string, and the contains function returns true if the first argument string contains the second argument string.

//*[name()='BBB']
Select all elements with name BBB, equivalent with //BBB

//*[starts-with(name(),'B')]
Select all elements name of which starts with letter B

//*[contains(name(),'C')]
Select all elements name of which contain letter C

< BBB />
< BBB />

< BBB />
< BBB />

The string-length function returns the number of characters in the string. You must use < as a substitute for < and > as a substitute for > .

//*[string-length(name()) = 3]
Select elements with three-letter name

Several paths can be combined with | separator.

//CCC | //BBB
Select all elements CCC and BBB

/AAA/EEE | //BBB
Select all elements BBB and elements EEE which are children of root element AAA

/AAA/EEE | //DDD/CCC | /AAA | //BBB
Number of combinations is not restricted

selenium uses XpathLibrary(".....")

selenium.useXpathLibrary has no impact on Firefox as there is a native XPath implementation available that is used by default (and btw it is also not possible to switch from native to javascript-xpath).

Regarding your page. Not only IDs are increasing XPath performance but also name and a single class field. So the XPathes

//div[@name='nameValue']

//div[@class='cssClass']

should also be performant as javascript-xpath uses document.getElementsByName() and document.getElementsByClassName() in this case. But I never tried this until now as our app always has some useful IDs (it's a Dojo app and Dojo adds some IDs), I only saw this in the source of javascript-xpath.

But I have another performance tipp - something that I am also doing in many cases. Following HTML:

...

....

...

Title 1

Title 2

We are having here a DOM with two forms (I did not include all the inputs that are in there, just something ...). The two forms are equal - something that is happening more and more offen in Web 2.0 applications where the end-user selects which content he wants to display on a page. A typical example is a weather widget that displays weather information for one location. But as users are interested in the weather in their hometown but also of there favorite holiday location they are placing the same widget two times on one page. This is difficult to differentiate when using XPathes. E. g. to access form elements we need to use the XPath:

//body/div[starts-with(@id, 'generatedId']/h2[.='Title 1']/../form/input[@name='zipCode']

//body/div[starts-with(@id, 'generatedId']/h2[.='Title 2']/../form/input[@name='zipCode']

But these are very inperformant. Especially if you need to fill other input fields and click a button and verify that some things happend you will run into hard performance issues on Internet Explorer. Therefore we need to first get the generated id and then continue:

String idTitle1 = selenium.getAttribute("//body/div[starts-with(@id, 'generatedId']/h2[.='Title 1']/..@id");

selenium.type("//div[id='" + idTitle1 + "']/form/input[@name='zipCode']", "12345");

...

Unfortunately that seems not to be something for your site but for the Selenium documentation.

Monday, May 4, 2009

Testing Ajax Applications with Selenium

AJAX, stands for Asynchronous JavaScript and XML, is a web development technique for developing intractive web application that makes

web applicaton fast and more responsive by exchanging data with the server.

For loading a page time is not fixed.(i.e 200 ms or 20 secs.) Ajax avoid reloading the page. Browser sends the request to server and refreshs the small part of

current page.This reduces the time between sending the request and seeing the result on the page because it saves time takes by reloading the entire page.

Gmail is the prefect example of Ajax.

When we click on arrow it does not reload entire page instead it refresh the web clicp header only.

Suppose we have an web application cotaining one text field and button. Once we click on the button text field reflectes with the result comes from the server.

In some case pause will work but its not a permanent workaround because we dont know how much time server will take to respond. It might repsond withing millseconds or might respond in more than 20 secs.

When selenium does not how long to wait for the result then how can we test these kind of application.

Wait For It...

So how do we get Selenium to wait for the result? One way to solve the problem is to use the clickAndWait command instead of click; the "AndWait" suffix indicates that Selenium should wait for a page-reload. This might seem like it would work, but there's a catch: because the page is not reloaded, clickAndWait will make Selenium keep waiting forever. This clearly isn't going to work.

Fortunately Selenium has provided support for doing exactly what we want. When a field value changes in the current page, you can use the waitForValue command to make Selenium wait until the expected value appears.

When executing this command, Selenium will suspend the execution of current test case and wait for the expected value. When the string "newValue" appears in the text field, the suspended test will go on. One thing to note: if you misspelled the expected value, Selenium will wait for 30 seconds before timing out.

As you may have already guessed, there are lots more commands that can be used to test Ajax effects. For example, if you want to check some plain text updated with Ajax, there's waitForText; if you want to check the title of current page, there's waitForTitle; if you want to verify that an HTML element is removed, there's waitForElementNotPresent. Actually, for every Selenium Accessor, there is a waitForXxxx and a waitForNotXxxx commands corresponding. Whenever you use verifyXxxx or assertXxxx to check something, there will always be a waitForXxxx for testing asynchronous effects.

What happens if the predefined waitForXxxx and waitForNotXxxx commands don't meet your needs? Well for this there is the waitForCondition command which allows you to specify a Boolean expression in Javascript which causes Selenium to wait until the expression evaluates to true

How to use XPath

XPath

XPath is a small language that describes the path to parts of a web page or path of an element on the webpage. Selenium uses it to perform an action on an element on the page by idientifying them.
Like. Clicking on buttons, Filling any text field.
XPath is a very useful for selenium to idnetify an element.
Brian Slesinsky has a great tool called XPath Checker for Firefox. Its a free plugin, that is well worth installing into Firefox.
There is one of the widely used tool firebug for firefox. It allows us to inspect the elements runtime.

We can instruct selenium to identify an element on the page according to consistency and maintainabilty of our webpage.

# xpath=xpathExpression: Locate an element using an XPath expression.

* xpath=//img[@alt='The image alt text']
ex.

click
xpath=//img[@alt='Click me']

Selenium will click a link having alt value "Click me" on the page.

* xpath=//a[contains(text(),'Images')]

open
http://www.google.co.in/

assertTitle
Google

clickAndWait
xpath=//a[contains(text(),'Images')]

Selenium will click a link having text value "Click me" on the google.co.in.

* xpath=//input[@name='name2' and @value='yes']
when the element does not have unique identifcation then we can instruct selenium to identify the element with the combination of multiple attributes.

click
xpath=//button[@calss="Btn" and @type="submit"]

Selenium Commands List

Concepts

A command is what tells Selenium what to do. Selenium commands come in three 'flavors': Actions, Accessors and Assertions. Each command call is one line in the test table of the form:

command target value

Actions are commands that generally manipulate the state of the application. They do things like "click this link" and "select that option". If an Action fails, or has an error, the execution of the current test is stopped.

Many Actions can be called with the "AndWait" suffix, e.g. "clickAndWait". This suffix tells Selenium that the action will cause the browser to make a call to the server, and that Selenium should wait for a new page to load.

Accessors examine the state of the application and store the results in variables, e.g. "storeTitle". They are also used to automatically generate Assertions.

Assertions are like Accessors, but they verify that the state of the application conforms to what is expected. Examples include "make sure the page title is X" and "verify that this checkbox is checked".

All Selenium Assertions can be used in 3 modes: "assert", "verify", and "waitFor". For example, you can "assertText", "verifyText" and "waitForText". When an "assert" fails, the test is aborted. When a "verify" fails, the test will continue execution, logging the failure. This allows a single "assert" to ensure that the application is on the correct page, followed by a bunch of "verify" assertions to test form field values, labels, etc.

"waitFor" commands wait for some condition to become true (which can be useful for testing Ajax applications). They will succeed immediately if the condition is already true. However, they will fail and halt the test if the condition does not become true within the current timeout setting (see the setTimeout action below).

Element Locators tell Selenium which HTML element a command refers to. Many commands require an Element Locator as the "target" attribute. Examples of Element Locators include "elementId" and "document.forms[0].element". These are described more clearly in the next section.

Patterns are used for various reasons, e.g. to specify the expected value of an input field, or identify a select option. Selenium supports various types of pattern, including regular-expressions, all of which are described in more detail below.

Defines an object that runs Selenium commands.

Element Locators

Element Locators tell Selenium which HTML element a command refers to. The format of a locator is:

locatorType=argument

We support the following strategies for locating elements:

identifier=id: Select the element with the specified @id attribute. If no match is found, select the first element whose @name attribute is id. (This is normally the default; see below.)
id=id: Select the element with the specified @id attribute.
name=name: Select the first element with the specified @name attribute.
- username
- name=username
The name may optionally be followed by one or more element-filters, separated from the name by whitespace. If the filterType is not specified, value is assumed.
- name=flavour value=chocolate
dom=javascriptExpression: 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.
- dom=document.forms['myForm'].myDropdown
- dom=document.images[56]
- dom=function foo() { return document.links[1]; }; foo();
XPath=xpathExpression: Locate an element using an XPath expression.
- xpath=//img[@alt='The image alt text']
- xpath=//table[@id='table1']//tr[4]/td[2]
- xpath=//a[contains(@href,'#id1')]
- xpath=//a[contains(@href,'#id1')]/@class
- xpath=(//table[@class='stylee'])//th[text()='theHeaderText']/../td
- xpath=//input[@name='name2' and @value='yes']
- xpath=//*[text()="right"]
link=textPattern: Select the link (anchor) element which contains text matching the specified pattern.
- link=The link text
css=cssSelectorSyntax: Select the element using css selectors. Please refer to CSS2 selectors, CSS3 selectors 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.
- css=a[href="#id3"]
- css=span#firstChild + span
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).

Without an explicit locator prefix, Selenium uses the following default strategies:

dom, for locators starting with "document."
xpath, for locators starting with "//"
identifier, otherwise

Element Filters

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.

Filters look much like locators, ie.

filterType=argument

Supported element-filters are:

value=valuePattern

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

index=index

Selects a single element based on its position in the list (offset from zero).

String-match Patterns

Various Pattern syntaxes are available for matching string values:

glob:pattern: 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.
regexp:regexp: Match a string using a regular-expression. The full power of JavaScript regular-expressions is available.
exact:string: Match a string exactly, verbatim, without any of that fancy wildcard stuff.

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

Selenium Actions

addLocationStrategy ( strategyName,functionDefinition )

Defines a new function for Selenium to locate elements on the page. For example, if you define the strategy "foo", and someone runs click("foo=blah"), we'll run your function, passing you the string "blah", and click on the element that your function returns, or throw an "Element not found" error if your function returns null. We'll pass three arguments to your function:

locator: the string the user passed in
inWindow: the currently selected window
inDocument: the currently selected document

The function must return null if the element can't be found.

Arguments:

strategyName - the name of the strategy to define; this should use only letters [a-zA-Z] with no spaces or other punctuation.
functionDefinition - a string defining the body of a function in JavaScript. For example: return inDocument.getElementById(locator);

addSelection ( 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

Arguments:

locator - an element locator identifying a multi-select box
optionLocator - an option locator (a label by default)

allowNativeXpath ( allow )

Specifies whether Selenium should use the native in-browser implementation of XPath (if any native version is available); if you pass "false" to this function, we will always use our pure-JavaScript xpath library. Using the pure-JS xpath library can improve the consistency of xpath element locators between different browser vendors, but the pure-JS version is much slower than the native implementations.

Arguments:

allow - boolean, true means we'll prefer to use native XPath; false means we'll only use JS XPath

altKeyDown ( )

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

altKeyUp ( )

Release the alt key.

answerOnNextPrompt ( answer )

Instructs Selenium to return the specified answer string in response to the next JavaScript prompt [window.prompt()].

Arguments:

answer - the answer to give in response to the prompt pop-up

assignId ( locator,identifier )

Temporarily sets the "id" attribute of the specified element, so you can locate it in the future using its ID rather than a slow/complicated XPath. This ID will disappear once the page is reloaded.

Arguments:

locator - an element locator pointing to an element
identifier - a string to be used as the ID of the specified element

break ( )

Halt the currently running test, and wait for the user to press the Continue button. This command is useful for debugging, but be careful when using it, because it will force automated tests to hang until a user intervenes manually.

check ( locator )

Check a toggle-button (checkbox/radio)

Arguments:

locator - an element locator

chooseCancelOnNextConfirmation ( )

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. Selenium will then resume using the default behavior for future confirmations, automatically returning true (OK) unless/until you explicitly call this command for each confirmation.

chooseOkOnNextConfirmation ( )

Undo the effect of calling chooseCancelOnNextConfirmation. Note that Selenium's overridden window.confirm() function will normally automatically return true, as if the user had manually clicked OK, so you shouldn't need to use this command unless for some reason you need to change your mind prior to the next confirmation. After any confirmation, Selenium will resume using the default behavior for future confirmations, automatically returning true (OK) unless/until you explicitly call chooseCancelOnNextConfirmation for each confirmation.

click ( 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.

Arguments:

locator - an element locator

clickAt ( 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.

Arguments:

locator - an element locator
coordString - specifies the x,y position (i.e. - 10,20) of the mouse event relative to the element returned by the locator.

close ( )

Simulates the user clicking the "close" button in the titlebar of a popup window or tab.

controlKeyDown ( )

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

controlKeyUp ( )

Release the control key.

createCookie ( nameValuePair,optionsString )

Create a new cookie whose path and domain are same with those of current page under test, unless you specified a path for this cookie explicitly.

Arguments:

nameValuePair - name and value of the cookie in a format "name=value"
optionsString - options for the cookie. Currently supported options include 'path' and 'max_age'. the optionsString's format is "path=/path/, max_age=60". The order of options are irrelevant, the unit of the value of 'max_age' is second.

deleteCookie ( name,path )

Delete a named cookie with specified path.

Arguments:

name - the name of the cookie to be deleted
path - the path property of the cookie to be deleted

doubleClick ( 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.

Arguments:

locator - an element locator

doubleClickAt ( 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.

Arguments:

locator - an element locator
coordString - specifies the x,y position (i.e. - 10,20) of the mouse event relative to the element returned by the locator.

dragAndDrop ( locator,movementsString )

Drags an element a certain distance and then drops it

Arguments:

locator - an element locator
movementsString - offset in pixels from the current location to which the element should be moved, e.g., "+70,-300"

dragAndDropToObject ( locatorOfObjectToBeDragged,locatorOfDragDestinationObject )

Drags an element and drops it on another element

Arguments:

locatorOfObjectToBeDragged - an element to be dragged
locatorOfDragDestinationObject - an element whose location (i.e., whose center-most pixel) will be the point where locatorOfObjectToBeDragged is dropped

dragdrop ( locator,movementsString )

deprecated - use dragAndDrop instead

Arguments:

locator - an element locator
movementsString - offset in pixels from the current location to which the element should be moved, e.g., "+70,-300"

echo ( message )

Prints the specified message into the third table cell in your Selenese tables. Useful for debugging.

Arguments:

message - the message to print

fireEvent ( locator,eventName )

Explicitly simulate an event, to trigger the corresponding "onevent" handler.

Arguments:

locator - an element locator
eventName - the event name, e.g. "focus" or "blur"

getSpeed ( )

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.

goBack ( )

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

highlight ( locator )

Briefly changes the backgroundColor of the specified element yellow. Useful for debugging.

Arguments:

locator - an element locator

keyDown ( locator,keySequence )

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

Arguments:

locator - an element locator
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".

keyPress ( locator,keySequence )

Simulates a user pressing and releasing a key.

Arguments:

locator - an element locator
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".

keyUp ( locator,keySequence )

Simulates a user releasing a key.

Arguments:

locator - an element locator
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".

metaKeyDown ( )

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

metaKeyUp ( )

Release the meta key.

mouseDown ( locator )

Simulates a user pressing the mouse button (without releasing it yet) on the specified element.

Arguments:

locator - an element locator

mouseDownAt ( locator,coordString )

Simulates a user pressing the mouse button (without releasing it yet) at the specified location.

Arguments:

locator - an element locator
coordString - specifies the x,y position (i.e. - 10,20) of the mouse event relative to the element returned by the locator.

mouseMove ( locator )

Simulates a user pressing the mouse button (without releasing it yet) on the specified element.

Arguments:

locator - an element locator

mouseMoveAt ( locator,coordString )

Simulates a user pressing the mouse button (without releasing it yet) on the specified element.

Arguments:

locator - an element locator
coordString - specifies the x,y position (i.e. - 10,20) of the mouse event relative to the element returned by the locator.

mouseOut ( locator )

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

Arguments:

locator - an element locator

mouseOver ( locator )

Simulates a user hovering a mouse over the specified element.

Arguments:

locator - an element locator

mouseUp ( locator )

Simulates the event that occurs when the user releases the mouse button (i.e., stops holding the button down) on the specified element.

Arguments:

locator - an element locator

mouseUpAt ( locator,coordString )

Simulates the event that occurs when the user releases the mouse button (i.e., stops holding the button down) at the specified location.

Arguments:

locator - an element locator
coordString - specifies the x,y position (i.e. - 10,20) of the mouse event relative to the element returned by the locator.

open ( 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. Note: 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.

Arguments:

url - the URL to open; may be relative or absolute

openWindow ( 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.

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").

Arguments:

url - the URL to open, which can be blank
windowID - the JavaScript window ID of the window to select

pause ( waitTime )

Wait for the specified amount of time (in milliseconds)

Arguments:

waitTime - the amount of time to sleep (in milliseconds)

refresh ( )

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

removeAllSelections ( locator )

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

Arguments:

locator - an element locator identifying a multi-select box

removeSelection ( 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

Arguments:

locator - an element locator identifying a multi-select box
optionLocator - an option locator (a label by default)

runScript ( script )

Creates a new "script" tag in the body of the current test window, and adds the specified text into the body of the command. Scripts run in this way can often be debugged more easily than scripts executed using Selenium's "getEval" command. Beware that JS exceptions thrown in these script tags aren't managed by Selenium, so you should probably wrap your script in try/catch blocks if there is any chance that the script will throw an exception.

Arguments:

script - the JavaScript snippet to run

select ( selectLocator,optionLocator )

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

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.

label=labelPattern: matches options based on their labels, i.e. the visible text. (This is the default.)
- label=regexp:^[Oo]ther
value=valuePattern: matches options based on their values.
- value=other
id=id: matches options based on their ids.
- id=option1
index=index: matches an option based on its index (offset from zero).
- index=2

If no option locator prefix is provided, the default behaviour is to match on label.

Arguments:

selectLocator - an element locator identifying a drop-down menu
optionLocator - an option locator (a label by default)

selectFrame ( 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". You can also select a frame by its 0-based index number; select the first frame with "index=0", or the third frame with "index=2".

You may also use a DOM expression to identify the frame you want directly, like this: dom=frames["main"].frames["subframe"]

Arguments:

locator - an element locator identifying a frame or iframe

selectWindow ( 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.

Note that there is a big difference between a window's internal JavaScript "name" property and the "title" of a given window's document (which is normally what you actually see, as an end user, in the title bar of the window). The "name" is normally invisible to the end-user; it's the second parameter "windowName" passed to the JavaScript method window.open(url, windowName, windowFeatures, replaceFlag) (which selenium intercepts).

Selenium has several strategies for finding the window object referred to by the "windowID" parameter.

1.) if windowID is null, (or the string "null") then it is assumed the user is referring to the original window instantiated by the browser).

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.

3.) Otherwise, selenium looks in a hash it maintains that maps string names to window "names".

4.) If that fails, we'll try looping over all of the known windows to try to find the appropriate "title". Since "title" is not necessarily unique, this may have unexpected behavior.

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:

debug: window.open call intercepted; window ID (which you can use with selectWindow()) is "myNewWindow"

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").

Arguments:

windowID - the JavaScript window ID of the window to select

setBrowserLogLevel ( logLevel )

Sets the threshold for browser-side logging messages; log messages beneath this threshold will be discarded. Valid logLevel strings are: "debug", "info", "warn", "error" or "off". To see the browser logs, you need to either show the log window in GUI mode, or enable browser-side logging in Selenium RC.

Arguments:

logLevel - one of the following: "debug", "info", "warn", "error" or "off"

setCursorPosition ( locator,position )

Moves the text cursor to the specified position in the given input element or textarea. This method will fail if the specified element isn't an input element or textarea.

Arguments:

locator - an element locator pointing to an input element or textarea
position - the numerical position of the cursor in the field; position should be 0 to move the position to the beginning of the field. You can also set the cursor to -1 to move it to the end of the field.

setMouseSpeed ( pixels )

Configure the number of pixels between "mousemove" events during dragAndDrop commands (default=10).

Setting this value to 0 means that we'll send a "mousemove" event to every single pixel in between the start location and the end location; that can be very slow, and may cause some browsers to force the JavaScript to timeout.

If the mouse speed is greater than the distance between the two dragged objects, we'll just send one "mousemove" at the start location and then one final one at the end location.

Arguments:

pixels - the number of pixels between "mousemove" events

setSpeed ( 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.

Arguments:

value - the number of milliseconds to pause after operation

setTimeout ( timeout )

Specifies the amount of time that Selenium will wait for actions to complete.

Actions that require waiting include "open" and the "waitFor*" actions.

The default timeout is 30 seconds.

Arguments:

timeout - a timeout in milliseconds, after which the action will return with an error

shiftKeyDown ( )

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

shiftKeyUp ( )

Release the shift key.

store ( expression,variableName )

This command is a synonym for storeExpression.

Arguments:

expression - the value to store
variableName - the name of a variable in which the result is to be stored.

submit ( formLocator )

Submit the specified form. This is particularly useful for forms without submit buttons, e.g. single-input "Search" forms.

Arguments:

formLocator - an element locator for the form you want to submit

type ( locator,value )

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

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.

Arguments:

locator - an element locator
value - the value to type

typeKeys ( locator,value )

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

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.

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.

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.

Arguments:

locator - an element locator
value - the value to type

uncheck ( locator )

Uncheck a toggle-button (checkbox/radio)

Arguments:

locator - an element locator

waitForCondition ( script,timeout )

Runs the specified JavaScript snippet repeatedly until it evaluates to "true". The snippet may have multiple lines, but only the result of the last line will be considered.

Note that, by default, the snippet will be run in the runner's test window, not in the window of your application. To get the window of your application, you can use the JavaScript snippet selenium.browserbot.getCurrentWindow(), and then run your JavaScript in there

Arguments:

script - the JavaScript snippet to run
timeout - a timeout in milliseconds, after which this command will return with an error

waitForFrameToLoad ( frameAddress,timeout )

Waits for a new frame to load.

Selenium constantly keeps track of new pages and frames loading, and sets a "newPageLoaded" flag when it first notices a page load.

See waitForPageToLoad for more information.

Arguments:

frameAddress - FrameAddress from the server side
timeout - a timeout in milliseconds, after which this command will return with an error

waitForPageToLoad ( timeout )

Waits for a new page to load.

You can use this command instead of the "AndWait" suffixes, "clickAndWait", "selectAndWait", "typeAndWait" etc. (which are only available in the JS API).

Selenium constantly keeps track of new pages loading, and sets a "newPageLoaded" flag when it first notices a page load. Running any other Selenium command after turns the flag to false. Hence, if you want to wait for a page to load, you must wait immediately after a Selenium command that caused a page-load.

Arguments:

timeout - a timeout in milliseconds, after which this command will return with an error

waitForPopUp ( windowID,timeout )

Waits for a popup window to appear and load up.

Arguments:

windowID - the JavaScript window ID of the window that will appear
timeout - a timeout in milliseconds, after which the action will return with an error

windowFocus ( )

Gives focus to the currently selected window

windowMaximize ( )

Resize currently selected window to take up the entire screen

Selenium Accessors

assertErrorOnNext ( message )

Tell Selenium to expect an error on the next command execution.

Arguments:

message - The error message we should expect. This command will fail if the wrong error message appears.

Related Assertions, automatically generated:

assertNotErrorOnNext ( message )
verifyErrorOnNext ( message )
verifyNotErrorOnNext ( message )
waitForErrorOnNext ( message )
waitForNotErrorOnNext ( message )

assertFailureOnNext ( message )

Tell Selenium to expect a failure on the next command execution.

Arguments:

message - The failure message we should expect. This command will fail if the wrong failure message appears.

Related Assertions, automatically generated:

assertNotFailureOnNext ( message )
verifyFailureOnNext ( message )
verifyNotFailureOnNext ( message )
waitForFailureOnNext ( message )
waitForNotFailureOnNext ( message )

assertSelected ( selectLocator,optionLocator )

Verifies that the selected option of a drop-down satisfies the optionSpecifier. Note that this command is deprecated; you should use assertSelectedLabel, assertSelectedValue, assertSelectedIndex, or assertSelectedId instead.

See the select command for more information about option locators.

Arguments:

selectLocator - an element locator identifying a drop-down menu
optionLocator - an option locator, typically just an option label (e.g. "John Smith")

Related Assertions, automatically generated:

assertNotSelected ( selectLocator, optionLocator )
verifySelected ( selectLocator, optionLocator )
verifyNotSelected ( selectLocator, optionLocator )
waitForSelected ( selectLocator, optionLocator )
waitForNotSelected ( selectLocator, optionLocator )

storeAlert ( variableName )

Retrieves the message of a JavaScript alert generated during the previous action, or fail if there were no alerts.

Getting an alert has the same effect as manually clicking OK. If an alert is generated but you do not get/verify it, the next Selenium action will fail.

NOTE: under Selenium, JavaScript alerts will NOT pop up a visible alert dialog.

NOTE: Selenium does NOT support JavaScript alerts that are generated in a page's onload() event handler. In this case a visible dialog WILL be generated and Selenium will hang until someone manually clicks OK.

Returns:: The message of the most recent JavaScript alert

Related Assertions, automatically generated:

assertAlert ( pattern )
assertNotAlert ( pattern )
verifyAlert ( pattern )
verifyNotAlert ( pattern )
waitForAlert ( pattern )
waitForNotAlert ( pattern )

storeAllButtons ( variableName )

Returns the IDs of all buttons on the page.

If a given button has no ID, it will appear as "" in this array.

Returns:: the IDs of all buttons on the page

Related Assertions, automatically generated:

assertAllButtons ( pattern )
assertNotAllButtons ( pattern )
verifyAllButtons ( pattern )
verifyNotAllButtons ( pattern )
waitForAllButtons ( pattern )
waitForNotAllButtons ( pattern )

storeAllFields ( variableName )

Returns the IDs of all input fields on the page.

If a given field has no ID, it will appear as "" in this array.

Returns:: the IDs of all field on the page

Related Assertions, automatically generated:

assertAllFields ( pattern )
assertNotAllFields ( pattern )
verifyAllFields ( pattern )
verifyNotAllFields ( pattern )
waitForAllFields ( pattern )
waitForNotAllFields ( pattern )

storeAllLinks ( variableName )

Returns the IDs of all links on the page.

If a given link has no ID, it will appear as "" in this array.

Returns:: the IDs of all links on the page

Related Assertions, automatically generated:

assertAllLinks ( pattern )
assertNotAllLinks ( pattern )
verifyAllLinks ( pattern )
verifyNotAllLinks ( pattern )
waitForAllLinks ( pattern )
waitForNotAllLinks ( pattern )

storeAllWindowIds ( variableName )

Returns the IDs of all windows that the browser knows about.

Returns:: the IDs of all windows that the browser knows about.

Related Assertions, automatically generated:

assertAllWindowIds ( pattern )
assertNotAllWindowIds ( pattern )
verifyAllWindowIds ( pattern )
verifyNotAllWindowIds ( pattern )
waitForAllWindowIds ( pattern )
waitForNotAllWindowIds ( pattern )

storeAllWindowNames ( variableName )

Returns the names of all windows that the browser knows about.

Returns:: the names of all windows that the browser knows about.

Related Assertions, automatically generated:

assertAllWindowNames ( pattern )
assertNotAllWindowNames ( pattern )
verifyAllWindowNames ( pattern )
verifyNotAllWindowNames ( pattern )
waitForAllWindowNames ( pattern )
waitForNotAllWindowNames ( pattern )

storeAllWindowTitles ( variableName )

Returns the titles of all windows that the browser knows about.

Returns:: the titles of all windows that the browser knows about.

Related Assertions, automatically generated:

assertAllWindowTitles ( pattern )
assertNotAllWindowTitles ( pattern )
verifyAllWindowTitles ( pattern )
verifyNotAllWindowTitles ( pattern )
waitForAllWindowTitles ( pattern )
waitForNotAllWindowTitles ( pattern )

storeAttribute ( attributeLocator, variableName )

Gets the value of an element attribute.

Arguments:

attributeLocator - an element locator followed by an @ sign and then the name of the attribute, e.g. "foo@bar"
variableName - the name of a variable in which the result is to be stored.

Returns:: the value of the specified attribute

Related Assertions, automatically generated:

assertAttribute ( attributeLocator, pattern )
assertNotAttribute ( attributeLocator, pattern )
verifyAttribute ( attributeLocator, pattern )
verifyNotAttribute ( attributeLocator, pattern )
waitForAttribute ( attributeLocator, pattern )
waitForNotAttribute ( attributeLocator, pattern )

storeAttributeFromAllWindows ( attributeName, variableName )

Returns every instance of some attribute from all known windows.

Arguments:

attributeName - name of an attribute on the windows
variableName - the name of a variable in which the result is to be stored.

Returns:: the set of values of this attribute from all known windows.

Related Assertions, automatically generated:

assertAttributeFromAllWindows ( attributeName, pattern )
assertNotAttributeFromAllWindows ( attributeName, pattern )
verifyAttributeFromAllWindows ( attributeName, pattern )
verifyNotAttributeFromAllWindows ( attributeName, pattern )
waitForAttributeFromAllWindows ( attributeName, pattern )
waitForNotAttributeFromAllWindows ( attributeName, pattern )

storeBodyText ( variableName )

Gets the entire text of the page.

Returns:: the entire text of the page

Related Assertions, automatically generated:

assertBodyText ( pattern )
assertNotBodyText ( pattern )
verifyBodyText ( pattern )
verifyNotBodyText ( pattern )
waitForBodyText ( pattern )
waitForNotBodyText ( pattern )

storeConfirmation ( variableName )

Retrieves the message of a JavaScript confirmation dialog generated during the previous action.

By default, the confirm function will return true, having the same effect as manually clicking OK. This can be changed by prior execution of the chooseCancelOnNextConfirmation command. If an confirmation is generated but you do not get/verify it, the next Selenium action will fail.

NOTE: under Selenium, JavaScript confirmations will NOT pop up a visible dialog.

NOTE: Selenium does NOT support JavaScript confirmations that are generated in a page's onload() event handler. In this case a visible dialog WILL be generated and Selenium will hang until you manually click OK.

Returns:: the message of the most recent JavaScript confirmation dialog

Related Assertions, automatically generated:

assertConfirmation ( pattern )
assertNotConfirmation ( pattern )
verifyConfirmation ( pattern )
verifyNotConfirmation ( pattern )
waitForConfirmation ( pattern )
waitForNotConfirmation ( pattern )

storeCookie ( variableName )

Return all cookies of the current page under test.

Returns:: all cookies of the current page under test

Related Assertions, automatically generated:

assertCookie ( pattern )
assertNotCookie ( pattern )
verifyCookie ( pattern )
verifyNotCookie ( pattern )
waitForCookie ( pattern )
waitForNotCookie ( pattern )

storeCursorPosition ( locator, variableName )

Retrieves the text cursor position in the given input element or textarea; beware, this may not work perfectly on all browsers.

Specifically, if the cursor/selection has been cleared by JavaScript, this command will tend to return the position of the last location of the cursor, even though the cursor is now gone from the page. This is filed as SEL-243.

This method will fail if the specified element isn't an input element or textarea, or there is no cursor in the element.

Arguments:

locator - an element locator pointing to an input element or textarea
variableName - the name of a variable in which the result is to be stored.

Returns:: the numerical position of the cursor in the field

Related Assertions, automatically generated:

assertCursorPosition ( locator, pattern )
assertNotCursorPosition ( locator, pattern )
verifyCursorPosition ( locator, pattern )
verifyNotCursorPosition ( locator, pattern )
waitForCursorPosition ( locator, pattern )
waitForNotCursorPosition ( locator, pattern )

storeElementHeight ( locator, variableName )

Retrieves the height of an element

Arguments:

locator - an element locator pointing to an element
variableName - the name of a variable in which the result is to be stored.

Returns:: height of an element in pixels

Related Assertions, automatically generated:

assertElementHeight ( locator, pattern )
assertNotElementHeight ( locator, pattern )
verifyElementHeight ( locator, pattern )
verifyNotElementHeight ( locator, pattern )
waitForElementHeight ( locator, pattern )
waitForNotElementHeight ( locator, pattern )

storeElementIndex ( locator, variableName )

Get the relative index of an element to its parent (starting from 0). The comment node and empty text node will be ignored.

Arguments:

locator - an element locator pointing to an element
variableName - the name of a variable in which the result is to be stored.

Returns:: of relative index of the element to its parent (starting from 0)

Related Assertions, automatically generated:

assertElementIndex ( locator, pattern )
assertNotElementIndex ( locator, pattern )
verifyElementIndex ( locator, pattern )
verifyNotElementIndex ( locator, pattern )
waitForElementIndex ( locator, pattern )
waitForNotElementIndex ( locator, pattern )

storeElementPositionLeft ( locator, variableName )

Retrieves the horizontal position of an element

Arguments:

locator - an element locator pointing to an element OR an element itself
variableName - the name of a variable in which the result is to be stored.

Returns:: of pixels from the edge of the frame.

Related Assertions, automatically generated:

assertElementPositionLeft ( locator, pattern )
assertNotElementPositionLeft ( locator, pattern )
verifyElementPositionLeft ( locator, pattern )
verifyNotElementPositionLeft ( locator, pattern )
waitForElementPositionLeft ( locator, pattern )
waitForNotElementPositionLeft ( locator, pattern )

storeElementPositionTop ( locator, variableName )

Retrieves the vertical position of an element

Arguments:

locator - an element locator pointing to an element OR an element itself
variableName - the name of a variable in which the result is to be stored.

Returns:: of pixels from the edge of the frame.

Related Assertions, automatically generated:

assertElementPositionTop ( locator, pattern )
assertNotElementPositionTop ( locator, pattern )
verifyElementPositionTop ( locator, pattern )
verifyNotElementPositionTop ( locator, pattern )
waitForElementPositionTop ( locator, pattern )
waitForNotElementPositionTop ( locator, pattern )

storeElementWidth ( locator, variableName )

Retrieves the width of an element

Arguments:

locator - an element locator pointing to an element
variableName - the name of a variable in which the result is to be stored.

Returns:: width of an element in pixels

Related Assertions, automatically generated:

assertElementWidth ( locator, pattern )
assertNotElementWidth ( locator, pattern )
verifyElementWidth ( locator, pattern )
verifyNotElementWidth ( locator, pattern )
waitForElementWidth ( locator, pattern )
waitForNotElementWidth ( locator, pattern )

storeEval ( script, variableName )

Gets the result of evaluating the specified JavaScript snippet. The snippet may have multiple lines, but only the result of the last line will be returned.

Note that, by default, the snippet will run in the context of the "selenium" object itself, so this will refer to the Selenium object. Use window to refer to the window of your application, e.g. window.document.getElementById('foo')

If you need to use a locator to refer to a single element in your application page, you can use this.browserbot.findElement("id=foo") where "id=foo" is your locator.

Arguments:

script - the JavaScript snippet to run
variableName - the name of a variable in which the result is to be stored.

Returns:: the results of evaluating the snippet

Related Assertions, automatically generated:

assertEval ( script, pattern )
assertNotEval ( script, pattern )
verifyEval ( script, pattern )
verifyNotEval ( script, pattern )
waitForEval ( script, pattern )
waitForNotEval ( script, pattern )

storeExpression ( expression, variableName )

Returns the specified expression.

This is useful because of JavaScript preprocessing. It is used to generate commands like assertExpression and waitForExpression.

Arguments:

expression - the value to return
variableName - the name of a variable in which the result is to be stored.

Returns:: the value passed in

Related Assertions, automatically generated:

assertExpression ( expression, pattern )
assertNotExpression ( expression, pattern )
verifyExpression ( expression, pattern )
verifyNotExpression ( expression, pattern )
waitForExpression ( expression, pattern )
waitForNotExpression ( expression, pattern )

storeHtmlSource ( variableName )

Returns the entire HTML source between the opening and closing "html" tags.

Returns:: the entire HTML source

Related Assertions, automatically generated:

assertHtmlSource ( pattern )
assertNotHtmlSource ( pattern )
verifyHtmlSource ( pattern )
verifyNotHtmlSource ( pattern )
waitForHtmlSource ( pattern )
waitForNotHtmlSource ( pattern )

storeLocation ( variableName )

Gets the absolute URL of the current page.

Returns:: the absolute URL of the current page

Related Assertions, automatically generated:

assertLocation ( pattern )
assertNotLocation ( pattern )
verifyLocation ( pattern )
verifyNotLocation ( pattern )
waitForLocation ( pattern )
waitForNotLocation ( pattern )

storeMouseSpeed ( variableName )

Returns the number of pixels between "mousemove" events during dragAndDrop commands (default=10).

Returns:: the number of pixels between "mousemove" events during dragAndDrop commands (default=10)

Related Assertions, automatically generated:

assertMouseSpeed ( pattern )
assertNotMouseSpeed ( pattern )
verifyMouseSpeed ( pattern )
verifyNotMouseSpeed ( pattern )
waitForMouseSpeed ( pattern )
waitForNotMouseSpeed ( pattern )

storePrompt ( variableName )

Retrieves the message of a JavaScript question prompt dialog generated during the previous action.

Successful handling of the prompt requires prior execution of the answerOnNextPrompt command. If a prompt is generated but you do not get/verify it, the next Selenium action will fail.

NOTE: under Selenium, JavaScript prompts will NOT pop up a visible dialog.

NOTE: Selenium does NOT support JavaScript prompts that are generated in a page's onload() event handler. In this case a visible dialog WILL be generated and Selenium will hang until someone manually clicks OK.

Returns:: the message of the most recent JavaScript question prompt

Related Assertions, automatically generated:

assertPrompt ( pattern )
assertNotPrompt ( pattern )
verifyPrompt ( pattern )
verifyNotPrompt ( pattern )
waitForPrompt ( pattern )
waitForNotPrompt ( pattern )

storeSelectedId ( selectLocator, variableName )

Gets option element ID for selected option in the specified select element.

Arguments:

selectLocator - an element locator identifying a drop-down menu
variableName - the name of a variable in which the result is to be stored.

Returns:: the selected option ID in the specified select drop-down

Related Assertions, automatically generated:

assertSelectedId ( selectLocator, pattern )
assertNotSelectedId ( selectLocator, pattern )
verifySelectedId ( selectLocator, pattern )
verifyNotSelectedId ( selectLocator, pattern )
waitForSelectedId ( selectLocator, pattern )
waitForNotSelectedId ( selectLocator, pattern )

storeSelectedIds ( selectLocator, variableName )

Gets all option element IDs for selected options in the specified select or multi-select element.

Arguments:

selectLocator - an element locator identifying a drop-down menu
variableName - the name of a variable in which the result is to be stored.

Returns:: an array of all selected option IDs in the specified select drop-down

Related Assertions, automatically generated:

assertSelectedIds ( selectLocator, pattern )
assertNotSelectedIds ( selectLocator, pattern )
verifySelectedIds ( selectLocator, pattern )
verifyNotSelectedIds ( selectLocator, pattern )
waitForSelectedIds ( selectLocator, pattern )
waitForNotSelectedIds ( selectLocator, pattern )

storeSelectedIndex ( selectLocator, variableName )

Gets option index (option number, starting at 0) for selected option in the specified select element.

Arguments:

selectLocator - an element locator identifying a drop-down menu
variableName - the name of a variable in which the result is to be stored.

Returns:: the selected option index in the specified select drop-down

Related Assertions, automatically generated:

assertSelectedIndex ( selectLocator, pattern )
assertNotSelectedIndex ( selectLocator, pattern )
verifySelectedIndex ( selectLocator, pattern )
verifyNotSelectedIndex ( selectLocator, pattern )
waitForSelectedIndex ( selectLocator, pattern )
waitForNotSelectedIndex ( selectLocator, pattern )

storeSelectedIndexes ( selectLocator, variableName )

Gets all option indexes (option number, starting at 0) for selected options in the specified select or multi-select element.

Arguments:

selectLocator - an element locator identifying a drop-down menu
variableName - the name of a variable in which the result is to be stored.

Returns:: an array of all selected option indexes in the specified select drop-down

Related Assertions, automatically generated:

assertSelectedIndexes ( selectLocator, pattern )
assertNotSelectedIndexes ( selectLocator, pattern )
verifySelectedIndexes ( selectLocator, pattern )
verifyNotSelectedIndexes ( selectLocator, pattern )
waitForSelectedIndexes ( selectLocator, pattern )
waitForNotSelectedIndexes ( selectLocator, pattern )

storeSelectedLabel ( selectLocator, variableName )

Gets option label (visible text) for selected option in the specified select element.

Arguments:

selectLocator - an element locator identifying a drop-down menu
variableName - the name of a variable in which the result is to be stored.

Returns:: the selected option label in the specified select drop-down

Related Assertions, automatically generated:

assertSelectedLabel ( selectLocator, pattern )
assertNotSelectedLabel ( selectLocator, pattern )
verifySelectedLabel ( selectLocator, pattern )
verifyNotSelectedLabel ( selectLocator, pattern )
waitForSelectedLabel ( selectLocator, pattern )
waitForNotSelectedLabel ( selectLocator, pattern )

storeSelectedLabels ( selectLocator, variableName )

Gets all option labels (visible text) for selected options in the specified select or multi-select element.

Arguments:

selectLocator - an element locator identifying a drop-down menu
variableName - the name of a variable in which the result is to be stored.

Returns:: an array of all selected option labels in the specified select drop-down

Related Assertions, automatically generated:

assertSelectedLabels ( selectLocator, pattern )
assertNotSelectedLabels ( selectLocator, pattern )
verifySelectedLabels ( selectLocator, pattern )
verifyNotSelectedLabels ( selectLocator, pattern )
waitForSelectedLabels ( selectLocator, pattern )
waitForNotSelectedLabels ( selectLocator, pattern )

storeSelectedValue ( selectLocator, variableName )

Gets option value (value attribute) for selected option in the specified select element.

Arguments:

selectLocator - an element locator identifying a drop-down menu
variableName - the name of a variable in which the result is to be stored.

Returns:: the selected option value in the specified select drop-down

Related Assertions, automatically generated:

assertSelectedValue ( selectLocator, pattern )
assertNotSelectedValue ( selectLocator, pattern )
verifySelectedValue ( selectLocator, pattern )
verifyNotSelectedValue ( selectLocator, pattern )
waitForSelectedValue ( selectLocator, pattern )
waitForNotSelectedValue ( selectLocator, pattern )

storeSelectedValues ( selectLocator, variableName )

Gets all option values (value attributes) for selected options in the specified select or multi-select element.

Arguments:

selectLocator - an element locator identifying a drop-down menu
variableName - the name of a variable in which the result is to be stored.

Returns:: an array of all selected option values in the specified select drop-down

Related Assertions, automatically generated:

assertSelectedValues ( selectLocator, pattern )
assertNotSelectedValues ( selectLocator, pattern )
verifySelectedValues ( selectLocator, pattern )
verifyNotSelectedValues ( selectLocator, pattern )
waitForSelectedValues ( selectLocator, pattern )
waitForNotSelectedValues ( selectLocator, pattern )

storeSelectOptions ( selectLocator, variableName )

Gets all option labels in the specified select drop-down.

Arguments:

selectLocator - an element locator identifying a drop-down menu
variableName - the name of a variable in which the result is to be stored.

Returns:: an array of all option labels in the specified select drop-down

Related Assertions, automatically generated:

assertSelectOptions ( selectLocator, pattern )
assertNotSelectOptions ( selectLocator, pattern )
verifySelectOptions ( selectLocator, pattern )
verifyNotSelectOptions ( selectLocator, pattern )
waitForSelectOptions ( selectLocator, pattern )
waitForNotSelectOptions ( selectLocator, pattern )

storeTable ( tableCellAddress, variableName )

Gets the text from a cell of a table. The cellAddress syntax tableLocator.row.column, where row and column start at 0.

Arguments:

tableCellAddress - a cell address, e.g. "foo.1.4"
variableName - the name of a variable in which the result is to be stored.

Returns:: the text from the specified cell

Related Assertions, automatically generated:

assertTable ( tableCellAddress, pattern )
assertNotTable ( tableCellAddress, pattern )
verifyTable ( tableCellAddress, pattern )
verifyNotTable ( tableCellAddress, pattern )
waitForTable ( tableCellAddress, pattern )
waitForNotTable ( tableCellAddress, pattern )

storeText ( locator, variableName )

Gets the text of an element. This works for any element that contains text. This command uses either the textContent (Mozilla-like browsers) or the innerText (IE-like browsers) of the element, which is the rendered text shown to the user.

Arguments:

locator - an element locator
variableName - the name of a variable in which the result is to be stored.

Returns:: the text of the element

Related Assertions, automatically generated:

assertText ( locator, pattern )
assertNotText ( locator, pattern )
verifyText ( locator, pattern )
verifyNotText ( locator, pattern )
waitForText ( locator, pattern )
waitForNotText ( locator, pattern )

storeTitle ( variableName )

Gets the title of the current page.

Returns:: the title of the current page

Related Assertions, automatically generated:

assertTitle ( pattern )
assertNotTitle ( pattern )
verifyTitle ( pattern )
verifyNotTitle ( pattern )
waitForTitle ( pattern )
waitForNotTitle ( pattern )

storeValue ( locator, variableName )

Gets the (whitespace-trimmed) value of an input field (or anything else with a value parameter). For checkbox/radio elements, the value will be "on" or "off" depending on whether the element is checked or not.

Arguments:

locator - an element locator
variableName - the name of a variable in which the result is to be stored.

Returns:: the element value, or "on/off" for checkbox/radio elements

Related Assertions, automatically generated:

assertValue ( locator, pattern )
assertNotValue ( locator, pattern )
verifyValue ( locator, pattern )
verifyNotValue ( locator, pattern )
waitForValue ( locator, pattern )
waitForNotValue ( locator, pattern )

storeWhetherThisFrameMatchFrameExpression ( currentFrameString, target, variableName )

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

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.

Arguments:

currentFrameString - starting frame
target - new frame (which might be relative to the current one)
variableName - the name of a variable in which the result is to be stored.

Returns:: true if the new frame is this code's window

Related Assertions, automatically generated:

assertWhetherThisFrameMatchFrameExpression ( currentFrameString, target )
assertNotWhetherThisFrameMatchFrameExpression ( currentFrameString, target )
verifyWhetherThisFrameMatchFrameExpression ( currentFrameString, target )
verifyNotWhetherThisFrameMatchFrameExpression ( currentFrameString, target )
waitForWhetherThisFrameMatchFrameExpression ( currentFrameString, target )
waitForNotWhetherThisFrameMatchFrameExpression ( currentFrameString, target )

storeWhetherThisWindowMatchWindowExpression ( currentWindowString, target, variableName )

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

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.

Arguments:

currentWindowString - starting window
target - new window (which might be relative to the current one, e.g., "_parent")
variableName - the name of a variable in which the result is to be stored.

Returns:: true if the new window is this code's window

Related Assertions, automatically generated:

assertWhetherThisWindowMatchWindowExpression ( currentWindowString, target )
assertNotWhetherThisWindowMatchWindowExpression ( currentWindowString, target )
verifyWhetherThisWindowMatchWindowExpression ( currentWindowString, target )
verifyNotWhetherThisWindowMatchWindowExpression ( currentWindowString, target )
waitForWhetherThisWindowMatchWindowExpression ( currentWindowString, target )
waitForNotWhetherThisWindowMatchWindowExpression ( currentWindowString, target )

storeXpathCount ( xpath, variableName )

Returns the number of nodes that match the specified xpath, eg. "//table" would give the number of tables.

Arguments:

xpath - the xpath expression to evaluate. do NOT wrap this expression in a 'count()' function; we will do that for you.
variableName - the name of a variable in which the result is to be stored.

Returns:: the number of nodes that match the specified xpath

Related Assertions, automatically generated:

assertXpathCount ( xpath, pattern )
assertNotXpathCount ( xpath, pattern )
verifyXpathCount ( xpath, pattern )
verifyNotXpathCount ( xpath, pattern )
waitForXpathCount ( xpath, pattern )
waitForNotXpathCount ( xpath, pattern )

storeAlertPresent ( variableName )

Has an alert occurred?

This function never throws an exception

Returns:: true if there is an alert

Related Assertions, automatically generated:

assertAlertPresent ( )
assertAlertNotPresent ( )
verifyAlertPresent ( )
verifyAlertNotPresent ( )
waitForAlertPresent ( )
waitForAlertNotPresent ( )

storeChecked ( locator, variableName )

Gets whether a toggle-button (checkbox/radio) is checked. Fails if the specified element doesn't exist or isn't a toggle-button.

Arguments:

locator - an element locator pointing to a checkbox or radio button
variableName - the name of a variable in which the result is to be stored.

Returns:: true if the checkbox is checked, false otherwise

Related Assertions, automatically generated:

assertChecked ( locator )
assertNotChecked ( locator )
verifyChecked ( locator )
verifyNotChecked ( locator )
waitForChecked ( locator )
waitForNotChecked ( locator )

storeConfirmationPresent ( variableName )

Has confirm() been called?

This function never throws an exception

Returns:: true if there is a pending confirmation

Related Assertions, automatically generated:

assertConfirmationPresent ( )
assertConfirmationNotPresent ( )
verifyConfirmationPresent ( )
verifyConfirmationNotPresent ( )
waitForConfirmationPresent ( )
waitForConfirmationNotPresent ( )

storeEditable ( locator, variableName )

Determines whether the specified input element is editable, ie hasn't been disabled. This method will fail if the specified element isn't an input element.

Arguments:

locator - an element locator
variableName - the name of a variable in which the result is to be stored.

Returns:: true if the input element is editable, false otherwise

Related Assertions, automatically generated:

assertEditable ( locator )
assertNotEditable ( locator )
verifyEditable ( locator )
verifyNotEditable ( locator )
waitForEditable ( locator )
waitForNotEditable ( locator )

storeElementPresent ( locator, variableName )

Verifies that the specified element is somewhere on the page.

Arguments:

locator - an element locator
variableName - the name of a variable in which the result is to be stored.

Returns:: true if the element is present, false otherwise

Related Assertions, automatically generated:

assertElementPresent ( locator )
assertElementNotPresent ( locator )
verifyElementPresent ( locator )
verifyElementNotPresent ( locator )
waitForElementPresent ( locator )
waitForElementNotPresent ( locator )

storeOrdered ( locator1, locator2, variableName )

Check if these two elements have same parent and are ordered siblings in the DOM. Two same elements will not be considered ordered.

Arguments:

locator1 - an element locator pointing to the first element
locator2 - an element locator pointing to the second element
variableName - the name of a variable in which the result is to be stored.

Returns:: true if element1 is the previous sibling of element2, false otherwise

Related Assertions, automatically generated:

assertOrdered ( locator1, locator2 )
assertNotOrdered ( locator1, locator2 )
verifyOrdered ( locator1, locator2 )
verifyNotOrdered ( locator1, locator2 )
waitForOrdered ( locator1, locator2 )
waitForNotOrdered ( locator1, locator2 )

storePromptPresent ( variableName )

Has a prompt occurred?

This function never throws an exception

Returns:: true if there is a pending prompt

Related Assertions, automatically generated:

assertPromptPresent ( )
assertPromptNotPresent ( )
verifyPromptPresent ( )
verifyPromptNotPresent ( )
waitForPromptPresent ( )
waitForPromptNotPresent ( )

storeSomethingSelected ( selectLocator, variableName )

Determines whether some option in a drop-down menu is selected.

Arguments:

selectLocator - an element locator identifying a drop-down menu
variableName - the name of a variable in which the result is to be stored.

Returns:: true if some option has been selected, false otherwise

Related Assertions, automatically generated:

assertSomethingSelected ( selectLocator )
assertNotSomethingSelected ( selectLocator )
verifySomethingSelected ( selectLocator )
verifyNotSomethingSelected ( selectLocator )
waitForSomethingSelected ( selectLocator )
waitForNotSomethingSelected ( selectLocator )

storeTextPresent ( pattern, variableName )

Verifies that the specified text pattern appears somewhere on the rendered page shown to the user.

Arguments:

pattern - a pattern to match with the text of the page
variableName - the name of a variable in which the result is to be stored.

Returns:: true if the pattern matches the text, false otherwise

Related Assertions, automatically generated:

assertTextPresent ( pattern )
assertTextNotPresent ( pattern )
verifyTextPresent ( pattern )
verifyTextNotPresent ( pattern )
waitForTextPresent ( pattern )
waitForTextNotPresent ( pattern )

storeVisible ( locator, variableName )

Determines if the specified element is visible. An element can be rendered invisible by setting the CSS "visibility" property to "hidden", or the "display" property to "none", either for the element itself or one if its ancestors. This method will fail if the element is not present.

Arguments:

locator - an element locator
variableName - the name of a variable in which the result is to be stored.

Returns:: true if the specified element is visible, false otherwise

Related Assertions, automatically generated:

assertVisible ( locator )
assertNotVisible ( locator )
verifyVisible ( locator )
verifyNotVisible ( locator )
waitForVisible ( locator )
waitForNotVisible ( locator )

Parameter construction and Variables

All Selenium command parameters can be constructed using both simple variable substitution as well as full javascript. Both of these mechanisms can access previously stored variables, but do so using different syntax.

Stored Variables

The commands store, storeValue and storeText can be used to store a variable value for later access. Internally, these variables are stored in a map called "storedVars", with values keyed by the variable name. These commands are documented in the command reference.

Variable substitution

Variable substitution provides a simple way to include a previously stored variable in a command parameter. This is a simple mechanism, by which the variable to substitute is indicated by ${variableName}. Multiple variables can be substituted, and intermixed with static text.

Example:

store Mr title

storeValue nameField surname

store ${title} ${surname} fullname

type textElement Full name is: ${fullname}

Javascript evaluation

Javascript evaluation provides the full power of javascript in constructing a command parameter. To use this mechanism, the entire parameter value must be prefixed by 'javascript{' with a trailing '}'. The text inside the braces is evaluated as a javascript expression, and can access previously stored variables using the storedVars map detailed above. Note that variable substitution cannot be combined with javascript evaluation.

Example:

store javascript{'merchant' + (new Date()).getTime()} merchantId

type textElement javascript{storedVars['merchantId'].toUpperCase()}

Extending Selenium

It can be quite simple to extend Selenium, adding your own actions, assertions and locator-strategies. This is done with javascript by adding methods to the Selenium object prototype, and the PageBot object prototype. On startup, Selenium will automatically look through methods on these prototypes, using name patterns to recognise which ones are actions, assertions and locators.

The following examples try to give an indication of how Selenium can be extended with javascript.

Actions

All doFoo methods on the Selenium prototype are added as actions. For each action foo there is also an action fooAndWait registered. An action method can take up to 2 parameters, which will be passed the second and third column values in the test.

Example: Add a "typeRepeated" action to Selenium, which types the text twice into a text box.
        Selenium.prototype.doTypeRepeated = function(locator, text) {
     // All locator-strategies are automatically handled by "findElement"
     var element = this.page().findElement(locator);

     // Create the text to type
     var valueToType = text + text;

     // Replace the element text with the new text
     this.page().replaceText(element, valueToType);
 };

Accessors/Assertions

All getFoo and isFoo methods on the Selenium prototype are added as accessors (storeFoo). For each accessor there is an assertFoo, verifyFoo and waitForFoo registered. An assert method can take up to 2 parameters, which will be passed the second and third column values in the test. You can also define your own assertions literally as simple "assert" methods, which will also auto-generate "verify" and "waitFor" commands.

Example: Add a valueRepeated assertion, that makes sure that the element value consists of the supplied text repeated. The 2 commands that would be available in tests would be assertValueRepeated and verifyValueRepeated.
        Selenium.prototype.assertValueRepeated = function(locator, text) {
     // All locator-strategies are automatically handled by "findElement"
     var element = this.page().findElement(locator);

     // Create the text to verify
     var expectedValue = text + text;

     // Get the actual element value
     var actualValue = element.value;

     // Make sure the actual value matches the expected
     Assert.matches(expectedValue, actualValue);
 };

Automatic availability of storeFoo, assertFoo, assertNotFoo, waitForFoo and waitForNotFoo for every getFoo

All getFoo and isFoo methods on the Selenium prototype automatically result in the availability of storeFoo, assertFoo, assertNotFoo, verifyFoo, verifyNotFoo, waitForFoo, and waitForNotFoo commands.

Example, if you add a getTextLength() method, the following commands will automatically be available: storeTextLength, assertTextLength, assertNotTextLength, verifyTextLength, verifyNotTextLength, waitForTextLength, and waitForNotTextLength commands.
        Selenium.prototype.getTextLength = function(locator, text) {
     return this.getText(locator).length;
 };
Also note that the assertValueRepeated method described above could have been implemented using isValueRepeated, with the added benefit of also automatically getting assertNotValueRepeated, storeValueRepeated, waitForValueRepeated and waitForNotValueRepeated.

Locator Strategies

All locateElementByFoo methods on the PageBot prototype are added as locator-strategies. A locator strategy takes 2 parameters, the first being the locator string (minus the prefix), and the second being the document in which to search.

Example: Add a "valuerepeated=" locator, that finds the first element a value attribute equal to the the supplied value repeated.
        // The "inDocument" is a the document you are searching.
 PageBot.prototype.locateElementByValueRepeated = function(text, inDocument) {
     // Create the text to search for
     var expectedValue = text + text;

     // Loop through all elements, looking for ones that have
     // a value === our expected value
     var allElements = inDocument.getElementsByTagName("*");
     for (var i = 0; i < testelement =" allElements[i];" value ="=">     

user-extensions.js

By default, Selenium looks for a file called "user-extensions.js", and loads the javascript code found in that file. This file provides a convenient location for adding features to Selenium, without needing to modify the core Selenium sources.

In the standard distibution, this file does not exist. Users can create this file and place their extension code in this common location, removing the need to modify the Selenium sources, and hopefully assisting with the upgrade process

S/W Testing Experience

Monday, October 12, 2009

Wednesday, October 7, 2009

Commads for attributes

Locating elment using XPath

selenium uses XpathLibrary(".....")

Title 1

Title 2

Monday, May 4, 2009

Testing Ajax Applications with Selenium

How to use XPath

Selenium Commands List

Concepts

Element Locators

Element Filters

String-match Patterns

Selenium Actions

Selenium Accessors

Parameter construction and Variables

Extending Selenium

About Me

Blog Archive

store	Mr	title
storeValue	nameField	surname
store	${title} ${surname}	fullname
type	textElement	Full name is: ${fullname}

store	javascript{'merchant' + (new Date()).getTime()}	merchantId
type	textElement	javascript{storedVars['merchantId'].toUpperCase()}