<?xml version="1.0" encoding="UTF-8"?>
<keywordspec format="ROBOT" type="LIBRARY" generated="2021-10-13T18:18:15Z" scope="GLOBAL" name="SeleniumLibrary" specversion="3">
<version>4.0.0.0</version>
<doc>SeleniumLibrary is a web testing library for the Robot Framework and was originally written in Python. This is the Java port of the SeleniumLibrary for Robot Framework (https://github.com/robotframework/SeleniumLibrary). It uses the Selenium libraries internally to control a web browser. See [http://seleniumhq.org/docs/03_webdriver.html|WebDriver] for more information on Selenium (2) and WebDriver. It runs tests in a real browser instance and should work with most modern browsers and can be used with the Jython interpreter or any other Java application.

== Before running tests ==

Prior to running test cases using SeleniumLibrary, the library must be imported into your Robot Framework test suite (see importing section), and the `Open Browser` keyword must be used to open a browser to the desired location.

= Locating elements =

All keywords in SeleniumLibrary that need to find an element on the page take an locator argument.

== Key attributes ==

By default, when a locator value is provided, it is matched against the key attributes of the particular element type. The attributes ``id`` and ``name`` are key attributes to all elements.

List of key attributes:

 | = Element Type = | = Key Attributes = | 
 | A | @id,@name,@href,text | 
 | IMG | @id,@name,@src,@alt | 
 | INPUT | @id,@name,@value,@src | 
 | BUTTON | @id,@name,@value,text | 
 | * | @id,@name | 
 
Example:
 | Click Element | my_element |

== Locator strategies ==

It is also possible to specify the approach SeleniumLibrary should take to find an element by specifying a locator strategy with a locator prefix.

Supported strategies are:

 | = Strategy = | = Example = | = Description = | 
 | identifier | Click Element | identifier:my_element | Matches by @id or @name attribute | 
 | id | Click Element | id:my_element | Matches by @id attribute | 
 | name | Click Element | name:my_element | Matches by @name attribute | 
 | xpath | Click Element | xpath://div[@id='my_element'] | Matches by arbitrary XPath expression | 
 | dom | Click Element | dom:document.images[56] | Matches by arbitrary DOM expression | 
 | link | Click Element | link:My Link | Matches by the link text | 
 | css | Click Element | css:div.my_class | Matches by CSS selector | 
 | jquery | Click Element | jquery:div.my_class | Matches by jQuery/sizzle selector | 
 | sizzle | Click Element | sizzle:div.my_class | Matches by jQuery/sizzle selector | 
 | tag | Click Element | tag:div | Matches by HTML tag name | 
 
== Locating tables ==

Table related keywords, such as `Table Should Contain`, work differently. By default, when a table locator value is provided, it will search for a table with the specified id attribute.

Example:

 | Table Should Contain | my_table | text | 
 
More complex table locator strategies:

 | = Strategy = | = Example = | = Description = | 
 | xpath | Table Should Contain | xpath://table/[@name="my_table"] | text | Matches by arbitrary XPath expression | 
 | css | Table Should Contain | css:table.my_class | text | Matches by CSS selector | 

== Custom location strategies ==

It is also possible to register custom location strategies. See `Add Location Strategy` for details about custom location strategies.&lt;br&gt;

Example:

 | Add Location Strategy | custom | return window.document.getElementById(arguments[0]); | 
 | Input Text | custom=firstName | Max | 
 
= Timeouts =

There are several Wait ... keywords that take ``timeout`` as an argument. All of these timeout arguments are optional. The timeout used by all of them can be set globally using the `Set Selenium Timeout keyword`.

All timeouts can be given as numbers considered seconds (e.g. ``0.5`` or ``42``) or in Robot Framework's time syntax (e.g. ``1.5 seconds`` or ``1 min 30 s``). See [http://robotframework.org/robotframework/latest/RobotFrameworkUserGuide.html#time-format|Robot Framework User Guide] for details about the time syntax.

== Log Level ==
There are several keywords that take ``log level`` as an argument. All of these log level arguments are optional. The default is usually INFO.

 | = Log Level = | = Description = | 
 | DEBUG |  | 
 | INFO |  | 
 | HTML | Same as INFO, but message is in HTML format | 
 | TRACE |  | 
 | WARN |  | </doc>
<tags>
</tags>
<inits>
<init name="Init">
<arguments repr="arg1=, arg2=, arg3=, arg4=, /">
<arg repr="arg1=" kind="POSITIONAL_ONLY" required="false">
<name>arg1</name>
<default/>
</arg>
<arg repr="arg2=" kind="POSITIONAL_ONLY" required="false">
<name>arg2</name>
<default/>
</arg>
<arg repr="arg3=" kind="POSITIONAL_ONLY" required="false">
<name>arg3</name>
<default/>
</arg>
<arg repr="arg4=" kind="POSITIONAL_ONLY" required="false">
<name>arg4</name>
<default/>
</arg>
<arg repr="/" kind="POSITIONAL_ONLY_MARKER" required="false">
</arg>
</arguments>
<doc>SeleniumLibrary can be imported with several optional arguments.
        - ``timeout``:
          Default value for `timeouts` used with ``Wait ...`` keywords.
        - ``implicit_wait``:
          Default value for `implicit wait` used when locating elements.
        - ``run_on_failure``:
          Default action for the `run-on-failure functionality`.
        - ``screenshot_root_directory``:
          Location where possible screenshots are created. If not given,
          the directory where the log file is written is used.</doc>
<shortdoc>SeleniumLibrary can be imported with several optional arguments.         - ``timeout``:           Default value for `timeouts` used with ``Wait ...`` keywords.         - ``implicit_wait``:           Default value for `implicit wait` used when locating elements.         - ``run_on_failure``:           Default action for the `run-on-failure functionality`.         - ``screenshot_root_directory``:           Location where possible screenshots are created. If not given,           the directory where the log file is written is used.</shortdoc>
</init>
</inits>
<keywords>
<kw name="Add Cookie">
<arguments repr="name, value, path=NONE, domain=NONE, secure=NONE">
<arg repr="name" kind="POSITIONAL_OR_NAMED" required="true">
<name>name</name>
</arg>
<arg repr="value" kind="POSITIONAL_OR_NAMED" required="true">
<name>value</name>
</arg>
<arg repr="path=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>path</name>
<default>NONE</default>
</arg>
<arg repr="domain=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>domain</name>
<default>NONE</default>
</arg>
<arg repr="secure=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>secure</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Adds a cookie to your current session.</doc>
<shortdoc>Adds a cookie to your current session.</shortdoc>
</kw>
<kw name="Add Location Strategy">
<arguments repr="strategyName, functionDefinition, delimiter=NONE">
<arg repr="strategyName" kind="POSITIONAL_OR_NAMED" required="true">
<name>strategyName</name>
</arg>
<arg repr="functionDefinition" kind="POSITIONAL_OR_NAMED" required="true">
<name>functionDefinition</name>
</arg>
<arg repr="delimiter=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>delimiter</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Registers a JavaScript function as locator with the specified strategy name.

The registered function has to return a WebElement, a List of WebElements or null. Optionally a delimiter can be given to split the value of the locator in multiple arguments when executing the JavaScript function. 

Example:
 | Add Location Strategy | byId | return window.document.getElementById(arguments[0]); | 
 | Input Text | byId:firstName | Max |

Example with delimiter:
 | Add Location Strategy | byClassname | return window.document.getElementsByClassName(arguments[0])[arguments[1]]; | , | 
 | Input Text | byClassname:input,3 | Max |</doc>
<shortdoc>Registers a JavaScript function as locator with the specified strategy name.</shortdoc>
</kw>
<kw name="Alert Should Be Present">
<arguments repr="text=NONE">
<arg repr="text=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>text</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Verify an alert is present and dismiss it.

If ``text`` is a non-empty string, then it is also verified that the message of the alert equals to text.

Will fail if no alert is present. Note that following keywords will fail unless the alert is confirmed by this keyword or another like `Confirm Action`.</doc>
<shortdoc>Verify an alert is present and dismiss it.</shortdoc>
</kw>
<kw name="Assign Id To Element">
<arguments repr="locator, id">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="id" kind="POSITIONAL_OR_NAMED" required="true">
<name>id</name>
</arg>
</arguments>
<doc>Assigns a temporary identifier to the element identified by ``locator``.

This is mainly useful, when the locator is a complicated and slow XPath expression. The identifier expires when the page is reloaded.

Example:
 | Assign ID to Element | xpath://div[@id=\"first_div\"] | my id | 
 | Page Should Contain Element | my id |</doc>
<shortdoc>Assigns a temporary identifier to the element identified by ``locator``.</shortdoc>
</kw>
<kw name="Capture Page Screenshot">
<arguments repr="filename=selenium-screenshot-{index}.png">
<arg repr="filename=selenium-screenshot-{index}.png" kind="POSITIONAL_OR_NAMED" required="false">
<name>filename</name>
<default>selenium-screenshot-{index}.png</default>
</arg>
</arguments>
<doc>Take a screenshot of the current page and embed it into the log.

The ``filename`` argument specifies the name of the file to write the screenshot into. If no filename is given, the screenshot is saved into file selenium-screenshot-{index}.png under the directory where the Robot Framework log file is written into. The filename is also considered relative to the same directory, if it is not given in absolute format.

if ``filename`` contains marker {index}, it will be automatically replaced with unique running index preventing files to be overwritten. Indices start from 1.

A CSS can be used to modify how the screenshot is taken. By default the background color is changed to avoid possible problems with background leaking when the page layout is somehow broken.</doc>
<shortdoc>Take a screenshot of the current page and embed it into the log.</shortdoc>
</kw>
<kw name="Checkbox Should Be Selected">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Verify the checkbox identified by ``locator``is selected/checked.

Key attributes for checkboxes are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the checkbox identified by ``locator``is selected/checked.</shortdoc>
</kw>
<kw name="Checkbox Should Not Be Selected">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Verify the checkbox identified by ``locator``is not selected/checked.

Key attributes for checkboxes are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the checkbox identified by ``locator``is not selected/checked.</shortdoc>
</kw>
<kw name="Choose Cancel On Confirmation">
<arguments repr="">
</arguments>
<doc>Cancel will as default be selected from now on every time a confirmation dialog appears.

Note that every time a confirmation comes up, it must be confirmed by the keywords `Alert Should Be Present` or `Confirm Action`. Otherwise all following operations will fail.</doc>
<shortdoc>Cancel will as default be selected from now on every time a confirmation dialog appears.</shortdoc>
</kw>
<kw name="Choose Cancel On Next Confirmation">
<arguments repr="">
</arguments>
<doc>Cancel will be selected the next time a confirmation dialog appears.

Note that every time a confirmation comes up, it must be confirmed by the keywords `Alert Should Be Present` or `Confirm Action`. Otherwise all following operations will fail.</doc>
<shortdoc>Cancel will be selected the next time a confirmation dialog appears.</shortdoc>
</kw>
<kw name="Choose File">
<arguments repr="locator, filePath">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="filePath" kind="POSITIONAL_OR_NAMED" required="true">
<name>filePath</name>
</arg>
</arguments>
<doc>Types the given ``filePath`` into the input field identified by ``locator``.

This keyword is most often used to input files into upload forms. The file specified with filePath must be available on the same host where the Selenium Server is running.

Example:
| Choose File | my_upload_field | /home/user/files/trades.csv |
Key attributes for input fields are id and name. See Introduction for details about locators.</doc>
<shortdoc>Types the given ``filePath`` into the input field identified by ``locator``.</shortdoc>
</kw>
<kw name="Choose Ok On Confirmation">
<arguments repr="">
</arguments>
<doc>OK will as default be selected from now on every time a confirmation dialog appears.

Note that every time a confirmation comes up, it must be confirmed by the keywords `Alert Should Be Present` or `Confirm Action`. Otherwise all following operations will fail.</doc>
<shortdoc>OK will as default be selected from now on every time a confirmation dialog appears.</shortdoc>
</kw>
<kw name="Choose Ok On Next Confirmation">
<arguments repr="">
</arguments>
<doc>OK will be selected the next time a confirmation dialog appears.

Note that every time a confirmation comes up, it must be confirmed by the keywords `Alert Should Be Present` or `Confirm Action`. Otherwise all following operations will fail.</doc>
<shortdoc>OK will be selected the next time a confirmation dialog appears.</shortdoc>
</kw>
<kw name="Clear Element Text">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Clears the text from element identified by ``locator``.

This keyword does not execute any checks on whether or not the clear method has succeeded, so if any subsequent checks are needed, they should be executed using method `Element Text Should Be`.

Also, this method will use WebDriver's internal _element.clear()_ method, i.e. it will not send any keypresses, and it will not have any effect whatsoever on elements other than input textfields or input textareas. Clients relying on keypresses should implement their own methods.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Clears the text from element identified by ``locator``.</shortdoc>
</kw>
<kw name="Click Button">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Click on the button identified by ``locator``.

Key attributes for buttons are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Click on the button identified by ``locator``.</shortdoc>
</kw>
<kw name="Click Element">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Click on the element identified by ``locator``.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Click on the element identified by ``locator``.</shortdoc>
</kw>
<kw name="Click Element At Coordinates">
<arguments repr="locator, xOffset, yOffset">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="xOffset" kind="POSITIONAL_OR_NAMED" required="true">
<name>xOffset</name>
</arg>
<arg repr="yOffset" kind="POSITIONAL_OR_NAMED" required="true">
<name>yOffset</name>
</arg>
</arguments>
<doc>Click on the element identified by locator at the coordinates ``xOffset`` and ``yOffset``.

The cursor is moved at the center of the element and the to the given x/y offset from that point. Both offsets are specified as negative (left/up) or positive (right/down) number.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Click on the element identified by locator at the coordinates ``xOffset`` and ``yOffset``.</shortdoc>
</kw>
<kw name="Click Element By Index">
<arguments repr="xpath, index=0, message=NONE">
<arg repr="xpath" kind="POSITIONAL_OR_NAMED" required="true">
<name>xpath</name>
</arg>
<arg repr="index=0" kind="POSITIONAL_OR_NAMED" required="false">
<name>index</name>
<default>0</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Click to element from list elements by locator ``xpath``.</doc>
<shortdoc>Click to element from list elements by locator ``xpath``.</shortdoc>
</kw>
<kw name="Click Image">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Click on the image identified by ``locator``.

Key attributes for images are id, src and alt. See `Introduction` for details about locators.</doc>
<shortdoc>Click on the image identified by ``locator``.</shortdoc>
</kw>
<kw name="Click Link">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Click on the link identified by ``locator``.

Key attributes for links are id, name, href and link text. See `Introduction` for details about locators.</doc>
<shortdoc>Click on the link identified by ``locator``.</shortdoc>
</kw>
<kw name="Close All Browsers">
<arguments repr="">
</arguments>
<doc>Closes all open browsers and resets the browser cache.

After this keyword new indexes returned from `Open Browser` keyword are reset to 1.

This keyword should be used in test or suite teardown to make sure all browsers are closed.</doc>
<shortdoc>Closes all open browsers and resets the browser cache.</shortdoc>
</kw>
<kw name="Close Browser">
<arguments repr="">
</arguments>
<doc>Closes the current browser instance.</doc>
<shortdoc>Closes the current browser instance.</shortdoc>
</kw>
<kw name="Close Window">
<arguments repr="">
</arguments>
<doc>Closes the currently open pop-up window.</doc>
<shortdoc>Closes the currently open pop-up window.</shortdoc>
</kw>
<kw name="Confirm Action">
<arguments repr="">
</arguments>
<doc>Dismisses currently shown confirmation dialog and returns its message.

By default, this keyword chooses 'OK' option from the dialog. If 'Cancel' needs to be chosen, keyword `Choose Cancel On Next Confirmation` must be called before the action that causes the confirmation dialog to be shown.

Example:
 | Click Button | Send |  | # Shows a confirmation dialog | 
 | ${message}= | Confirm Action |  | # Chooses Ok | 
 | Should Be Equal | ${message} | Are your sure? | # Check dialog message | 
 | Choose Cancel On Next Confirmation |  |  | # Choose cancel on next Confirm Action | 
 | Click Button | Send |  | # Shows a confirmation dialog | 
 | Confirm Action |  |  | # Chooses Cancel |</doc>
<shortdoc>Dismisses currently shown confirmation dialog and returns its message.</shortdoc>
</kw>
<kw name="Current Frame Contains">
<arguments repr="text, logLevel=INFO">
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the current frame contains ``text``.

See `Introduction` for details about log levels.</doc>
<shortdoc>Verify the current frame contains ``text``.</shortdoc>
</kw>
<kw name="Current Frame Should Not Contain">
<arguments repr="text, logLevel=INFO">
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the current frame does not contain ``text``.

See `Introduction` for details about log levels.</doc>
<shortdoc>Verify the current frame does not contain ``text``.</shortdoc>
</kw>
<kw name="Delete All Cookies">
<arguments repr="">
</arguments>
<doc>Deletes all cookies.</doc>
<shortdoc>Deletes all cookies.</shortdoc>
</kw>
<kw name="Delete Cookie">
<arguments repr="name">
<arg repr="name" kind="POSITIONAL_OR_NAMED" required="true">
<name>name</name>
</arg>
</arguments>
<doc>Deletes cookie matching ``name``.

If the cookie is not found, nothing happens.</doc>
<shortdoc>Deletes cookie matching ``name``.</shortdoc>
</kw>
<kw name="Double Click Element">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Double-Click on the element identified by ``locator``.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Double-Click on the element identified by ``locator``.</shortdoc>
</kw>
<kw name="Drag And Drop">
<arguments repr="source, target">
<arg repr="source" kind="POSITIONAL_OR_NAMED" required="true">
<name>source</name>
</arg>
<arg repr="target" kind="POSITIONAL_OR_NAMED" required="true">
<name>target</name>
</arg>
</arguments>
<doc>Drag the element identified by the locator ``source`` and move it on top of the element identified by the locator ``target``.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.

Example:
 | Drag And Drop | elem1 | elem2 | # Move elem1 over elem2 |</doc>
<shortdoc>Drag the element identified by the locator ``source`` and move it on top of the element identified by the locator ``target``.</shortdoc>
</kw>
<kw name="Drag And Drop By Offset">
<arguments repr="source, xOffset, yOffset">
<arg repr="source" kind="POSITIONAL_OR_NAMED" required="true">
<name>source</name>
</arg>
<arg repr="xOffset" kind="POSITIONAL_OR_NAMED" required="true">
<name>xOffset</name>
</arg>
<arg repr="yOffset" kind="POSITIONAL_OR_NAMED" required="true">
<name>yOffset</name>
</arg>
</arguments>
<doc>Drag the element identified by the locator ``source`` and move it on top of the element identified by the locator ``target``.

Both offsets are specified as negative (left/up) or positive (right/down) number.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.

Example:
 | Drag And Drop By Offset | elem1 | 50 | 35 | # Move elem1 50px right and 35px down. |</doc>
<shortdoc>Drag the element identified by the locator ``source`` and move it on top of the element identified by the locator ``target``.</shortdoc>
</kw>
<kw name="Element Should Be Clickable">
<arguments repr="locator, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Verify the element identified by ``locator`` is clickable.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the element identified by ``locator`` is clickable.</shortdoc>
</kw>
<kw name="Element Should Be Disabled">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Verify the element identified by ``locator`` is disabled.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the element identified by ``locator`` is disabled.</shortdoc>
</kw>
<kw name="Element Should Be Enabled">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Verify the element identified by ``locator`` is enabled

Key attributes for arbitrary elements are id and name. See `Introduction` for details about log levels and locators.</doc>
<shortdoc>Verify the element identified by ``locator`` is enabled</shortdoc>
</kw>
<kw name="Element Should Be Focused">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Verify the element identified by ``locator`` is focused

Key attributes for arbitrary elements are id and name. See `Introduction` for details about log levels and locators.</doc>
<shortdoc>Verify the element identified by ``locator`` is focused</shortdoc>
</kw>
<kw name="Element Should Be Selected">
<arguments repr="locator, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Verify the element identified by ``locator`` is selected.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the element identified by ``locator`` is selected.</shortdoc>
</kw>
<kw name="Element Should Be Visible">
<arguments repr="locator, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Verify the element identified by ``locator`` is visible.

Herein, visible means that the element is logically visible, not optically visible in the current browser viewport. For example, an element that carries display:none is not logically visible, so using this keyword on that element would fail.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the element identified by ``locator`` is visible.</shortdoc>
</kw>
<kw name="Element Should Contain">
<arguments repr="locator, text, message=NONE, ignore_case=False">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="ignore_case=False" kind="POSITIONAL_OR_NAMED" required="false">
<name>ignore_case</name>
<default>False</default>
</arg>
</arguments>
<doc>Verify the element identified by ``locator`` contains ``text``.

See `Introduction` for details about locators.</doc>
<shortdoc>Verify the element identified by ``locator`` contains ``text``.</shortdoc>
</kw>
<kw name="Element Should Not Be Clickable">
<arguments repr="locator, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Verify the element identified by ``locator`` is not clickable.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the element identified by ``locator`` is not clickable.</shortdoc>
</kw>
<kw name="Element Should Not Be Selected">
<arguments repr="locator, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Verify the element identified by ``locator`` is not selected.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the element identified by ``locator`` is not selected.</shortdoc>
</kw>
<kw name="Element Should Not Be Visible">
<arguments repr="locator, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Verify the element identified by ``locator`` is not visible.

Herein, visible means that the element is logically visible, not optically visible in the current browser viewport. For example, an element that carries display:none is not logically visible, so using this keyword on that element would fail.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the element identified by ``locator`` is not visible.</shortdoc>
</kw>
<kw name="Element Should Not Contain">
<arguments repr="locator, text, message=NONE, ignore_case=False">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="ignore_case=False" kind="POSITIONAL_OR_NAMED" required="false">
<name>ignore_case</name>
<default>False</default>
</arg>
</arguments>
<doc>Verify the element identified by ``locator`` does not contain ``text``.

See `Introduction` for details about locators.</doc>
<shortdoc>Verify the element identified by ``locator`` does not contain ``text``.</shortdoc>
</kw>
<kw name="Element Text Should Be">
<arguments repr="locator, text, message=NONE, ignore_case=False">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="ignore_case=False" kind="POSITIONAL_OR_NAMED" required="false">
<name>ignore_case</name>
<default>False</default>
</arg>
</arguments>
<doc>Verify the text of the element identified by ``locator`` is exactly ``text``.

In contrast to `Element Should Contain`, this keyword does not try a substring match but an exact match on the element identified by locator.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the text of the element identified by ``locator`` is exactly ``text``.</shortdoc>
</kw>
<kw name="Element Text Should Not Be">
<arguments repr="locator, text, message=NONE, ignore_case=False">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="ignore_case=False" kind="POSITIONAL_OR_NAMED" required="false">
<name>ignore_case</name>
<default>False</default>
</arg>
</arguments>
<doc>Verify the text of the element identified by ``locator`` is not exactly ``text``.

In contrast to `Element Should Not Contain`, this keyword does not try a substring match but an exact match on the element identified by locator.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the text of the element identified by ``locator`` is not exactly ``text``.</shortdoc>
</kw>
<kw name="Execute Async Javascript">
<arguments repr="*code">
<arg repr="*code" kind="VAR_POSITIONAL" required="false">
<name>code</name>
</arg>
</arguments>
<doc>Execute the given JavaScript ``code`` asynchronously.

The given code may contain multiple lines of code, but must contain a return statement (with the value to be returned) at the end.

The given code may be divided into multiple cells in the test data. In that case, the parts are concatenated together without adding spaces. If the given code is an absolute path to an existing file, the JavaScript to execute will be read from that file. Forward slashes work as a path separator on all operating systems.

Note that by default the code will be executed 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')_.

Example:
 | Execute Async JavaScript | return window.my_js_function('arg1', 'arg2'); | # Directly execute the JavaScript | 
 | Execute Async JavaScript | ${CURDIR}/js_to_execute.js | # Load the JavaScript to execute from file |</doc>
<shortdoc>Execute the given JavaScript ``code`` asynchronously.</shortdoc>
</kw>
<kw name="Execute Javascript">
<arguments repr="*code">
<arg repr="*code" kind="VAR_POSITIONAL" required="false">
<name>code</name>
</arg>
</arguments>
<doc>Execute the given JavaScript ``code``.

The given code may contain multiple lines of code, but must contain a return statement (with the value to be returned) at the end.

The given code may be divided into multiple cells in the test data. In that case, the parts are concatenated together without adding spaces. If the given code is an absolute path to an existing file, the JavaScript to execute will be read from that file. Forward slashes work as a path separator on all operating systems.

Note that by default the code will be executed 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')_.

Example:
 | Execute JavaScript | return window.my_js_function('arg1', 'arg2'); | # Directly execute the JavaScript | 
 | Execute JavaScript | ${CURDIR}/js_to_execute.js | # Load the JavaScript to execute from file |</doc>
<shortdoc>Execute the given JavaScript ``code``.</shortdoc>
</kw>
<kw name="Focus">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Set the focus to the element identified by ``locator``.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Set the focus to the element identified by ``locator``.</shortdoc>
</kw>
<kw name="Frame Should Contain">
<arguments repr="locator, text, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the frame identified by ``locator`` contains ``text``.

See `Introduction` for details about locators.</doc>
<shortdoc>Verify the frame identified by ``locator`` contains ``text``.</shortdoc>
</kw>
<kw name="Frame Should Not Contain">
<arguments repr="locator, text, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the frame identified by ``locator`` does not contain ``text``.

See `Introduction` for details about locators.</doc>
<shortdoc>Verify the frame identified by ``locator`` does not contain ``text``.</shortdoc>
</kw>
<kw name="Get Alert Message">
<arguments repr="">
</arguments>
<doc>Returns the text of current JavaScript alert.

This keyword will fail if no alert is present. Note that following keywords will fail unless the alert is confirmed by the keywords `Alert Should Be Present` or `Confirm Action`.</doc>
<shortdoc>Returns the text of current JavaScript alert.</shortdoc>
</kw>
<kw name="Get All Links">
<arguments repr="">
</arguments>
<doc>Returns a list containing ids of all links found in current page.

If a link has no id, an empty string will be in the list instead.</doc>
<shortdoc>Returns a list containing ids of all links found in current page.</shortdoc>
</kw>
<kw name="Get Cookie Value">
<arguments repr="name">
<arg repr="name" kind="POSITIONAL_OR_NAMED" required="true">
<name>name</name>
</arg>
</arguments>
<doc>Returns value of cookie found with ``name``.

If no cookie is found with name, this keyword fails.</doc>
<shortdoc>Returns value of cookie found with ``name``.</shortdoc>
</kw>
<kw name="Get Cookies">
<arguments repr="">
</arguments>
<doc>Returns all cookies of the current page.</doc>
<shortdoc>Returns all cookies of the current page.</shortdoc>
</kw>
<kw name="Get Css Value">
<arguments repr="attribute, locator">
<arg repr="attribute" kind="POSITIONAL_OR_NAMED" required="true">
<name>attribute</name>
</arg>
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Get the value of a given CSS property.</doc>
<shortdoc>Get the value of a given CSS property.</shortdoc>
</kw>
<kw name="Get Element Attribute">
<arguments repr="locator, attribute=None">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="attribute=None" kind="POSITIONAL_OR_NAMED" required="false">
<name>attribute</name>
<default>None</default>
</arg>
</arguments>
<doc>Returns value of attribute from element locator.

See the `Locating elements` section for details about the locator syntax.

Example: ${id}=    Get Element Attribute   css:h1  id

Passing attribute name as part of the locator was removed in SeleniumLibrary 3.2. The explicit attribute argument should be used instead.</doc>
<shortdoc>Returns value of attribute from element locator.</shortdoc>
</kw>
<kw name="Get Horizontal Position">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Returns horizontal position of element identified by ``locator``.

The position is returned in pixels off the left side of the page, as an integer. Fails if the matching element is not found.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Returns horizontal position of element identified by ``locator``.</shortdoc>
</kw>
<kw name="Get Inner Element Id">
<arguments repr="locator, matchid, index">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="matchid" kind="POSITIONAL_OR_NAMED" required="true">
<name>matchid</name>
</arg>
<arg repr="index" kind="POSITIONAL_OR_NAMED" required="true">
<name>index</name>
</arg>
</arguments>
<doc>Returns inner element id by index```` of element identified by ``locator`` which is matched by ``matchid``.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Returns inner element id by index```` of element identified by ``locator`` which is matched by ``matchid``.</shortdoc>
</kw>
<kw name="Get List Items">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Returns the values in the select list identified by ``locator``.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Returns the values in the select list identified by ``locator``.</shortdoc>
</kw>
<kw name="Get Location">
<arguments repr="">
</arguments>
<doc>Returns the current browser URL.</doc>
<shortdoc>Returns the current browser URL.</shortdoc>
</kw>
<kw name="Get Locations">
<arguments repr="">
</arguments>
<doc>Returns and logs URLs of all known browser windows.</doc>
<shortdoc>Returns and logs URLs of all known browser windows.</shortdoc>
</kw>
<kw name="Get Matching Xpath Count">
<arguments repr="xpath">
<arg repr="xpath" kind="POSITIONAL_OR_NAMED" required="true">
<name>xpath</name>
</arg>
</arguments>
<doc>Returns the number of elements located the given ``xpath``.
 
If you wish to assert the number of located elements, use `Xpath Should Match X Times`.</doc>
<shortdoc>Returns the number of elements located the given ``xpath``.</shortdoc>
</kw>
<kw name="Get Remote Capabilities">
<arguments repr="">
</arguments>
<doc>     * Returns the actually supported capabilities of the remote browser instance.
     * 
Not all server implementations will support every WebDriver feature. Therefore, the client and server should use JSON objects with the properties listed below when describing which features a user requests that a session support. &lt;b&gt;If a session cannot support a capability that is requested in the desired capabilities, no error is thrown;&lt;/b&gt; a read-only capabilities object is returned that indicates the capabilities the session actually supports. For more information see:[http://code.google.com/p/selenium/wiki/DesiredCapabilities|DesiredCapabilities]</doc>
<shortdoc>     * Returns the actually supported capabilities of the remote browser instance.      *  Not all server implementations will support every WebDriver feature. Therefore, the client and server should use JSON objects with the properties listed below when describing which features a user requests that a session support. &lt;b&gt;If a session cannot support a capability that is requested in the desired capabilities, no error is thrown;&lt;/b&gt; a read-only capabilities object is returned that indicates the capabilities the session actually supports. For more information see:[http://code.google.com/p/selenium/wiki/DesiredCapabilities|DesiredCapabilities]</shortdoc>
</kw>
<kw name="Get Remote Session Id">
<arguments repr="">
</arguments>
<doc>Returns the session id of the remote browser instance.</doc>
<shortdoc>Returns the session id of the remote browser instance.</shortdoc>
</kw>
<kw name="Get Selected List Label">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Returns the visible label of the first selected element from the select list identified by ``locator``.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Returns the visible label of the first selected element from the select list identified by ``locator``.</shortdoc>
</kw>
<kw name="Get Selected List Labels">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Returns the visible labels of the first selected element from the select list identified by ``locator``.

Fails if there is no selection.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Returns the visible labels of the first selected element from the select list identified by ``locator``.</shortdoc>
</kw>
<kw name="Get Selected List Value">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Returns the value of the first selected element from the select list identified by ``locator``.

The return value is read from the value attribute of the selected element.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Returns the value of the first selected element from the select list identified by ``locator``.</shortdoc>
</kw>
<kw name="Get Selected List Values">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Returns the values of the first selected element as a list from the select list identified by ``locator``.

Fails if there is no selection. The return values are read from the value attribute of the selected element.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Returns the values of the first selected element as a list from the select list identified by ``locator``.</shortdoc>
</kw>
<kw name="Get Selenium Implicit Wait">
<arguments repr="">
</arguments>
<doc>Returns the implicit wait time in seconds that is used by Selenium.</doc>
<shortdoc>Returns the implicit wait time in seconds that is used by Selenium.</shortdoc>
</kw>
<kw name="Get Selenium Speed">
<arguments repr="">
</arguments>
<doc>*(NOT IMPLEMENTED)*

Returns the delay in seconds that is waited after each Selenium command.</doc>
<shortdoc>*(NOT IMPLEMENTED)*</shortdoc>
</kw>
<kw name="Get Selenium Timeout">
<arguments repr="">
</arguments>
<doc>Returns the timeout in seconds that is used by various keywords.</doc>
<shortdoc>Returns the timeout in seconds that is used by various keywords.</shortdoc>
</kw>
<kw name="Get Source">
<arguments repr="">
</arguments>
<doc>Returns the entire HTML source of the current page or frame.</doc>
<shortdoc>Returns the entire HTML source of the current page or frame.</shortdoc>
</kw>
<kw name="Get System Info">
<arguments repr="">
</arguments>
<doc>Returns basic system information about the execution environment.</doc>
<shortdoc>Returns basic system information about the execution environment.</shortdoc>
</kw>
<kw name="Get Table Cell">
<arguments repr="tableLocator, row, column, logLevel=INFO">
<arg repr="tableLocator" kind="POSITIONAL_OR_NAMED" required="true">
<name>tableLocator</name>
</arg>
<arg repr="row" kind="POSITIONAL_OR_NAMED" required="true">
<name>row</name>
</arg>
<arg repr="column" kind="POSITIONAL_OR_NAMED" required="true">
<name>column</name>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Returns the content of the table cell at the coordinates ``row`` and ``column`` of the table identified by ``tableLocator``.

Row and column number start from 1. Header and footer rows are included in the count. That way also cell content from header or footer rows can be obtained with this keyword.

Key attributes for tables are id and name. See `Introduction` for details about locators and log levels.</doc>
<shortdoc>Returns the content of the table cell at the coordinates ``row`` and ``column`` of the table identified by ``tableLocator``.</shortdoc>
</kw>
<kw name="Get Text">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Returns the text of the element identified by ``locator``..

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Returns the text of the element identified by ``locator``..</shortdoc>
</kw>
<kw name="Get Title">
<arguments repr="">
</arguments>
<doc>Returns the title of current page.</doc>
<shortdoc>Returns the title of current page.</shortdoc>
</kw>
<kw name="Get Value">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Returns the value attribute of the element identified by ``locator``..

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Returns the value attribute of the element identified by ``locator``..</shortdoc>
</kw>
<kw name="Get Vertical Position">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Returns vertical position of element identified by ``locator``.

The position is returned in pixels off the left side of the page, as an integer. Fails if the matching element is not found.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Returns vertical position of element identified by ``locator``.</shortdoc>
</kw>
<kw name="Get Window Identifiers">
<arguments repr="">
</arguments>
<doc>Returns the id attributes of all windows known to the current browser instance.</doc>
<shortdoc>Returns the id attributes of all windows known to the current browser instance.</shortdoc>
</kw>
<kw name="Get Window Names">
<arguments repr="">
</arguments>
<doc>Returns the names of all windows known to the current browser instance.</doc>
<shortdoc>Returns the names of all windows known to the current browser instance.</shortdoc>
</kw>
<kw name="Get Window Size">
<arguments repr="">
</arguments>
<doc>Returns current window width and height as integers.

See also `Set Window Size`.

Example:

 | ${width} | ${height}= | Get Window Size |</doc>
<shortdoc>Returns current window width and height as integers.</shortdoc>
</kw>
<kw name="Get Window Titles">
<arguments repr="">
</arguments>
<doc>Returns the titles of all windows known to the current browser instance.</doc>
<shortdoc>Returns the titles of all windows known to the current browser instance.</shortdoc>
</kw>
<kw name="Go Back">
<arguments repr="">
</arguments>
<doc>Simulates the user clicking the "back" button on their browser.</doc>
<shortdoc>Simulates the user clicking the "back" button on their browser.</shortdoc>
</kw>
<kw name="Go To">
<arguments repr="url">
<arg repr="url" kind="POSITIONAL_OR_NAMED" required="true">
<name>url</name>
</arg>
</arguments>
<doc>Navigates the active browser instance to the provided URL.</doc>
<shortdoc>Navigates the active browser instance to the provided URL.</shortdoc>
</kw>
<kw name="Input Password">
<arguments repr="locator, text">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
</arguments>
<doc>Types the given ``text`` into the password field identified by ``locator``.

Key attributes for input fields are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Types the given ``text`` into the password field identified by ``locator``.</shortdoc>
</kw>
<kw name="Input Text">
<arguments repr="locator, text">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
</arguments>
<doc>Types the given ``text`` into the text field identified by ``locator``.

Key attributes for input fields are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Types the given ``text`` into the text field identified by ``locator``.</shortdoc>
</kw>
<kw name="List Selection Should Be">
<arguments repr="locator, *items">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="*items" kind="VAR_POSITIONAL" required="false">
<name>items</name>
</arg>
</arguments>
<doc>Verify the selection of the select list identified by ``locator``.

If you want to verify no option is selected, simply give no items.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the selection of the select list identified by ``locator``.</shortdoc>
</kw>
<kw name="List Should Have No Selections">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Verify the select list identified by ``locator`` has no selections.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the select list identified by ``locator`` has no selections.</shortdoc>
</kw>
<kw name="Location Should Be">
<arguments repr="url">
<arg repr="url" kind="POSITIONAL_OR_NAMED" required="true">
<name>url</name>
</arg>
</arguments>
<doc>Verify the current page URL is exactly ``url``.</doc>
<shortdoc>Verify the current page URL is exactly ``url``.</shortdoc>
</kw>
<kw name="Location Should Contain">
<arguments repr="url">
<arg repr="url" kind="POSITIONAL_OR_NAMED" required="true">
<name>url</name>
</arg>
</arguments>
<doc> Verify the current page URL contains ``url``</doc>
<shortdoc> Verify the current page URL contains ``url``</shortdoc>
</kw>
<kw name="Log Location">
<arguments repr="logLevel=INFO">
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Logs and returns the location of current browser instance.

See `Introduction` for details about the ``logLevel``.</doc>
<shortdoc>Logs and returns the location of current browser instance.</shortdoc>
</kw>
<kw name="Log Remote Capabilities">
<arguments repr="logLevel=INFO">
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Returns the actually supported capabilities of the remote browser instance.

Not all server implementations will support every WebDriver feature. Therefore, the client and server should use JSON objects with the properties listed below when describing which features a user requests that a session support. *If a session cannot support a capability that is requested in the desired capabilities, no error is thrown*; a read-only capabilities object is returned that indicates the capabilities the session actually supports. For more information see: [https://github.com/SeleniumHQ/selenium/wiki/DesiredCapabilities|DesiredCapabilities]

See `Introduction` for details about the ``logLevel``.</doc>
<shortdoc>Returns the actually supported capabilities of the remote browser instance.</shortdoc>
</kw>
<kw name="Log Remote Session Id">
<arguments repr="logLevel=INFO">
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Logs and returns the session id of the remote browser instance.

See `Introduction` for details about the ``logLevel``.</doc>
<shortdoc>Logs and returns the session id of the remote browser instance.</shortdoc>
</kw>
<kw name="Log Source">
<arguments repr="logLevel=INFO">
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Logs and returns the entire html source of the current page or frame.

See `Introduction` for details about the ``logLevel``.</doc>
<shortdoc>Logs and returns the entire html source of the current page or frame.</shortdoc>
</kw>
<kw name="Log System Info">
<arguments repr="logLevel=INFO">
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Logs and returns basic system information about the execution environment.

See `Introduction` for details about the ``logLevel``.</doc>
<shortdoc>Logs and returns basic system information about the execution environment.</shortdoc>
</kw>
<kw name="Log Title">
<arguments repr="logLevel=INFO">
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Logs and returns the title of current page.

See `Introduction` for details about the ``logLevel``.</doc>
<shortdoc>Logs and returns the title of current page.</shortdoc>
</kw>
<kw name="Log Window Identifiers">
<arguments repr="logLevel=INFO">
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Logs and returns the id attributes of all windows known to the current browser instance.</doc>
<shortdoc>Logs and returns the id attributes of all windows known to the current browser instance.</shortdoc>
</kw>
<kw name="Log Window Names">
<arguments repr="logLevel=INFO">
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Logs and returns the names of all windows known to the current browser instance.

See `Introduction` for details about the ``logLevel``.</doc>
<shortdoc>Logs and returns the names of all windows known to the current browser instance.</shortdoc>
</kw>
<kw name="Log Window Titles">
<arguments repr="logLevel=INFO">
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Logs and returns the titles of all windows known to the current browser instance.

See `Introduction` for details about the ``logLevel``.</doc>
<shortdoc>Logs and returns the titles of all windows known to the current browser instance.</shortdoc>
</kw>
<kw name="Maximize Browser Window">
<arguments repr="">
</arguments>
<doc>Maximizes current browser window.</doc>
<shortdoc>Maximizes current browser window.</shortdoc>
</kw>
<kw name="Mouse Down">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Simulates pressing the left mouse button on the element identified by ``locator``.

The element is pressed without releasing the mouse button.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Simulates pressing the left mouse button on the element identified by ``locator``.</shortdoc>
</kw>
<kw name="Mouse Down On Image">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Simulates pressing the left mouse button on the image identified by ``locator``.

The element is pressed without releasing the mouse button.

Key attributes for images are id, src and alt. See `Introduction` for details about locators.</doc>
<shortdoc>Simulates pressing the left mouse button on the image identified by ``locator``.</shortdoc>
</kw>
<kw name="Mouse Down On Link">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Simulates pressing the left mouse button on the link identified by  ``locator``.

The element is pressed without releasing the mouse button.

Key attributes for links are id, name, href and link text. See `Introduction` for details about locators.</doc>
<shortdoc>Simulates pressing the left mouse button on the link identified by  ``locator``.</shortdoc>
</kw>
<kw name="Mouse Out">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Simulates moving the mouse away from the element identified by ``locator``.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Simulates moving the mouse away from the element identified by ``locator``.</shortdoc>
</kw>
<kw name="Mouse Over">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Simulates moving the mouse over the element identified by ``locator``.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Simulates moving the mouse over the element identified by ``locator``.</shortdoc>
</kw>
<kw name="Mouse Up">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Simulates releasing the left mouse button on the element identified by ``locator``.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Simulates releasing the left mouse button on the element identified by ``locator``.</shortdoc>
</kw>
<kw name="Open Browser">
<arguments repr="url, browserName=firefox, alias=None, remoteUrl=None, desiredCapabilities=None, browserOptions=None, isWebDriverManager=false">
<arg repr="url" kind="POSITIONAL_OR_NAMED" required="true">
<name>url</name>
</arg>
<arg repr="browserName=firefox" kind="POSITIONAL_OR_NAMED" required="false">
<name>browserName</name>
<default>firefox</default>
</arg>
<arg repr="alias=None" kind="POSITIONAL_OR_NAMED" required="false">
<name>alias</name>
<default>None</default>
</arg>
<arg repr="remoteUrl=None" kind="POSITIONAL_OR_NAMED" required="false">
<name>remoteUrl</name>
<default>None</default>
</arg>
<arg repr="desiredCapabilities=None" kind="POSITIONAL_OR_NAMED" required="false">
<name>desiredCapabilities</name>
<default>None</default>
</arg>
<arg repr="browserOptions=None" kind="POSITIONAL_OR_NAMED" required="false">
<name>browserOptions</name>
<default>None</default>
</arg>
<arg repr="isWebDriverManager=false" kind="POSITIONAL_OR_NAMED" required="false">
<name>isWebDriverManager</name>
<default>false</default>
</arg>
</arguments>
<doc>Opens a new browser instance to the given ``url``.

The ``browser`` argument specifies which browser to use, and the supported browser are listed in the table below. The browser names are case-insensitive and some browsers have multiple supported names.
|    = Browser =    | = Name(s) =       |
| Firefox   | firefox, ff      |
| Firefox (headless)   | firefoxheadless, ffheadless      |
| Google Chrome     | googlechrome, chrome, gc |
| Google Chrome (headless)    | googlechromeheadless, chromeheadless, gcheadless |
| Internet Explorer | internetexplorer, ie     |
| Edge      | edge      |
| Edge (headless)     | edgeheadless      |
| Safari    | safari    |
| Android   | android   |
| Iphone    | iphone    |

To be able to actually use one of these browsers, you need to have a matching Selenium browser driver available. See the [https://github.com/Hi-Fi/robotframework-seleniumlibrary-java#browser-drivers|project documentation] for more details.

Optional ``alias`` is an alias given for this browser instance and it can be used for switching between browsers. An alternative approach for switching is using an index returned by this keyword. These indices start from 1, are incremented when new browsers are opened, and reset back to 1 when `Close All Browsers` is called. See `Switch Browser` for more information and examples.

Optional ``remote_url`` is the URL for a remote Selenium server. If you specify a value for a remote, you can also specify ``desired_capabilities`` to configure, for example, a proxy server for Internet Explorer or a browser and operating system when using [http://saucelabs.com|Sauce Labs]. Desired capabilities can be given as a dictionary. [https://github.com/SeleniumHQ/selenium/wiki/Capabilities| Selenium documentation] lists possible capabilities that can be enabled.

Optional ``ff_profile_dir`` is the path to the Firefox profile directory if you wish to overwrite the default profile Selenium uses. Notice that prior to SeleniumLibrary 3.0, the library contained its own profile that was used by default.

Examples:
| `Open Browser` | http://example.com | Chrome  |
| `Open Browser` | http://example.com | Firefox | alias=Firefox |
| `Open Browser` | http://example.com | Edge    | remote_url=http://127.0.0.1:4444/wd/hub |

If the provided configuration options are not enough, it is possible to use `Create Webdriver` to customize browser initialization even more.</doc>
<shortdoc>Opens a new browser instance to the given ``url``.</shortdoc>
</kw>
<kw name="Open Context Menu">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Opens the context menu on the element identified by ``locator``.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Opens the context menu on the element identified by ``locator``.</shortdoc>
</kw>
<kw name="Page Should Contain">
<arguments repr="text, logLevel=INFO">
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the current page contains ``text``.

See `Introduction` for details about log levels.</doc>
<shortdoc>Verify the current page contains ``text``.</shortdoc>
</kw>
<kw name="Page Should Contain Button">
<arguments repr="locator, message=NONE, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the button identified by ``locator`` is found on the current page.

Key attributes for buttons are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the button identified by ``locator`` is found on the current page.</shortdoc>
</kw>
<kw name="Page Should Contain Checkbox">
<arguments repr="locator, message=NONE, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the checkbox identified by ``locator``is found on the current page.

Key attributes for checkboxes are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the checkbox identified by ``locator``is found on the current page.</shortdoc>
</kw>
<kw name="Page Should Contain Element">
<arguments repr="locator, message=NONE, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the element identified by ``locator`` is found on the current page

Key attributes for arbitrary elements are id and name. See `Introduction` for details about log levels and locators.</doc>
<shortdoc>Verify the element identified by ``locator`` is found on the current page</shortdoc>
</kw>
<kw name="Page Should Contain Image">
<arguments repr="locator, message=NONE, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the image identified by ``locator`` is found on the current page.

Key attributes for images are id, src and alt. See `Introduction` for details about log levels and locators.</doc>
<shortdoc>Verify the image identified by ``locator`` is found on the current page.</shortdoc>
</kw>
<kw name="Page Should Contain Link">
<arguments repr="locator, message=NONE, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the link identified by ``locator`` is found on the current page.

Key attributes for links are id, name, href and link text. See `Introduction` for details about log levels and locators.</doc>
<shortdoc>Verify the link identified by ``locator`` is found on the current page.</shortdoc>
</kw>
<kw name="Page Should Contain List">
<arguments repr="locator, message=NONE, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the select list identified by ``locator`` is found on the current page.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the select list identified by ``locator`` is found on the current page.</shortdoc>
</kw>
<kw name="Page Should Contain Radio Button">
<arguments repr="locator, message=NONE, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the radio button identified by ``locator``is found on the current page.

Key attributes for radio buttons are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the radio button identified by ``locator``is found on the current page.</shortdoc>
</kw>
<kw name="Page Should Contain Textfield">
<arguments repr="locator, message=NONE, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the text field identified by ``locator`` is found on the current page.

Key attributes for input fields are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the text field identified by ``locator`` is found on the current page.</shortdoc>
</kw>
<kw name="Page Should Not Contain">
<arguments repr="text, logLevel=INFO">
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the current page does not contain ``text``.

See `Introduction` for details about log levels.</doc>
<shortdoc>Verify the current page does not contain ``text``.</shortdoc>
</kw>
<kw name="Page Should Not Contain Button">
<arguments repr="locator, message=NONE, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the button identified by ``locator`` is not found on the current page.

Key attributes for buttons are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the button identified by ``locator`` is not found on the current page.</shortdoc>
</kw>
<kw name="Page Should Not Contain Checkbox">
<arguments repr="locator, message=NONE, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the checkbox identified by ``locator``is not found on the current page.

Key attributes for checkboxes are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the checkbox identified by ``locator``is not found on the current page.</shortdoc>
</kw>
<kw name="Page Should Not Contain Element">
<arguments repr="locator, message=NONE, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the element identified by ``locator`` is not found on the current page

Key attributes for arbitrary elements are id and name. See `Introduction` for details about log levels and locators.</doc>
<shortdoc>Verify the element identified by ``locator`` is not found on the current page</shortdoc>
</kw>
<kw name="Page Should Not Contain Image">
<arguments repr="locator, message=NONE, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the image identified by ``locator`` is not found on the current page.

Key attributes for images are id, src and alt. See `Introduction` for details about log levels and locators.</doc>
<shortdoc>Verify the image identified by ``locator`` is not found on the current page.</shortdoc>
</kw>
<kw name="Page Should Not Contain Link">
<arguments repr="locator, message=NONE, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the link identified by ``locator`` is not found on the current page.

Key attributes for links are id, name, href and link text. See `Introduction` for details about log levels and locators.</doc>
<shortdoc>Verify the link identified by ``locator`` is not found on the current page.</shortdoc>
</kw>
<kw name="Page Should Not Contain List">
<arguments repr="locator, message=NONE, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the select list identified by ``locator`` is not found on the current page.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the select list identified by ``locator`` is not found on the current page.</shortdoc>
</kw>
<kw name="Page Should Not Contain Radio Button">
<arguments repr="locator, message=NONE, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the radio button identified by ``locator``is not found on the current page.

Key attributes for radio buttons are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the radio button identified by ``locator``is not found on the current page.</shortdoc>
</kw>
<kw name="Page Should Not Contain Textfield">
<arguments repr="locator, message=NONE, logLevel=INFO">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the text field identified by ``locator`` is not found on the current page.

Key attributes for input fields are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the text field identified by ``locator`` is not found on the current page.</shortdoc>
</kw>
<kw name="Press Key">
<arguments repr="locator, key">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="key" kind="POSITIONAL_OR_NAMED" required="true">
<name>key</name>
</arg>
</arguments>
<doc>Simulates pressing key on the element identified by ``locator``.

Key is either a single character, or a numerical ASCII code of the key lead by '\\'.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.

Example:
 | Press Key | text_field | q | # Press 'q' | 
 | Press Key | login_button | \\13 | # ASCII code for enter key |</doc>
<shortdoc>Simulates pressing key on the element identified by ``locator``.</shortdoc>
</kw>
<kw name="Radio Button Should Be Set To">
<arguments repr="groupName, value">
<arg repr="groupName" kind="POSITIONAL_OR_NAMED" required="true">
<name>groupName</name>
</arg>
<arg repr="value" kind="POSITIONAL_OR_NAMED" required="true">
<name>value</name>
</arg>
</arguments>
<doc>Verify the radio button group identified by ``groupName``has its selection set to ``value``.

See `Select Radio Button` for details about locating radio buttons.</doc>
<shortdoc>Verify the radio button group identified by ``groupName``has its selection set to ``value``.</shortdoc>
</kw>
<kw name="Radio Button Should Not Be Selected">
<arguments repr="groupName">
<arg repr="groupName" kind="POSITIONAL_OR_NAMED" required="true">
<name>groupName</name>
</arg>
</arguments>
<doc>Verify the radio button group identified by ``groupName``has no selection.

See `Select Radio Button` for details about locating radio buttons.</doc>
<shortdoc>Verify the radio button group identified by ``groupName``has no selection.</shortdoc>
</kw>
<kw name="Register Keyword To Run On Failure">
<arguments repr="keyword">
<arg repr="keyword" kind="POSITIONAL_OR_NAMED" required="true">
<name>keyword</name>
</arg>
</arguments>
<doc>Sets the actual and returns the previous keyword to execute when a SeleniumLibrary keyword fails.

The keyword is the name of a keyword (from any available libraries) that will be executed, if a SeleniumLibrary keyword fails. It is not possible to use a keyword that requires arguments. Using the value *Nothing* will disable this feature altogether.

The initial keyword to use is set at importing the library and the keyword that is used by default is `Capture Page Screenshot`. Taking a screenshot when something failed is a very useful feature, but notice that it can slow down the execution.

This keyword returns the name of the previously registered failure keyword. It can be used to restore the original value later.

Example:
 | Register Keyword To Run On Failure | Log Source |  | # Run Log Source on failure. | 
 | ${previous kw}= | Register Keyword To Run On Failure | Nothing | # Disable run-on-failure functionality and stors the previous kw name in a variable. | 
 | Register Keyword To Run On Failure | ${previous kw} |  | # Restore to the previous keyword. |</doc>
<shortdoc>Sets the actual and returns the previous keyword to execute when a SeleniumLibrary keyword fails.</shortdoc>
</kw>
<kw name="Reload Page">
<arguments repr="">
</arguments>
<doc>Simulates user reloading page.</doc>
<shortdoc>Simulates user reloading page.</shortdoc>
</kw>
<kw name="Select All From List">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Select all values of the multi-select list identified by ``locator``.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Select all values of the multi-select list identified by ``locator``.</shortdoc>
</kw>
<kw name="Select Checkbox">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Select the checkbox identified by ``locator``.

Does nothing, if the checkbox is already selected.

Key attributes for checkboxes are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Select the checkbox identified by ``locator``.</shortdoc>
</kw>
<kw name="Select Frame">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Sets frame identified by ``locator`` as the current frame.

See the `Locating elements` section for details about the locator syntax.

Works both with frames and iframes. Use `Unselect Frame` to cancel the frame selection and return to the main frame.

Example:

 | Select Frame | top-frame | # Select frame with id or name 'top-frame' | 
 | Click Link | example | # Click link 'example' in the selected frame | 
 | Unselect Frame |  | # Back to main frame. | 
 | Select Frame | //iframe[@name='xxx'] | # Select frame using xpath |</doc>
<shortdoc>Sets frame identified by ``locator`` as the current frame.</shortdoc>
</kw>
<kw name="Select From List">
<arguments repr="locator, *items">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="*items" kind="VAR_POSITIONAL" required="false">
<name>items</name>
</arg>
</arguments>
<doc>Select the given ``*items`` of the multi-select list identified by ``locator``.

An exception is raised for a single-selection list if the last value does not exist in the list and a warning for all other non-existing items. For a multi-selection list, an exception is raised for any and all non-existing values.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Select the given ``*items`` of the multi-select list identified by ``locator``.</shortdoc>
</kw>
<kw name="Select From List By Index">
<arguments repr="locator, *indexes">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="*indexes" kind="VAR_POSITIONAL" required="false">
<name>indexes</name>
</arg>
</arguments>
<doc>Select the given ``*indexes`` of the multi-select list identified by ``locator``.

Tries to select by value AND by label. It's generally faster to use 'by index/value/label' keywords.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Select the given ``*indexes`` of the multi-select list identified by ``locator``.</shortdoc>
</kw>
<kw name="Select From List By Label">
<arguments repr="locator, *labels">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="*labels" kind="VAR_POSITIONAL" required="false">
<name>labels</name>
</arg>
</arguments>
<doc>Select the given ``*labels`` of the multi-select list identified by ``locator``.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Select the given ``*labels`` of the multi-select list identified by ``locator``.</shortdoc>
</kw>
<kw name="Select From List By Value">
<arguments repr="locator, *values">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="*values" kind="VAR_POSITIONAL" required="false">
<name>values</name>
</arg>
</arguments>
<doc>Select the given ``*values`` of the multi-select list identified by ``locator``.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Select the given ``*values`` of the multi-select list identified by ``locator``.</shortdoc>
</kw>
<kw name="Select Radio Button">
<arguments repr="groupName, value">
<arg repr="groupName" kind="POSITIONAL_OR_NAMED" required="true">
<name>groupName</name>
</arg>
<arg repr="value" kind="POSITIONAL_OR_NAMED" required="true">
<name>value</name>
</arg>
</arguments>
<doc>Sets the selection of the radio button group identified by ``groupName`` to ``value``.

Example:
 | Select Radio Button | size | XL | # Matches HTML like &lt;input type="radio" name="size" value="XL"&gt;XL&lt;/input&gt; | 
 | Select Radio Button | size | sizeXL | # Matches HTML like &lt;input type="radio" name="size" value="XL" id="sizeXL"&gt;XL&lt;/input&gt; |</doc>
<shortdoc>Sets the selection of the radio button group identified by ``groupName`` to ``value``.</shortdoc>
</kw>
<kw name="Select Window">
<arguments repr="locator=MAIN">
<arg repr="locator=MAIN" kind="POSITIONAL_OR_NAMED" required="false">
<name>locator</name>
<default>MAIN</default>
</arg>
</arguments>
<doc>Selects the window identified by ``locator`` as the context of actions.

If the window is found, all subsequent commands use that window, until this keyword is used again. If the window is not found, this keyword fails.

By default, when a ``locator`` value is provided, it is matched against the title of the window and the javascript name of the window. If multiple windows with same identifier are found, the first one is selected.

The special locator *MAIN* (default) can be used to select the main window.

Example:

 | Click Link | popup_link | # opens new window | 
 | Select Window | popupName |  | 
 | Title Should Be | Popup Title |  | 
 | Select Window |  | # Chooses the main window again |

It is also possible to specify the approach SeleniumLibrary should take to find a window by specifying a locator strategy. See Introduction for details about locators:

 | = Strategy = | = Example = | = Description = | 
 | title | Select Window | title:My Document | Matches by window title | 
 | name | Select Window | name:${name} | Matches by window javascript name | 
 | url | Select Window | url:http://google.com | Matches by window's current URL |</doc>
<shortdoc>Selects the window identified by ``locator`` as the context of actions.</shortdoc>
</kw>
<kw name="Set Browser Implicit Wait">
<arguments repr="timestr">
<arg repr="timestr" kind="POSITIONAL_OR_NAMED" required="true">
<name>timestr</name>
</arg>
</arguments>
<doc>Sets and returns the implicit wait time in seconds that is used by the current Selenium 2 WebDriver instance.

From selenium 2 function: _Sets a sticky timeout to implicitly wait for an element to be found, or a command to complete. This method only needs to be called one time per session._

Example:
 | ${orig wait} = | Set Browser Implicit Wait | 10 seconds | 
 | # Perform AJAX call that is slow |  |  | 
 | Set Browser Implicit Wait | ${orig wait} | # Reset to old value |</doc>
<shortdoc>Sets and returns the implicit wait time in seconds that is used by the current Selenium 2 WebDriver instance.</shortdoc>
</kw>
<kw name="Set Focus To Element">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Set the focus to the element identified by ``locator``.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Set the focus to the element identified by ``locator``.</shortdoc>
</kw>
<kw name="Set Log Directory">
<arguments repr="logDirectory">
<arg repr="logDirectory" kind="POSITIONAL_OR_NAMED" required="true">
<name>logDirectory</name>
</arg>
</arguments>
<doc>Set the ``logDirectory``, where captured screenshots are stored, to some custom path.

Fails, if either the given path does not exist, is no directory or is not writable.</doc>
<shortdoc>Set the ``logDirectory``, where captured screenshots are stored, to some custom path.</shortdoc>
</kw>
<kw name="Set Remote Web Driver Proxy">
<arguments repr="host, port, username=None, password=None, domain=None, workstation=None">
<arg repr="host" kind="POSITIONAL_OR_NAMED" required="true">
<name>host</name>
</arg>
<arg repr="port" kind="POSITIONAL_OR_NAMED" required="true">
<name>port</name>
</arg>
<arg repr="username=None" kind="POSITIONAL_OR_NAMED" required="false">
<name>username</name>
<default>None</default>
</arg>
<arg repr="password=None" kind="POSITIONAL_OR_NAMED" required="false">
<name>password</name>
<default>None</default>
</arg>
<arg repr="domain=None" kind="POSITIONAL_OR_NAMED" required="false">
<name>domain</name>
<default>None</default>
</arg>
<arg repr="workstation=None" kind="POSITIONAL_OR_NAMED" required="false">
<name>workstation</name>
<default>None</default>
</arg>
</arguments>
<doc>Configures proxy handling for remote WebDriver instances.

This is needed to connect to an external Selenium 2 WebDriver rid through a local HTTP proxy. This implementation handles BASIC, DIGEST and NTLM based authentication schemes correctly.

The given configuration will be used for all subsequent calls of `Open Browser`. To remove the proxy call:
| Set Remote Web Driver Proxy | ${EMPTY} | ${EMPTY} |

Some additional info:
 - If no ``username`` is provided, it looks for a username at the Java property http.proxyUser and the environment variables HTTP_PROXY and http_proxy. If a username is found, it is only used, if the host and port also match.
 - If no ``password`` is provided, it looks for a password at the Java property http.proxyUser and the environment variables HTTP_PROXY and http_proxy. If a password is found, it is only used, if the host, port and username also match.
 - If a ``domain`` is provided, NTLM based authentication is used
 - If no ``workstation`` is provided and NTLM based authentication is used, the hostname is used as workstation name.</doc>
<shortdoc>Configures proxy handling for remote WebDriver instances.</shortdoc>
</kw>
<kw name="Set Screenshot Directory">
<arguments repr="path">
<arg repr="path" kind="POSITIONAL_OR_NAMED" required="true">
<name>path</name>
</arg>
</arguments>
<doc>Sets the directory for captured screenshots.

``path`` argument specifies the absolute path to a directory where the screenshots should be written to. If the directory does not exist, it will be created. The directory can also be set when `importing` the library. If it is not configured anywhere, screenshots are saved to the same directory where Robot Framework's log file is written.

The previous value is returned and can be used to restorethe original value later if needed.</doc>
<shortdoc>Sets the directory for captured screenshots.</shortdoc>
</kw>
<kw name="Set Selenium Implicit Wait">
<arguments repr="timestr">
<arg repr="timestr" kind="POSITIONAL_OR_NAMED" required="true">
<name>timestr</name>
</arg>
</arguments>
<doc>Sets and returns the implicit wait time in seconds that is used by all Selenium 2 WebDriver instances. This affects all currently open and from now on opened instances.

From selenium 2 function: _Sets a sticky timeout to implicitly wait for an element to be found, or a command to complete. This method only needs to be called one time per session._

Example:
 | ${orig wait} = | Set Selenium Implicit Wait | 10 seconds | 
 | # Perform AJAX call that is slow |  |  | 
 | Set Selenium Implicit Wait | ${orig wait} | # Reset to old value |</doc>
<shortdoc>Sets and returns the implicit wait time in seconds that is used by all Selenium 2 WebDriver instances. This affects all currently open and from now on opened instances.</shortdoc>
</kw>
<kw name="Set Selenium Speed">
<arguments repr="timestr">
<arg repr="timestr" kind="POSITIONAL_OR_NAMED" required="true">
<name>timestr</name>
</arg>
</arguments>
<doc>*(NOT IMPLEMENTED)* 

Sets the delay in seconds that is waited after each Selenium command.</doc>
<shortdoc>*(NOT IMPLEMENTED)* </shortdoc>
</kw>
<kw name="Set Selenium Timeout">
<arguments repr="timestr">
<arg repr="timestr" kind="POSITIONAL_OR_NAMED" required="true">
<name>timestr</name>
</arg>
</arguments>
<doc>Sets and returns the timeout in seconds that is used by various keywords.

There are several Wait ... keywords that take a timeout as an argument. All of these timeout arguments are optional. The timeout used by all of them can be set globally using this keyword. See `Introduction` for more information about timeouts.

The previous timeout value is returned by this keyword and can be used to set the old value back later. The default timeout is 5 seconds, but it can be altered in importing the library.

Example:
 | ${orig timeout} = | Set Selenium Timeout | 15 seconds | 
 | # Open page that loads slowly |  |  | 
 | Set Selenium Timeout | ${orig timeout} | # Reset to old value |</doc>
<shortdoc>Sets and returns the timeout in seconds that is used by various keywords.</shortdoc>
</kw>
<kw name="Set Window Size">
<arguments repr="width, height">
<arg repr="width" kind="POSITIONAL_OR_NAMED" required="true">
<name>width</name>
</arg>
<arg repr="height" kind="POSITIONAL_OR_NAMED" required="true">
<name>height</name>
</arg>
</arguments>
<doc>Sets current windows size to given `` width`` and ``height``.

Values can be given using strings containing numbers or by using actual numbers. See also `Get Window Size`.

Browsers have a limit how small they can be set. Trying to set them smaller will cause the actual size to be bigger than the requested size.

Example:

 | Set Window Size | 800 | 600 |</doc>
<shortdoc>Sets current windows size to given `` width`` and ``height``.</shortdoc>
</kw>
<kw name="Simulate">
<arguments repr="locator, event">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="event" kind="POSITIONAL_OR_NAMED" required="true">
<name>event</name>
</arg>
</arguments>
<doc>Simulates the given ``event`` on the element identified by ``locator``.

This keyword is especially useful, when the element has an OnEvent handler that needs to be explicitly invoked.

Key attributes for arbitrary elements are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Simulates the given ``event`` on the element identified by ``locator``.</shortdoc>
</kw>
<kw name="Sort Strings">
<arguments repr="list, order=ascending">
<arg repr="list" kind="POSITIONAL_OR_NAMED" required="true">
<name>list</name>
</arg>
<arg repr="order=ascending" kind="POSITIONAL_OR_NAMED" required="false">
<name>order</name>
<default>ascending</default>
</arg>
</arguments>
<doc>Returns sorting list of strings by ``order``.</doc>
<shortdoc>Returns sorting list of strings by ``order``.</shortdoc>
</kw>
<kw name="Submit Form">
<arguments repr="locator=NONE">
<arg repr="locator=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>locator</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Submit the form identified by ``locator``.

If the locator is empty, the first form in the page will be submitted.

Key attributes for forms are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Submit the form identified by ``locator``.</shortdoc>
</kw>
<kw name="Switch Browser">
<arguments repr="indexOrAlias">
<arg repr="indexOrAlias" kind="POSITIONAL_OR_NAMED" required="true">
<name>indexOrAlias</name>
</arg>
</arguments>
<doc>Switches between active browser instances using an index or an alias.

The index is returned from Open Browser and an alias can be given to it.

Example:

 | Open Browser | http://google.com | ff |  | 
 | Location Should Be | http://google.com |  |  | 
 | Open Browser | http://yahoo.com | ie | 2nd conn | 
 | Location Should Be | http://yahoo.com |  |  | 
 | Switch Browser | 1 | # index |  | 
 | Page Should Contain | I'm feeling lucky |  |  | 
 | Switch Browser | 2nd conn | # alias |  | 
 | Page Should Contain | More Yahoo! |  |  | 
 | Close All Browsers |  |  | 

The above example expects that there was no other open browsers when opening the first one because it used index '1' when switching to it later. If you aren't sure about that you can store the index into a variable as below.

 | ${id} = | Open Browser | http://google.com | 
 | # Do something ... |  |  | 
 | Switch Browser | ${id} |</doc>
<shortdoc>Switches between active browser instances using an index or an alias.</shortdoc>
</kw>
<kw name="Table Cell Should Contain">
<arguments repr="tableLocator, row, column, text, logLevel=INFO">
<arg repr="tableLocator" kind="POSITIONAL_OR_NAMED" required="true">
<name>tableLocator</name>
</arg>
<arg repr="row" kind="POSITIONAL_OR_NAMED" required="true">
<name>row</name>
</arg>
<arg repr="column" kind="POSITIONAL_OR_NAMED" required="true">
<name>column</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the content of the table cell at the coordinates ``row`` and ``column`` of the table identified by ``tableLocator`` contains ``text``.

Row and column number start from 1. Header and footer rows are included in the count. That way also cell content from header or footer rows can be obtained with this keyword.

Key attributes for tables are id and name. See `Introduction` for details about locators and log levels.</doc>
<shortdoc>Verify the content of the table cell at the coordinates ``row`` and ``column`` of the table identified by ``tableLocator`` contains ``text``.</shortdoc>
</kw>
<kw name="Table Column Should Contain">
<arguments repr="tableLocator, col, text, logLevel=INFO">
<arg repr="tableLocator" kind="POSITIONAL_OR_NAMED" required="true">
<name>tableLocator</name>
</arg>
<arg repr="col" kind="POSITIONAL_OR_NAMED" required="true">
<name>col</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the content of any table cells of the table ``column`` of the table identified by ``tableLocator`` contains ``text``.

Key attributes for tables are id and name. See `Introduction` for details about locators and log levels.

The first leftmost column is column number 1. If the table contains cells that span multiple columns, those merged cells count as a single column. For example both tests below work, if in one row columns A and B are merged with colspan="2", and the logical third column contains "C".

Example:
 | Table Column Should Contain | tableId | 3 | C | 
 | Table Column Should Contain | tableId | 2 | C |</doc>
<shortdoc>Verify the content of any table cells of the table ``column`` of the table identified by ``tableLocator`` contains ``text``.</shortdoc>
</kw>
<kw name="Table Footer Should Contain">
<arguments repr="tableLocator, text, logLevel=INFO">
<arg repr="tableLocator" kind="POSITIONAL_OR_NAMED" required="true">
<name>tableLocator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the content of any table footer cells of the table identified by ``tableLocator`` contains ``text``.

Key attributes for tables are id and name. See `Introduction` for details about locators and log levels.</doc>
<shortdoc>Verify the content of any table footer cells of the table identified by ``tableLocator`` contains ``text``.</shortdoc>
</kw>
<kw name="Table Header Should Contain">
<arguments repr="tableLocator, text, logLevel=INFO">
<arg repr="tableLocator" kind="POSITIONAL_OR_NAMED" required="true">
<name>tableLocator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the content of any table header cells of the table identified by ``tableLocator`` contains ``text``.

Key attributes for tables are id and name. See `Introduction` for details about locators and log levels.</doc>
<shortdoc>Verify the content of any table header cells of the table identified by ``tableLocator`` contains ``text``.</shortdoc>
</kw>
<kw name="Table Row Should Contain">
<arguments repr="tableLocator, row, text, logLevel=INFO">
<arg repr="tableLocator" kind="POSITIONAL_OR_NAMED" required="true">
<name>tableLocator</name>
</arg>
<arg repr="row" kind="POSITIONAL_OR_NAMED" required="true">
<name>row</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the content of any table cells of the table ``row`` of the table identified by ``tableLocator`` contains ``text``.

Key attributes for tables are id and name. See `Introduction` for details about locators and log levels.

The uppermost row is row number 1. For tables that are structured with thead, tbody and tfoot, only the tbody section is searched. Please use Table Header Should Contain or Table Footer Should Contain for tests against the header or footer content.

If the table contains cells that span multiple rows, a match only occurs for the uppermost row of those merged cells.</doc>
<shortdoc>Verify the content of any table cells of the table ``row`` of the table identified by ``tableLocator`` contains ``text``.</shortdoc>
</kw>
<kw name="Table Should Contain">
<arguments repr="tableLocator, text, logLevel=INFO">
<arg repr="tableLocator" kind="POSITIONAL_OR_NAMED" required="true">
<name>tableLocator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify the content of any table cells of the table identified by ``tableLocator`` contains ``text``.

Key attributes for tables are id and name. See `Introduction` for details about locators and log levels.</doc>
<shortdoc>Verify the content of any table cells of the table identified by ``tableLocator`` contains ``text``.</shortdoc>
</kw>
<kw name="Textarea Should Contain">
<arguments repr="locator, text, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Verify the text area identified by ``locator`` contains ``text``.

Key attributes for text areas are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the text area identified by ``locator`` contains ``text``.</shortdoc>
</kw>
<kw name="Textarea Should Not Contain">
<arguments repr="locator, text, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Verify the text area identified by ``locator`` does not contain ``text``.

Key attributes for text areas are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the text area identified by ``locator`` does not contain ``text``.</shortdoc>
</kw>
<kw name="Textarea Value Should Be">
<arguments repr="locator, text, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Verify the text area identified by ``locator`` is exactly ``text``.

Key attributes for text areas are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the text area identified by ``locator`` is exactly ``text``.</shortdoc>
</kw>
<kw name="Textarea Value Should Not Be">
<arguments repr="locator, text, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Verify the text area identified by ``locator`` is not exactly ``text``.

Key attributes for text areas are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the text area identified by ``locator`` is not exactly ``text``.</shortdoc>
</kw>
<kw name="Textfield Should Contain">
<arguments repr="locator, text, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Verify the text field identified by ``locator`` contains ``text``.

Key attributes for input fields are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the text field identified by ``locator`` contains ``text``.</shortdoc>
</kw>
<kw name="Textfield Should Not Contain">
<arguments repr="locator, text, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Verify the text field identified by ``locator`` does not contain ``text``.

Key attributes for input fields are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the text field identified by ``locator`` does not contain ``text``.</shortdoc>
</kw>
<kw name="Textfield Value Should Be">
<arguments repr="locator, text, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Verify the text field identified by ``locator`` is exactly ``text``.

Key attributes for input fields are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the text field identified by ``locator`` is exactly ``text``.</shortdoc>
</kw>
<kw name="Textfield Value Should Not Be">
<arguments repr="locator, text, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Verify the text field identified by ``locator`` is not exactly ``text``.

Key attributes for input fields are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Verify the text field identified by ``locator`` is not exactly ``text``.</shortdoc>
</kw>
<kw name="Title Should Be">
<arguments repr="title">
<arg repr="title" kind="POSITIONAL_OR_NAMED" required="true">
<name>title</name>
</arg>
</arguments>
<doc>Verify the current page title is exactly ``title``</doc>
<shortdoc>Verify the current page title is exactly ``title``</shortdoc>
</kw>
<kw name="Title Should Contain">
<arguments repr="title">
<arg repr="title" kind="POSITIONAL_OR_NAMED" required="true">
<name>title</name>
</arg>
</arguments>
<doc>Verify the current page title contains ``title``.</doc>
<shortdoc>Verify the current page title contains ``title``.</shortdoc>
</kw>
<kw name="Title Should Not Be">
<arguments repr="title">
<arg repr="title" kind="POSITIONAL_OR_NAMED" required="true">
<name>title</name>
</arg>
</arguments>
<doc>Verify the current page title is not exactly ``title``.</doc>
<shortdoc>Verify the current page title is not exactly ``title``.</shortdoc>
</kw>
<kw name="Title Should Not Contain">
<arguments repr="title">
<arg repr="title" kind="POSITIONAL_OR_NAMED" required="true">
<name>title</name>
</arg>
</arguments>
<doc>Verify the current page title does not contain ``title``.</doc>
<shortdoc>Verify the current page title does not contain ``title``.</shortdoc>
</kw>
<kw name="Unselect Checkbox">
<arguments repr="locator">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
</arguments>
<doc>Unselect the checkbox identified by ``locator``.

Does nothing, if the checkbox is not selected.

Key attributes for checkboxes are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Unselect the checkbox identified by ``locator``.</shortdoc>
</kw>
<kw name="Unselect Frame">
<arguments repr="">
</arguments>
<doc>Selects the top frame as the current frame.</doc>
<shortdoc>Selects the top frame as the current frame.</shortdoc>
</kw>
<kw name="Unselect From List">
<arguments repr="locator, *items">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="*items" kind="VAR_POSITIONAL" required="false">
<name>items</name>
</arg>
</arguments>
<doc>Unselect the given ``*items`` of the multi-select list identified by ``locator``.

As a special case, giving an empty *items list will remove all selections.

Tries to unselect by value AND by label. It's generally faster to use 'by index/value/label' keywords.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Unselect the given ``*items`` of the multi-select list identified by ``locator``.</shortdoc>
</kw>
<kw name="Unselect From List By Index">
<arguments repr="locator, *indexes">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="*indexes" kind="VAR_POSITIONAL" required="false">
<name>indexes</name>
</arg>
</arguments>
<doc>Unselect the given ``*indexes`` of the multi-select list identified by ``locator``.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Unselect the given ``*indexes`` of the multi-select list identified by ``locator``.</shortdoc>
</kw>
<kw name="Unselect From List By Label">
<arguments repr="locator, *labels">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="*labels" kind="VAR_POSITIONAL" required="false">
<name>labels</name>
</arg>
</arguments>
<doc>Unselect the given ``*labels`` of the multi-select list identified by ``locator``.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Unselect the given ``*labels`` of the multi-select list identified by ``locator``.</shortdoc>
</kw>
<kw name="Unselect From List By Value">
<arguments repr="locator, *values">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="*values" kind="VAR_POSITIONAL" required="false">
<name>values</name>
</arg>
</arguments>
<doc>Unselect the given ``*values`` of the multi-select list identified by ``locator``.

Select list keywords work on both lists and combo boxes. Key attributes for select lists are id and name. See `Introduction` for details about locators.</doc>
<shortdoc>Unselect the given ``*values`` of the multi-select list identified by ``locator``.</shortdoc>
</kw>
<kw name="Wait For Condition">
<arguments repr="condition, timeout=5s, message=NONE">
<arg repr="condition" kind="POSITIONAL_OR_NAMED" required="true">
<name>condition</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the given JavaScript ``condition`` is true.

Fails, if the timeout expires, before the condition gets true. 

The condition may contain multiple JavaScript statements, but the last statement must return a boolean. Otherwise this keyword will always hit the timeout.

Note that by default the code will be executed 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')_.

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the given JavaScript ``condition`` is true.</shortdoc>
</kw>
<kw name="Wait Until Element Attribute Value Contains">
<arguments repr="value, attribute, locator, timeout=NONE, message=NONE">
<arg repr="value" kind="POSITIONAL_OR_NAMED" required="true">
<name>value</name>
</arg>
<arg repr="attribute" kind="POSITIONAL_OR_NAMED" required="true">
<name>attribute</name>
</arg>
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="timeout=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>NONE</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the current WebElement attribute or CSS property will be containing value.</doc>
<shortdoc>Waits until the current WebElement attribute or CSS property will be containing value.</shortdoc>
</kw>
<kw name="Wait Until Element Is Clickable">
<arguments repr="locator, timeout=5s, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the element identified by ``locator`` is clickable.

Fails, if the timeout expires, before the element gets clickable. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the element identified by ``locator`` is clickable.</shortdoc>
</kw>
<kw name="Wait Until Element Is Not Clickable">
<arguments repr="locator, timeout=5s, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the element identified by ``locator`` is not clickable.

Fails, if the timeout expires, before the element gets unclickable. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the element identified by ``locator`` is not clickable.</shortdoc>
</kw>
<kw name="Wait Until Element Is Not Selected">
<arguments repr="locator, timeout=5s, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the element identified by ``locator`` is not selected.

Fails, if the timeout expires, before the element gets unselected. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the element identified by ``locator`` is not selected.</shortdoc>
</kw>
<kw name="Wait Until Element Is Not Visible">
<arguments repr="locator, timeout=5s, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the element identified by ``locator`` is not visible.

Fails, if the timeout expires, before the element gets invisible. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the element identified by ``locator`` is not visible.</shortdoc>
</kw>
<kw name="Wait Until Element Is Selected">
<arguments repr="locator, timeout=5s, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the element identified by ``locator`` is selected.

Fails, if the timeout expires, before the element gets selected. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the element identified by ``locator`` is selected.</shortdoc>
</kw>
<kw name="Wait Until Element Is Successfully Clicked">
<arguments repr="locator, timeout=5s, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the element identified by ``locator`` is succesfully clicked on.

Fails, if the timeout expires, before the element gets clicked on. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the element identified by ``locator`` is succesfully clicked on.</shortdoc>
</kw>
<kw name="Wait Until Element Is Visible">
<arguments repr="locator, timeout=5s, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the element identified by ``locator`` is visible.

Fails, if the timeout expires, before the element gets visible. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the element identified by ``locator`` is visible.</shortdoc>
</kw>
<kw name="Wait Until Page Contains">
<arguments repr="condition, timeout=5s, message=NONE">
<arg repr="condition" kind="POSITIONAL_OR_NAMED" required="true">
<name>condition</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the current page contains ``text``.

Fails, if the timeout expires, before the text appears. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the current page contains ``text``.</shortdoc>
</kw>
<kw name="Wait Until Page Contains Element">
<arguments repr="locator, timeout=5s, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the element identified by ``locator`` is found on the current page.

Fails, if the timeout expires, before the element appears. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the element identified by ``locator`` is found on the current page.</shortdoc>
</kw>
<kw name="Wait Until Page Does Not Contain">
<arguments repr="text, timeout=5s, message=NONE">
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the current page does not contain ``text``.

Fails, if the timeout expires, before the text disappears. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the current page does not contain ``text``.</shortdoc>
</kw>
<kw name="Wait Until Page Does Not Contain Element">
<arguments repr="locator, timeout=5s, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the element identified by ``locator`` is not found on the current page.

Fails, if the timeout expires, before the element disappears. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the element identified by ``locator`` is not found on the current page.</shortdoc>
</kw>
<kw name="Wait Until Page Not Contains">
<arguments repr="text, timeout=5s, message=NONE">
<arg repr="text" kind="POSITIONAL_OR_NAMED" required="true">
<name>text</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the current page does not contain ``text``.

Fails, if the timeout expires, before the text disappears. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the current page does not contain ``text``.</shortdoc>
</kw>
<kw name="Wait Until Page Not Contains Element">
<arguments repr="locator, timeout=5s, message=NONE">
<arg repr="locator" kind="POSITIONAL_OR_NAMED" required="true">
<name>locator</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the element identified by ``locator`` is not found on the current page.

Fails, if the timeout expires, before the element disappears. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the element identified by ``locator`` is not found on the current page.</shortdoc>
</kw>
<kw name="Wait Until Title Contains">
<arguments repr="title, timeout=5s, message=NONE">
<arg repr="title" kind="POSITIONAL_OR_NAMED" required="true">
<name>title</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the current page title contains ``title``.

Fails, if the timeout expires, before the page title contains the given title. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the current page title contains ``title``.</shortdoc>
</kw>
<kw name="Wait Until Title Is">
<arguments repr="title, timeout=5s, message=NONE">
<arg repr="title" kind="POSITIONAL_OR_NAMED" required="true">
<name>title</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the current page title is exactly ``title``.

Fails, if the timeout expires, before the page title matches the given title. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the current page title is exactly ``title``.</shortdoc>
</kw>
<kw name="Wait Until Title Is Not">
<arguments repr="title, timeout=5s, message=NONE">
<arg repr="title" kind="POSITIONAL_OR_NAMED" required="true">
<name>title</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the current page title is not exactly ``title``.

Fails, if the timeout expires, before the page title does not match the given title. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the current page title is not exactly ``title``.</shortdoc>
</kw>
<kw name="Wait Until Title Not Contains">
<arguments repr="title, timeout=5s, message=NONE">
<arg repr="title" kind="POSITIONAL_OR_NAMED" required="true">
<name>title</name>
</arg>
<arg repr="timeout=5s" kind="POSITIONAL_OR_NAMED" required="false">
<name>timeout</name>
<default>5s</default>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
</arguments>
<doc>Waits until the current page title does not contain ``title``.

Fails, if the timeout expires, before the page title does not contain the given title. 

See `Introduction` for details about timeouts.</doc>
<shortdoc>Waits until the current page title does not contain ``title``.</shortdoc>
</kw>
<kw name="Web Driver Manager Setup">
<arguments repr="browserName=firefox">
<arg repr="browserName=firefox" kind="POSITIONAL_OR_NAMED" required="false">
<name>browserName</name>
<default>firefox</default>
</arg>
</arguments>
<doc>WebDriver Manager Setup</doc>
<shortdoc>WebDriver Manager Setup</shortdoc>
</kw>
<kw name="Xpath Should Match X Times">
<arguments repr="xpath, expectedXpathCount, message=NONE, logLevel=INFO">
<arg repr="xpath" kind="POSITIONAL_OR_NAMED" required="true">
<name>xpath</name>
</arg>
<arg repr="expectedXpathCount" kind="POSITIONAL_OR_NAMED" required="true">
<name>expectedXpathCount</name>
</arg>
<arg repr="message=NONE" kind="POSITIONAL_OR_NAMED" required="false">
<name>message</name>
<default>NONE</default>
</arg>
<arg repr="logLevel=INFO" kind="POSITIONAL_OR_NAMED" required="false">
<name>logLevel</name>
<default>INFO</default>
</arg>
</arguments>
<doc>Verify that the page contains the ``expectedXpathCount`` of elements located by the given ``xpath``.</doc>
<shortdoc>Verify that the page contains the ``expectedXpathCount`` of elements located by the given ``xpath``.</shortdoc>
</kw>
</keywords>
<datatypes>
</datatypes>
</keywordspec>
