English

Enter a keyword to find a phrase

Given

I set viewport to preset {string}

Sets the viewport dimensions with one of the presets defined by your runtime engine as Cypress: Link or Playwright: Link

I set viewport with width {int} and height {int}

Sets the viewport dimensions to the specified width and length

I start a keyboard navigation from the top of the page

Start a keyboard navigation session from the top of the page
Examples

When

I click

Triggers a click on the selected element.
Make sure you've selected an element beforehand with the within... phrases.

I click on element with role {string} and name {string}

Triggers a click on the element with given role and specific name

I set header(s) for uri {string} and method {string}

Sets one or more headers to the indicated http request and only for the Http method (GET / POST / etc...) passed as a argument. If you use Playwright as execution engine, method isn't used.

I set header(s) for uri {string}

Sets one or more headers to the indicated http request

I reset context

Deletes selected element and timeout

I set timeout with value {int}

Sets the timeout value (in millisecond) for finding element in the DOM
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string}

Writes the sentence passed as a parameter (useful for example to fill in a form field).
Make sure you've selected an element beforehand with the within... phrases.

I enter the value {string}

Writes the sentence passed as a parameter (useful for example to fill in a form field).
Make sure you've selected an element beforehand with the within... phrases.

I select the value {string}

Select the combo box option passed as a parameter (useful for example to fill in a combobox form field).
Make sure you've selected a combo box element beforehand with the within a combo box named 'yourComboboxNamee' phrases.

I press {string}

Press specified key:

Key	Description
{tab}	Tabulation
{reverseTab}	Reverse tabulation
{down}	Arrow Down
{right}	Arrow Right
{left}	Arrow Left
{up}	Arrow Up

Make sure you've selected an element beforehand with the within... phrases.

I press {int} times on {string}

Press specified key multiple times using | as: num|{key}

I go to next keyboard element

Move to the next html element that can be reached with Tab
Examples

I go to previous keyboard element

Move to the previous html element that can be reached with back Tab
Examples

I visit path {string}

Navigate to the Uri passed as a argument (full url consisting of the BASE_URL + Uri) or navigate to Url if begin with http:// or https://

within the element with aria-label {string}

Selects the element whose aria-label is specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

within the element with selector {string}

Selects the element whose selector is specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

