Total Pageviews

Thursday 27 December 2012

Selenium Runwith annotation program

//  Main program ( Sample.java )
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;

@RunWith(Suite.class)
@SuiteClasses({two.class})

public class Sample {
}


//   Subprogram   (two.java) (Called program)
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class two {

    @Before
    public  void before(){
        System.out.println("Before");
    }
   
    @Test
     public  void test(){
        System.out.println("Test");
    }
   
     @After
     public  void after(){
            System.out.println("After");
    }

}
Posted by at No comments:

Monday 17 December 2012

Selenium Accessors part 6

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 )

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. 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 two elements are ordered and have same parent, 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:
storeMrtitle
storeValuenameFieldsurname
store${title} ${surname}fullname
typetextElementFull 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:
storejavascript{'merchant' + (new Date()).getTime()}merchantId
typetextElementjavascript{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 < allElements.length; i++) {
         var testElement = allElements[i];
         if (testElement.value && testElement.value === expectedValue) {
             return testElement;
         }
     }
     return null;
 };
Posted by at No comments:

Selenium Accessors part 5

storeHtmlSource ( variableName )
Returns the entire HTML source between the opening and closing "html" tags.
Returns:
the entire HTML source
Related Assertions, automatically generated:

storeLocation ( variableName )
Gets the absolute URL of the current page.
Returns:
the absolute URL of the current page
Related Assertions, automatically generated:

storeLogMessages ( variableName )
Return the contents of the log. 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.
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.
Returns:
all log messages seen since the last call to this API
Related Assertions, automatically generated:

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:

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 )
Posted by at No comments:

Selenium Accessors part 4

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:

storeCookie ( variableName )
Return all cookies of the current page under test.
Returns:
all cookies of the current page under test
Related Assertions, automatically generated:

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 elementArguments:
  • 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 elementArguments:
  • 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 elementArguments:
  • 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 elementArguments:
  • 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, and window will refer to the top-level runner test window, not the window of your application.
If you need a reference to the window of your application, you can refer to this.browserbot.getCurrentWindow() and if you need to use a locator to refer to a single element in your application page, you can use this.page().findElement("foo") where "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:

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 )
Posted by at No comments:

Selenium Accessors part 3

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

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 ( windowName )
Gives focus to a windowArguments:
  • windowName - name of the window to be given focus

windowMaximize ( windowName )
Resize window to take up the entire screenArguments:
  • windowName - name of the window to be enlarged

Selenium Accessors

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:

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:

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:

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:

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:

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. Beware of http://jira.openqa.org/browse/SEL-280, which will lead some event handlers to get null event arguments. Read the bug for more details, including a workaround.Arguments:
  • attributeLocator - an element locator followed by an
  • 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:
Posted by at No comments:
Subscribe to: Posts (Atom)