within the element with role {string} and name {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

within the element with testId {string}

Selects the element whose data-testId attribute is specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I mock a request {} on url {string} named {string} with content {}

Mock a named API response with body. If you use Playwright as runtime engine, request and named are unused.

I mock a request {} on url {string} named {string} with fixture {}

Mock a named API response with file's extension .json, .js, .coffee, .html, .txt, .csv, .png, .jpg, .jpeg, .gif, .tif, .tiff, .zip

I mock a request {} on url {string} named {string} with status code {int}

Mock a named API response with status code

Then

I should see the page title {string}

Checks the current html page have the specified title

I should see a title named {string} with level {int}

Checks that an Html element exists with accessible role heading, the specified name and title level

I should see these attributes with values

Checks Html attributes of the selected element

I should see an element with aria-label {string} and content {string}

Checks that an Html element exists with the specified aria-label attribute and content

I should see an element with aria-label {string}

Checks that an Html element exists with the specified aria-label attribute

I should see an element with content {string}

Checks that an Html element exists with the specified content

I should see an element with selector {string}

Checks that an Html element exists with the specified selector

I should see an element with role {string} and name {string} and content {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see an element with role {string} and name {string} and content {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see an element with role {string} and name {string} and content {string}

Checks that an Html element exists with the specified accessible role, name and content

the element with selector {string} should be keyboard focused

Checks that the Html element with the specified selector is focused
Examples

the element with role {string} and name {string} should be keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

I should see an element with role {string} and name {string}

Checks that an Html element exists with the specified accessible role and name

I should see an element with testId {string}

Checks that an Html element exists with the specified data-testid attribute

I should see a list named {string} and containing

Checks that there is a list with the specified name containing list items.
Example

Then I should see a list named "test-list" and containing
| First element   |
| Second element  |
| Third element   |

I should see a grid named {string} and containing

Checks that there is a grid with the specified name containing list items.
Example

When I visit path "https://e2e-test-quest.github.io/simple-webapp/grid.html"
Then I should see a grid named "HTML Grid Example" and containing
| Make         | Model   | Price  |
| ------------ | ------- | ------ |
| Toyota       | Celica  | 35000  |
| Ford         | Mondeo  | 32000  |
| Porsche      | Boxster | 72000  |
| BMW          | M50     | 60000  |
| Aston Martin | DBX     | 190000 |

I should see a treegrid named {string} and containing

Checks that there is a treegrid with the specified name containing list items.
Example

When I visit path "https://e2e-test-quest.github.io/simple-webapp/treegrid.html"
Then I should see a treegrid named "HTML Treegrid Example" and containing
| Make         | Model   | Price  |
| ------------ | ------- | ------ |
| Toyota       | Celica  | 35000  |
| Ford         | Mondeo  | 32000  |
| Porsche      | Boxster | 72000  |
| BMW          | M50     | 60000  |
| Aston Martin | DBX     | 190000 |

I should see a table named {string} and containing

Checks that there is a table with the specified name containing list items.
Example

When I visit path "https://e2e-test-quest.github.io/simple-webapp/table.html"
Then I should see a table named "test-list" and containing
| Company                       | Contact          | Country |
| ----------------------------- | ---------------- | ------- |
| Alfreds Futterkiste           | Maria Anders     | Germany |
| Centro comercial Moctezuma    | Francisco Chang  | Mexico  |
| Ernst Handel                  | Roland Mendel    | Austria |
| Island Trading                | Helen Bennett    | UK      |
| Laughing Bacchus Winecellars  | Yoshi Tannamuri  | Canada  |
| Magazzini Alimentari Riuniti  | Giovanni Rovelli | Italy   |

I should not see an element with content {string}

Checks that an Html element does not exists with the specified content

I should not see an element with testId {string}

Checks that an Html element does not exists with the specified data-testid attribute

I should not see an element with role {string} and name {string}

Checks that an Html element does not exists with the specified accessible role and name

I should not see an element with aria-label {string}

Checks that an Html element does not exists with the specified aria-label attribute

the next keyboard element focused should have name {string} and role {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should have name {string} and role {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should consume a mock named {string}

Wait that a named mock has been consumed until timeout

I wait {int} ms

Wait milliseconds. Warning: use this sentence in production can make your test flaky.

I should not have any axe-core accessibility issue

Check that the current page have no accessibility issue for axe-core

I should not have any axe-core accessibility issue with context json fixture {} and option json fixture {}

Check that the current page have no accessibility issue for axe-core with an option on the specific context

I should not have any axe-core accessibility issue with option json fixture {}

Check that the current page have no accessibility issue for axe-core with an option

I should not have any axe-core critical accessibility issue

Check that the current page have not critical accessibility issue for axe-core

I should not have any axe-core accessibility issue with {} impact(s)

Check that the current page have not accessibility issue for axe-core with one or more impacts in: 'minor','moderate','serious','critical'

I should not have any axe-core accessibility issue with accessibility standard(s) {}

Check that the current page have not accessibility issue for axe-core with one or more Accessibility Standards

I should not have any rgaa accessibility issue

Check that the current page have no accessibility issue based on RGAA standards

I should have the following result based on the rgaa reference

Check that the current page have the following result based on RGAA standard

I should have the following partial result based on the rgaa reference

Check that the current page have the following partial result based on RGAA standard

I should see a combo box named {string} with value {string}

Check that the current page have the following partial result based on RGAA standard

I select the value {string} in the combo box named {string}

Check that the current page have the following partial result based on RGAA standard

Par rôle

alert

within an alert named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the alert named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the alert named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see an alert named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see an alert named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see an alert named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see an alert named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see an alert named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see an alert named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see an alert named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see an alert named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

alertdialog

within an alert dialog named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the alert dialog named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the alert dialog named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see an alert dialog named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see an alert dialog named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see an alert dialog named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see an alert dialog named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see an alert dialog named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see an alert dialog named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see an alert dialog named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see an alert dialog named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

application

within an application named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the application named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the application named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see an application named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see an application named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see an application named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see an application named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see an application named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see an application named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see an application named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see an application named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

article

within an article named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the article named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the article named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see an article named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see an article named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see an article named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see an article named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see an article named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see an article named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see an article named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see an article named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

banner

within a banner named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the banner named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the banner named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a banner named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a banner named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a banner named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a banner named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a banner named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a banner named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a banner named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a banner named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

button

within a button named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the button named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the button named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I click on button named {string}

Triggers a click on the element with role button and the specified name

I should see a button named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a button named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a button named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a button named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a button named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a button named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a button named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a button named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a button named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a button named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a button named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

cell

within a cell named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the cell named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the cell named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a cell named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a cell named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a cell named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a cell named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a cell named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a cell named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a cell named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a cell named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

checkbox

within a checkbox named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the checkbox named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the checkbox named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I click on checkbox named {string}

Triggers a click on the element with role checkbox and the specified name

I should see a checkbox named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a checkbox named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a checkbox named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a checkbox named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a checkbox named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a checkbox named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a checkbox named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a checkbox named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a checkbox named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a checkbox named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a checkbox named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

I should see a checkbox named {string} checked

Checks that an Html element exists with the specified accessible role and name and is checked

I should see a checkbox named {string} unchecked

Checks that an Html element exists with the specified accessible role and name and is unchecked

columnheader

within a column header named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the column header named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the column header named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a column header named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a column header named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a column header named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a column header named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a column header named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a column header named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a column header named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a column header named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

combobox

within a combo box named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I click on combo box named {string}

Triggers a click on the element with role combobox and the specified name

I should see a combo box named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a combo box named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a combo box named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a combo box named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a combo box named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a combo box named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a combo box named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a combo box named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a combo box named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a combo box named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a combo box named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

command

within a command named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the command named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the command named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a command named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a command named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a command named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a command named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a command named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a command named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a command named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a command named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

comment

within a comment named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the comment named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the comment named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a comment named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a comment named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a comment named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a comment named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a comment named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a comment named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a comment named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a comment named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

complementary

within a complementary named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the complementary named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the complementary named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a complementary named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a complementary named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a complementary named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a complementary named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a complementary named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a complementary named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a complementary named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a complementary named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

composite

within a composite named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the composite named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the composite named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a composite named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a composite named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a composite named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a composite named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a composite named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a composite named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a composite named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a composite named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

contentinfo

within a contentinfo named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the contentinfo named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the contentinfo named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a contentinfo named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a contentinfo named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a contentinfo named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a contentinfo named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a contentinfo named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a contentinfo named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a contentinfo named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a contentinfo named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

definition

within a definition named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the definition named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the definition named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a definition named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a definition named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a definition named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a definition named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a definition named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a definition named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a definition named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a definition named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

dialog

within a dialog named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the dialog named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the dialog named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a dialog named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a dialog named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a dialog named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a dialog named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a dialog named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a dialog named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a dialog named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a dialog named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

directory

within a directory named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the directory named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the directory named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a directory named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a directory named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a directory named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a directory named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a directory named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a directory named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a directory named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a directory named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

document

within a document named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the document named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the document named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a document named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a document named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a document named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a document named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a document named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a document named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a document named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a document named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

feed

within a flow named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the flow named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the flow named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a flow named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a flow named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a flow named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a flow named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a flow named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a flow named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a flow named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a flow named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

figure

within a figure named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the figure named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the figure named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a figure named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a figure named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a figure named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a figure named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a figure named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a figure named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a figure named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a figure named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

form

within a form named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the form named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the form named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a form named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a form named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a form named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a form named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a form named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a form named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a form named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a form named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

generic

within a generic named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the generic named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the generic named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a generic named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a generic named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a generic named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a generic named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a generic named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a generic named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a generic named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a generic named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

grid

within a grid named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the grid named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the grid named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a grid named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a grid named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a grid named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a grid named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a grid named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a grid named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a grid named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a grid named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

gridcell

within a grid cell named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the grid cell named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the grid cell named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a grid cell named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a grid cell named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a grid cell named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a grid cell named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a grid cell named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a grid cell named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a grid cell named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a grid cell named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

group

within a group named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the group named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the group named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a group named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a group named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a group named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a group named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a group named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a group named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a group named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a group named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

heading

within a title named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the title named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the title named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a title named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a title named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a title named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a title named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a title named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a title named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a title named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a title named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

img

within an image named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the image named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the image named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see an image named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see an image named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see an image named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see an image named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see an image named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see an image named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see an image named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see an image named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

landmark

within a landmark named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the landmark named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the landmark named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a landmark named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a landmark named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a landmark named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a landmark named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a landmark named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a landmark named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a landmark named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a landmark named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

link

within a link named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the link named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the link named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I click on link named {string}

Triggers a click on the element with role link and the specified name

I should see a link named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a link named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a link named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a link named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a link named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a link named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a link named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a link named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a link named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a link named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a link named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

list

within a list named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I should see a list named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a list named {string}

Checks that an Html element does not exists with the specified accessible role and name

listbox

within a list box named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the list box named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the list box named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a list box named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a list box named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a list box named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a list box named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a list box named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a list box named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a list box named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a list box named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a list box named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a list box named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a list box named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

listitem

within a list item named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the list item named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the list item named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I click on list item named {string}

Triggers a click on the element with role listitem and the specified name

I should see a list item named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a list item named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a list item named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a list item named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a list item named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a list item named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a list item named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a list item named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a list item named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a list item named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a list item named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

log

within a log named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the log named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the log named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a log named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a log named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a log named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a log named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a log named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a log named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a log named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a log named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

main

within a main named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the main named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the main named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a main named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a main named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a main named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a main named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a main named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a main named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a main named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a main named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

mark

within a mark named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the mark named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the mark named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a mark named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a mark named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a mark named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a mark named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a mark named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a mark named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a mark named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a mark named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

math

within a math named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the math named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the math named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a math named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a math named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a math named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a math named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a math named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a math named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a math named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a math named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

menu

within a menu named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the menu named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the menu named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a menu named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a menu named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a menu named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a menu named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a menu named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a menu named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a menu named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a menu named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

menubar

within a menubar named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the menubar named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the menubar named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a menubar named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a menubar named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a menubar named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a menubar named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a menubar named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a menubar named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a menubar named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a menubar named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

menuitem

within a menuitem named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the menuitem named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the menuitem named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I click on menuitem named {string}

Triggers a click on the element with role menuitem and the specified name

I should see a menuitem named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a menuitem named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a menuitem named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a menuitem named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a menuitem named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a menuitem named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a menuitem named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a menuitem named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a menuitem named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a menuitem named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a menuitem named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

menuitemcheckbox

within a menuitemcheckbox named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the menuitemcheckbox named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the menuitemcheckbox named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a menuitemcheckbox named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a menuitemcheckbox named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a menuitemcheckbox named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a menuitemcheckbox named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a menuitemcheckbox named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a menuitemcheckbox named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a menuitemcheckbox named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a menuitemcheckbox named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a menuitemcheckbox named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a menuitemcheckbox named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a menuitemcheckbox named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

menuitemradio

within a menuitemradio named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the menuitemradio named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the menuitemradio named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a menuitemradio named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a menuitemradio named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a menuitemradio named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a menuitemradio named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a menuitemradio named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a menuitemradio named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a menuitemradio named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a menuitemradio named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a menuitemradio named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a menuitemradio named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a menuitemradio named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

I should see a menuitemradio named {string} checked

Checks that an Html element exists with the specified accessible role and name and is checked

I should see a menuitemradio named {string} unchecked

Checks that an Html element exists with the specified accessible role and name and is unchecked

meter

within a counter named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the counter named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the counter named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a counter named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a counter named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a counter named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a counter named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a counter named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a counter named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a counter named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a counter named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

navigation

within a navigation named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the navigation named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the navigation named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a navigation named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a navigation named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a navigation named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a navigation named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a navigation named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a navigation named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a navigation named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a navigation named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

none

within a no named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the no named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the no named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a no named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a no named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a no named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a no named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a no named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a no named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a no named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a no named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

note

within a note named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the note named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the note named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a note named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a note named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a note named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a note named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a note named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a note named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a note named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a note named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

option

within an option named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the option named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the option named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I click on option named {string}

Triggers a click on the element with role option and the specified name

I should see an option named {string}

Checks that an Html element exists with the specified accessible role and name

I should see an option named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be an option named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be an option named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see an option named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see an option named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see an option named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see an option named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see an option named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see an option named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see an option named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

presentation

within a presentation named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the presentation named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the presentation named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a presentation named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a presentation named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a presentation named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a presentation named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a presentation named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a presentation named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a presentation named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a presentation named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

progressbar

within a progress bar named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the progress bar named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the progress bar named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a progress bar named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a progress bar named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a progress bar named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a progress bar named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a progress bar named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a progress bar named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a progress bar named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a progress bar named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

radio

within a radio named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the radio named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the radio named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I click on radio named {string}

Triggers a click on the element with role radio and the specified name

I should see a radio named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a radio named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a radio named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a radio named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a radio named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a radio named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a radio named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a radio named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a radio named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a radio named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a radio named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

I should see a radio named {string} checked

Checks that an Html element exists with the specified accessible role and name and is checked

I should see a radio named {string} unchecked

Checks that an Html element exists with the specified accessible role and name and is unchecked

radiogroup

within a radio group named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the radio group named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the radio group named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a radio group named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a radio group named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a radio group named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a radio group named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a radio group named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a radio group named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a radio group named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a radio group named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

range

within a range named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the range named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the range named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a range named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a range named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a range named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a range named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a range named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a range named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a range named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a range named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

region

within a region named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the region named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the region named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a region named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a region named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a region named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a region named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a region named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a region named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a region named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a region named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

roletype

within a role type named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the role type named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the role type named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a role type named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a role type named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a role type named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a role type named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a role type named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a role type named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a role type named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a role type named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

row

within a row named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the row named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the row named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a row named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a row named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a row named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a row named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a row named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a row named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a row named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a row named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

rowgroup

within a row group named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the row group named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the row group named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a row group named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a row group named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a row group named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a row group named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a row group named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a row group named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a row group named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a row group named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

rowheader

within a row header named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the row header named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the row header named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a row header named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a row header named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a row header named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a row header named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a row header named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a row header named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a row header named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a row header named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

scrollbar

within a scroll bar named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the scroll bar named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the scroll bar named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a scroll bar named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a scroll bar named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a scroll bar named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a scroll bar named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a scroll bar named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a scroll bar named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a scroll bar named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a scroll bar named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

search

within a search named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the search named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the search named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a search named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a search named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a search named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a search named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a search named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a search named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a search named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a search named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a search named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a search named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a search named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

searchbox

within a search box named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the search box named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the search box named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a search box named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a search box named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a search box named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a search box named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a search box named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a search box named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a search box named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a search box named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a search box named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a search box named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a search box named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

section

within a section named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the section named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the section named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a section named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a section named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a section named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a section named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a section named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a section named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a section named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a section named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

sectionhead

within a section header named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the section header named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the section header named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a section header named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a section header named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a section header named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a section header named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a section header named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a section header named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a section header named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a section header named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

select

within a select named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the select named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the select named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a select named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a select named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a select named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a select named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a select named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a select named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a select named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a select named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a select named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a select named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a select named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

separator

within a separator named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the separator named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the separator named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a separator named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a separator named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a separator named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a separator named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a separator named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a separator named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a separator named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a separator named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

slider

within a slider named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the slider named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the slider named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a slider named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a slider named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a slider named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a slider named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a slider named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a slider named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a slider named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a slider named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a slider named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a slider named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a slider named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

spinbutton

within a spin button named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the spin button named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the spin button named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a spin button named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a spin button named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a spin button named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a spin button named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a spin button named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a spin button named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a spin button named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a spin button named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a spin button named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a spin button named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a spin button named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

status

within a status named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the status named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the status named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a status named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a status named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a status named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a status named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a status named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a status named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a status named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a status named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

structure

within a structure named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the structure named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the structure named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a structure named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a structure named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a structure named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a structure named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a structure named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a structure named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a structure named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a structure named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

suggestion

within a suggestion named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the suggestion named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the suggestion named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a suggestion named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a suggestion named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a suggestion named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a suggestion named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a suggestion named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a suggestion named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a suggestion named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a suggestion named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

switch

within a switch named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the switch named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the switch named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a switch named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a switch named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a switch named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a switch named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a switch named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a switch named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a switch named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a switch named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a switch named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a switch named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a switch named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

tab

within a tab named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the tab named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the tab named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a tab named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a tab named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a tab named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a tab named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a tab named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a tab named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a tab named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a tab named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a tab named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a tab named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a tab named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

table

within a table named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the table named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the table named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a table named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a table named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a table named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a table named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a table named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a table named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a table named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a table named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

tablist

within a tablist named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the tablist named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the tablist named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a tablist named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a tablist named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a tablist named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a tablist named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a tablist named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a tablist named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a tablist named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a tablist named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

tabpanel

within a tabpanel named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the tabpanel named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the tabpanel named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a tabpanel named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a tabpanel named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a tabpanel named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a tabpanel named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a tabpanel named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a tabpanel named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a tabpanel named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a tabpanel named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

term

within a term named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the term named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the term named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a term named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a term named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a term named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a term named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a term named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a term named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a term named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a term named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

textbox

within a text box named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the text box named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the text box named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a text box named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a text box named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a text box named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a text box named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a text box named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a text box named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a text box named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a text box named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a text box named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a text box named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a text box named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

timer

within a timer named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the timer named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the timer named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a timer named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a timer named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a timer named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a timer named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a timer named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a timer named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a timer named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a timer named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

toolbar

within a toolbar named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the toolbar named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the toolbar named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a toolbar named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a toolbar named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a toolbar named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a toolbar named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a toolbar named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a toolbar named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a toolbar named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a toolbar named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

tooltip

within a tooltip named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the tooltip named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the tooltip named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a tooltip named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a tooltip named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a tooltip named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a tooltip named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a tooltip named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a tooltip named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a tooltip named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a tooltip named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

tree

within a tree named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the tree named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the tree named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a tree named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a tree named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a tree named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a tree named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a tree named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a tree named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a tree named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a tree named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

treegrid

within a tree grid named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the tree grid named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the tree grid named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a tree grid named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a tree grid named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a tree grid named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a tree grid named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a tree grid named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a tree grid named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a tree grid named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a tree grid named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

treeitem

within a tree item named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the tree item named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the tree item named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a tree item named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a tree item named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a tree item named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a tree item named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a tree item named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a tree item named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a tree item named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a tree item named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

widget

within a widget named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the widget named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the widget named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a widget named {string}

Checks that an Html element exists with the specified accessible role and name

I should see a widget named {string} keyboard focused

Checks that the Html element with the specified accessible role and name is focused
Examples

the next keyboard element focused should be a widget named {string}

Move to the next html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

the previous keyboard element focused should be a widget named {string}

Move to the previous html element that can be reached with Tab and checks that the Html element with the specified accessible role and name is focused
Examples

I should not see a widget named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a widget named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a widget named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a widget named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a widget named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a widget named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a widget named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false

window

within a window named {string}

Selects the element whose accessible role and accessible name are specified
⚠ remember to deselect the element with I reset context if you're no longer acting on it

I type the sentence {string} in the window named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I enter the value {string} in the window named {string}

Writes the sentence given as a parameter inside the specified field (useful for example to fill in a form field)

I should see a window named {string}

Checks that an Html element exists with the specified accessible role and name

I should not see a window named {string}

Checks that an Html element does not exists with the specified accessible role and name

I should see a window named {string} and containing {string}

Checks that an Html element exists with the specified accessible role, name and content

I should see a window named {string} with value {string}

Checks that an Form element(input) exists with the specified accessible role, name and specified value

I should see a window named {string} and containing {string} disabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to true

I should see a window named {string} and containing {string} enabled

Checks that an Html element exists with the specified accessible role, name and content, and with the disabled attribute set to false

I should see a window named {string} disabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to true

I should see a window named {string} enabled

Checks that an Html element exists with the specified accessible role, name, and with the disabled attribute set to false