RetroSearch Browse

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://a11ysupport.io/tests/techariaaria-required-on-html-radio-buttons below:

Test: aria-required attribute on each HTML radio button in a fieldset

Screen Reader support level: partial (111/121)

Voice Control support level: supported with 4 unknown results

On this page

About this test

This test checks the aria-required attribute as applied to each HTML radio button in a fieldset. Notes:

Currently, the most robust solution to mark a group of radio buttons as required is to place the text 'required' in the group label.
In most screen readers, this technique will result in the required state being conveyed for each radio in the group. Some users might find this confusing since only one radio can be selected at a time.

Submit new test results Age of results

Results in this test range from 4 years ago to 6 years ago. See detailed information about test dates and versions for more information.

Caution

Failing or partial results may be out of date. The oldest result is from 6 years ago. Consider running this test and contributing results.

Test HTMLOpen the test case HTML file

<!DOCTYPE html>
<html lang="en">
<head>
    <title>aria-required on radio buttons within a fieldset</title>
</head>
<body>
<h1>aria-required examples</h1>
<p>This page contains HTML radio buttons in a fieldset with with aria-requried</p>

<fieldset>
    <legend>Animal</legend>
    <input type="radio" name="animal" value="cat" id="cat" aria-required="true"><label for="cat">Cat</label>
    <input type="radio" name="animal" value="dog" id="dog" aria-required="true"><label for="dog">Dog</label>
    <input type="radio" name="animal" value="catdog" id="catdog" aria-required="true"><label for="catdog">CatDog</label>
</fieldset>

<button>submit</button>

</body>
</html>

Summary of Screen Reader support by expectation

* means that some support is hidden behind settings

Summary of Voice Control support by expectation aria-required attribute Expectation Dragon Naturally Speaking Voice Access (Android) Voice Control (iOS) Voice Control (MacOS) Windows Speech Recognition Windows Voice Access Chrome Chrome Safari Safari Edge Chrome Edge Chrome Not applicable fieldset element Expectation Dragon Naturally Speaking Voice Access (Android) Voice Control (iOS) Voice Control (MacOS) Windows Speech Recognition Windows Voice Access Chrome Chrome Safari Safari Edge Chrome Edge Chrome Not applicable legend element Expectation Dragon Naturally Speaking Voice Access (Android) Voice Control (iOS) Voice Control (MacOS) Windows Speech Recognition Windows Voice Access Chrome Chrome Safari Safari Edge Chrome Edge Chrome Not applicable

* means that some support is hidden behind settings

Summary of Keyboard support by expectation aria-required attribute Expectation Windows Keyboard Mac Keyboard iOS Keyboard Android Keyboard Chrome Firefox Edge Chrome Safari Safari Chrome Not applicable fieldset element Expectation Windows Keyboard Mac Keyboard iOS Keyboard Android Keyboard Chrome Firefox Edge Chrome Safari Safari Chrome Not applicable input[type="radio"] element Expectation Windows Keyboard Mac Keyboard iOS Keyboard Android Keyboard Chrome Firefox Edge Chrome Safari Safari Chrome Not applicable legend element Expectation Windows Keyboard Mac Keyboard iOS Keyboard Android Keyboard Chrome Firefox Edge Chrome Safari Safari Chrome Not applicable

* means that some support is hidden behind settings

Detailed support results by expectation Expectation for the aria-required attribute: convey the "true" value - applied to the input[type="radio"] element

This expectation is applied to the input[type="radio"] element. Expectations and results might differ when the the feature is applied to different roles.

This expectation is from the aria-required attribute feature.

Strength of this expectation for different types of assistive technologies:

Screen Readers: MUST
Voice Control: NA

Examples:

If applied to a single control, a screen reader might announce that control as required
If applied to a group of controls, such as a radio group, the screen reader might announce the required state on the group, and the required state will be implied for the controls.
If applied to a group of controls, such as a radio group, the screen reader might announce the first control as required, and the required state will be implied for the rest.
If applied to a group of controls, such as a radio group, the screen reader might announce the each control as required.

Grading method:

Just one of the listed commands must pass for the expectation to pass.

AT Browser Has Support Output Dragon Naturally Speaking Chrome not applicable - JAWS Chrome yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "CatDog radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, CatDog radio button, not checked, required, 3 of 3"

Notes: The required state is conveyed for each radio in the group. Some users might find this confusing since only one radio can be selected at a time. JAWS Edge yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "CatDog radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, CatDog radio button, not checked, required, 3 of 3"

JAWS Firefox yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal, cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "CatDog radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal, CatDog radio button, not checked, required, 3 of 3"

Notes: The required state is conveyed for each radio in the group. Some users might find this confusing since only one radio can be selected at a time. Narrator Edge yes

Result: (pass)
- Test Case: Use Down arrow (Jump to next item (scan mode)) to navigate forward to the start of `*[aria-required="true"]`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Jump to next item (scan mode))
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "cat, radio button, non-selected, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `*[aria-required="true"]`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "cat, radio button, non-selected, required, 1 of 3"
Result: (pass)
- Test Case: Use Up arrow (Jump to previous item (scan mode)) to navigate backwards to the end of `*[aria-required="true"]`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Jump to previous item (scan mode))
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "CatDog, radio button, non-selected, required, 3 of 3"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `*[aria-required="true"]`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "CatDog, radio button, non-selected, required, 3 of 3"

Notes: The required state is conveyed for each radio in the group. Some users might find this confusing since only one radio can be selected at a time. NVDA Chrome yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use up arrow (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "grouping, radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, catdog, radio button, not checked, required, 3 of 3"

Notes: The required state is conveyed for each radio in the group. Some users might find this confusing since only one radio can be selected at a time. NVDA Edge yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use up arrow (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "grouping, radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, catdog, radio button, not checked, required, 3 of 3"

NVDA Firefox yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, clickable, Cat, radio button, not checked, required, clickable, CatDog"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use up arrow (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, clickable, Cat, radio button, not checked, required, clickable, CatDog"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, CatDog, radio button, not checked, required, 3 of 3"

Notes: The required state is conveyed for each radio in the group. Some users might find this confusing since only one radio can be selected at a time. Orca Firefox none

Result: (fail)
- Test Case: Use down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, not selected, radio button. dog, not selected, radio button. catdog, not selected, radio button."
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (fail)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "animal panel, cat, not selected, radio button"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.

Result: (fail)
- Test Case: Use Swipe right (or alt+right arrow) (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe right (or alt+right arrow) (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "not checked, cat, radio button, double tap to toggle"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (fail)
- Test Case: Use Swipe left (or alt+left arrow) (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe left (or alt+left arrow) (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "not checked, CatDog, radio button, double tap to toggle"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.

Grading Note: There is no known/documented support. There may still be support for this expectation, but it is undocumented. If this is the case, please report this issue. Voice Access (Android) Chrome not applicable - Voice Control (iOS) Safari not applicable - Voice Control (MacOS) Safari not applicable - VoiceOver (iOS) Safari yes

Result: (pass)
- Test Case: Use Swipe Right (Next item) to navigate forward to `*[aria-required="true"]`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe Right (Next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, radio button, unchecked, 1 of 3, required"
Result: (pass)
- Test Case: Use Swipe Left (Previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe Left (Previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "CatDog, radio button, unchecked, 3 of 3, required"

Notes: The required state is conveyed for each radio in the group. Some users might find this confusing since only one radio can be selected at a time. VoiceOver (macOS) Safari yes

Result: (pass)
- Test Case: Use VO + Right arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + Right arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, required, radio button, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Cat, required, radio button, 1 of 3, animal, animal group"
Result: (pass)
- Test Case: Use VO + Left Arrow (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + Left Arrow (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "CatDog, required, radio button, 3 of 3"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "CatDog, required, radio button, 3 of 3, animal, animal group"

Notes: The required state is conveyed for each radio in the group. Some users might find this confusing since only one radio can be selected at a time. Windows Speech Recognition Edge not applicable - Windows Speech Recognition Chrome not applicable - Windows Voice Access Edge not applicable - Windows Voice Access Chrome not applicable - Windows Keyboard Chrome not applicable - Windows Keyboard Firefox not applicable - Windows Keyboard Edge not applicable - Mac Keyboard Chrome not applicable - Mac Keyboard Safari not applicable - iOS Keyboard Safari not applicable - Android Keyboard Chrome not applicable - Extended Support for: aria-required attribute: convey the "true" value

These are less common combinations

AT Browser Has Support Output Dragon Naturally Speaking IE not applicable - Dragon Naturally Speaking Firefox not applicable - JAWS 2019.1906.10 IE 11 yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal, cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "CatDog radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal, CatDog radio button, not checked, required, 3 of 3"

This expectation is from the fieldset element feature.

Rationale:

A screen reader user needs to know what to enter.

Strength of this expectation for different types of assistive technologies:

Screen Readers: MUST
Voice Control: NA

Examples:

A screen reader might convey the fieldset as "<role> <name-from-legend>"

Grading method:

Just one of the listed commands must pass for the expectation to pass.

AT Browser Has Support Output Dragon Naturally Speaking Chrome not applicable - JAWS Chrome yes

Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, CatDog radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "group start, animal"
Result: (fail)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "group end"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.

JAWS Edge yes

Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, CatDog radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "group start, animal"
Result: (fail)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "group end"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.

JAWS Firefox yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "group start, animal"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal, cat, radio button, not checked, required, 1 of 3"
Result: (fail)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "group end"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal, CatDog, radio button, not checked, required, 3 of 3"

Narrator Edge yes

Result: (pass)
- Test Case: Use Down arrow (Jump to next item (scan mode)) to navigate forward to the start of `fieldset`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Jump to next item (scan mode))
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "animal"
Result: (fail)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "cat, radio button, non-selected, required, 1 of 3"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (fail)
- Test Case: Use Up arrow (Jump to previous item (scan mode)) to navigate backwards to the end of `fieldset`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Jump to previous item (scan mode))
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "CatDog"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (fail)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "CatDog, radio button, non-selected, required, 3 of 3"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.

NVDA Chrome yes

Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"
Result: (fail)
- Test Case: Use up arrow (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "grouping, radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, catdog, radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "grouping, animal"

NVDA Edge yes

Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"
Result: (fail)
- Test Case: Use up arrow (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "grouping, radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, catdog, radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "grouping, animal"

NVDA Firefox yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "Animal"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"
Result: (fail)
- Test Case: Use up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, clickable, Cat, radio button, not checked, required, clickable, CatDog"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"

Orca Firefox yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "animal panel"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal panel, cat, not selected, radio button"
Result: (pass)
- Test Case: Use up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "animal panel. cat, not selected, radio button. dog, not selected, radio button. catdog, not selected, radio button. "
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal panel. catdog, not selected radio button"

TalkBack Chrome yes

Result: (pass)
- Test Case: Use Swipe right (or alt+right arrow) (Read next item) to navigate forward into `fieldset`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe right (or alt+right arrow) (Read next item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal"
Result: (fail)
- Test Case: Use Swipe left (or alt+left arrow) (Read previous item) to navigate backwards into `fieldset`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe left (or alt+left arrow) (Read previous item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "not checked, CatDog, radio button"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.

Voice Access (Android) Chrome not applicable - Voice Control (iOS) Safari not applicable - Voice Control (MacOS) Safari not applicable - VoiceOver (iOS) Safari yes

Result: (pass)
- Test Case: Use Swipe Right (Next item) to navigate forward into `fieldset`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe Right (Next item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal, form start"
Result: (pass)
- Test Case: Use Swipe Left (Previous item) to navigate backwards into `fieldset`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe Left (Previous item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal, CatDog, radio button, unchecked, 3 of 3, required"

VoiceOver (macOS) Safari yes

Result: (pass)
- Test Case: Use VO + Right arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + Right arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "animal, group"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Cat, required, radio button, 1 of 3, animal, animal group"
Result: (pass)
- Test Case: Use VO + Left Arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + Left Arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "end of animal, group"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "CatDog, required, radio button, 3 of 3, animal, animal group"

Windows Speech Recognition Edge not applicable - Windows Speech Recognition Chrome not applicable - Windows Voice Access Edge not applicable - Windows Voice Access Chrome not applicable - Windows Keyboard Chrome not applicable - Windows Keyboard Firefox not applicable - Windows Keyboard Edge not applicable - Mac Keyboard Chrome not applicable - Mac Keyboard Safari not applicable - iOS Keyboard Safari not applicable - Android Keyboard Chrome not applicable - Extended Support for: fieldset element: convey its name

These are less common combinations

AT Browser Has Support Output Dragon Naturally Speaking IE not applicable - Dragon Naturally Speaking Firefox not applicable - JAWS 2019.1906.10 IE 11 yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "group start, animal"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal, cat, radio button, not checked, required"
Result: (fail)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "group end"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal, CatDog, radio button, not checked, required"

This expectation is from the fieldset element feature.

Rationale:

A screen reader user needs to know how they can interact with the element. Voice control software might use the role to help users activate controls that do not have a visible name.

Strength of this expectation for different types of assistive technologies:

Screen Readers: MUST
Voice Control: NA

Examples:

A screen reader might announce an element as something like "<name>, <role>"
A screen reader might imply the role by the presence of certain context roles
Voice Control software might let the user say something like "click, <role>".
Voice Control software might let the user say something like "show numbers", and interactive roles will be flagged with numbers.

Grading method:

Just one of the listed commands must pass for the expectation to pass.

AT Browser Has Support Output Dragon Naturally Speaking Chrome not applicable - JAWS Chrome yes

Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, CatDog radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "group start, animal"
Result: (pass)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "group end"

JAWS Edge yes

Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, CatDog radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "group start, animal"
Result: (pass)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "group end"

JAWS Firefox yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "group start, animal"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal, cat, radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "group end"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal, CatDog, radio button, not checked, required, 3 of 3"

Narrator Edge none

Result: (fail)
- Test Case: Use Down arrow (Jump to next item (scan mode)) to navigate forward to the start of `fieldset`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Jump to next item (scan mode))
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "animal"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (fail)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "cat, radio button, non-selected, required, 1 of 3"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (fail)
- Test Case: Use Up arrow (Jump to previous item (scan mode)) to navigate backwards to the end of `fieldset`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Jump to previous item (scan mode))
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "CatDog"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (fail)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "CatDog, radio button, non-selected, required, 3 of 3"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.

Grading Note: There is no known/documented support. There may still be support for this expectation, but it is undocumented. If this is the case, please report this issue. NVDA Chrome yes

Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use up arrow (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "grouping, radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, catdog, radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "grouping, animal"

NVDA Edge yes

Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use up arrow (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "grouping, radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, catdog, radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "grouping, animal"

NVDA Firefox yes

Result: (fail)
- Test Case: Use down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "Animal"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"
Result: (fail)
- Test Case: Use up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, clickable, Cat, radio button, not checked, required, clickable, CatDog"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"

Orca Firefox yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "animal panel"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal panel, cat, not selected, radio button"
Result: (pass)
- Test Case: Use up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "animal panel. cat, not selected, radio button. dog, not selected, radio button. catdog, not selected, radio button. "
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal panel. catdog, not selected radio button"

TalkBack Chrome none

Result: (fail)
- Test Case: Use Swipe right (or alt+right arrow) (Read next item) to navigate forward into `fieldset`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe right (or alt+right arrow) (Read next item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (fail)
- Test Case: Use Swipe left (or alt+left arrow) (Read previous item) to navigate backwards into `fieldset`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe left (or alt+left arrow) (Read previous item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "not checked, CatDog, radio button"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.

Result: (pass)
- Test Case: Use Swipe Right (Next item) to navigate forward into `fieldset`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe Right (Next item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal, form start"
Result: (pass)
- Test Case: Use Swipe Left (Previous item) to navigate backwards into `fieldset`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe Left (Previous item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal, CatDog, radio button, unchecked, 3 of 3, required"

VoiceOver (macOS) Safari yes

Result: (pass)
- Test Case: Use VO + Right arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + Right arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "animal, group"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Cat, required, radio button, 1 of 3, animal, animal group"
Result: (pass)
- Test Case: Use VO + Left Arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + Left Arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "end of animal, group"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "CatDog, required, radio button, 3 of 3, animal, animal group"

These are less common combinations

AT Browser Has Support Output Dragon Naturally Speaking IE not applicable - Dragon Naturally Speaking Firefox not applicable - JAWS 2019.1906.10 IE 11 yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "group start, animal"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal, cat, radio button, not checked, required"
Result: (pass)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "group end"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal, CatDog, radio button, not checked, required"

This expectation is from the fieldset element feature.

Rationale:

A user needs to know when they enter and exit an element

Strength of this expectation for different types of assistive technologies:

Screen Readers: MUST
Voice Control: NA

Examples:

A screen reader might announce the role of the element when entering and say something like "leaving" when exiting.
A screen reader might not explicitly announce entering and existing the element, but instead imply that the is in the containing object by conveying the roles of required children (options in a listbox for example).
A screen reader might announce position in set information such as "1 of 6".
A screen reader might not convey boundaries if the content fits on a single line

Grading method:

All of the listed commands must pass for the expectation to pass.

AT Browser Has Support Output Dragon Naturally Speaking Chrome not applicable - JAWS Chrome yes

Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, CatDog radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "group start, animal"
Result: (pass)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "group end"

JAWS Edge yes

Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, CatDog radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "group start, animal"
Result: (pass)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "group end"

JAWS Firefox yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "group start, animal"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal, cat, radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "group end"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal, CatDog, radio button, not checked, required, 3 of 3"

Narrator Edge none

Result: (fail)
- Test Case: Use Down arrow (Jump to next item (scan mode)) to navigate forward to the start of `fieldset`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Jump to next item (scan mode))
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "animal"
Result: (fail)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "cat, radio button, non-selected, required, 1 of 3"
Result: (fail)
- Test Case: Use Up arrow (Jump to previous item (scan mode)) to navigate backwards to the end of `fieldset`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Jump to previous item (scan mode))
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "CatDog"
Result: (fail)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "CatDog, radio button, non-selected, required, 3 of 3"

Grading Note: There is no known/documented support. There may still be support for this expectation, but it is undocumented. If this is the case, please report this issue. NVDA Chrome yes

Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use up arrow (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "grouping, radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, catdog, radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "grouping, animal"

NVDA Edge yes

Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use up arrow (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "grouping, radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, catdog, radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "grouping, animal"

NVDA Firefox partial

Result: (fail)
- Test Case: Use down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "Animal"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"
Result: (fail)
- Test Case: Use up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, clickable, Cat, radio button, not checked, required, clickable, CatDog"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"

Orca Firefox yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "animal panel"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal panel, cat, not selected, radio button"
Result: (pass)
- Test Case: Use up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "animal panel. cat, not selected, radio button. dog, not selected, radio button. catdog, not selected, radio button. "
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal panel. catdog, not selected radio button"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forwards out of `fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: within target
    - Keyboard focus is: within target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: after target
  6. Record results for the relevant expectations
- Output: "leaving panel"

TalkBack Chrome none

Result: (fail)
- Test Case: Use Swipe right (or alt+right arrow) (Read next item) to navigate forward into `fieldset`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe right (or alt+right arrow) (Read next item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal"
Result: (fail)
- Test Case: Use Swipe left (or alt+left arrow) (Read previous item) to navigate backwards into `fieldset`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe left (or alt+left arrow) (Read previous item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "not checked, CatDog, radio button"

Result: (pass)
- Test Case: Use Swipe Right (Next item) to navigate forward into `fieldset`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe Right (Next item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal, form start"
Result: (pass)
- Test Case: Use Swipe Left (Previous item) to navigate backwards into `fieldset`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe Left (Previous item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal, CatDog, radio button, unchecked, 3 of 3, required"
Result: (fail)
- Test Case: Use Swipe Right (Next item) to navigate forwards out of `fieldset`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: within target
    - Keyboard focus is: within target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe Right (Next item)
    - After issuing the command, virtual focus should be: after target
  6. Record results for the relevant expectations
- Output: "submit, button"

VoiceOver (macOS) Safari yes

Result: (pass)
- Test Case: Use VO + Right arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + Right arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "animal, group"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Cat, required, radio button, 1 of 3, animal, animal group"
Result: (pass)
- Test Case: Use VO + Left Arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + Left Arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "end of animal, group"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "CatDog, required, radio button, 3 of 3, animal, animal group"

These are less common combinations

AT Browser Has Support Output Dragon Naturally Speaking IE not applicable - Dragon Naturally Speaking Firefox not applicable - JAWS 2019.1906.10 IE 11 yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "group start, animal"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `fieldset`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal, cat, radio button, not checked, required"
Result: (pass)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "group end"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `fieldset`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal, CatDog, radio button, not checked, required"

This expectation is from the input[type="radio"] element feature.

Rationale:

A screen reader user needs to know what to enter.

Strength of this expectation for different types of assistive technologies:

Screen Readers: MUST
Voice Control: MUST

Examples:

A screen reader will announce the name (label).
Voice control software will let the user say something like "click <name>" to activate the control.

Grading method:

Just one of the listed commands must pass for the expectation to pass.

Notes:

For form inputs - commands to read line by line (down and up arrows in most windows screen readers) will not always result in the name being explicitly conveyed when the virtual focus is moved to an input where the label is visually displayed and programmatically associated with the input. This is acceptable because the name is implied by the fact that it should be naturally found in the reading order. Some screen readers choose to not convey the name in these cases, likely in an effort to reduce verbosity.

AT Browser Has Support Output Dragon Naturally Speaking Chrome yes

Result: (pass)
- Test Case: Use "Click <text>" (Activate item by name)
  1. Launch Dragon Naturally Speaking and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Issue the command: "Click <text>" (Activate item by name)
  5. Record results for the relevant expectations
- Output: radio was checked
- Command Notes: said "click cat"

JAWS Chrome yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"

JAWS Edge yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"

JAWS Firefox yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal, cat radio button, not checked, required, 1 of 3"

Narrator Edge yes

Result: (pass)
- Test Case: Use Down arrow (Jump to next item (scan mode)) to navigate forward to the start of `input[type="radio"]`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Jump to next item (scan mode))
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "cat, radio button, non-selected, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `input[type="radio"]`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "cat, radio button, non-selected, required, 1 of 3"

NVDA Chrome yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"

NVDA Edge yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"

NVDA Firefox yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, clickable, Cat, radio button, not checked, required, clickable, CatDog"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"

Orca Firefox yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, not selected, radio button. dog, not selected, radio button. catdog, not selected, radio button."
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "animal panel, cat, not selected, radio button"

TalkBack Chrome yes

Result: (pass)
- Test Case: Use Swipe right (or alt+right arrow) (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe right (or alt+right arrow) (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "not checked, cat, radio button. double tap to toggle."

Voice Access (Android) Chrome yes

Result: (pass)
- Test Case: Use "Tap <text>" or just "<text>" (Activate item by name)
  1. Launch Voice Access (Android) and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Issue the command: "Tap <text>" or just "<text>" (Activate item by name)
  5. Record results for the relevant expectations
- Output: radio button was checked
- Command Notes: said "tap cat"

Voice Control (iOS) Safari yes

Result: (pass)
- Test Case: Use "Tap <text>" (Activate item by name)
  1. Launch Voice Control (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Issue the command: "Tap <text>" (Activate item by name)
  5. Record results for the relevant expectations
- Output: radio was checked
- Command Notes: said "tap cat"

Voice Control (MacOS) Safari yes

Result: (pass)
- Test Case: Use "Click <text>" (Activate item by name)
  1. Launch Voice Control (MacOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Issue the command: "Click <text>" (Activate item by name)
  5. Record results for the relevant expectations
- Output: checkbox was checked
- Command Notes: said "click cat". The correct radio button was flagged for disambiguation, but only a single number was displayed. Had to say "choose 2" in order to complete the task.

VoiceOver (iOS) Safari yes

Result: (pass)
- Test Case: Use Swipe Right (Next item) to navigate forward to `input[type="radio"]`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe Right (Next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, radio button, unchecked, 1 of 3, required"

VoiceOver (macOS) Safari yes

Result: (pass)
- Test Case: Use VO + Right arrow (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + Right arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, required, radio button, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Cat required, radio button, 1 of 3, animal, animal group"

Windows Speech Recognition Edge yes

Result: (pass)
- Test Case: Use "Click <text>" (Activate item by name)
  1. Launch Windows Speech Recognition and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Issue the command: "Click <text>" (Activate item by name)
  5. Record results for the relevant expectations
- Output: role was activated
- Command Notes: said "click cat"

Windows Speech Recognition Chrome yes

Result: (pass)
- Test Case: Use "Click <text>" (Activate item by name)
  1. Launch Windows Speech Recognition and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Issue the command: "Click <text>" (Activate item by name)
  5. Record results for the relevant expectations
- Output: role was activated
- Command Notes: said "click cat"

Windows Voice Access Edge unknown - Windows Voice Access Chrome unknown - Windows Keyboard Chrome not applicable - Windows Keyboard Firefox not applicable - Windows Keyboard Edge not applicable - Mac Keyboard Chrome not applicable - Mac Keyboard Safari not applicable - iOS Keyboard Safari not applicable - Android Keyboard Chrome not applicable - Extended Support for: input[type="radio"] element: convey its name

These are less common combinations

AT Browser Has Support Output Dragon Naturally Speaking IE unknown - Dragon Naturally Speaking Firefox unknown - JAWS 2019.1906.10 IE 11 yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal, cat radio button, not checked, required"

Narrator Firefox unknown - Narrator Chrome unknown - Narrator IE unknown - NVDA IE unknown - TalkBack Firefox unknown - Voice Access (Android) Firefox unknown - VoiceOver (iOS) Chrome unknown - VoiceOver (macOS) Chrome unknown - VoiceOver (macOS) Firefox unknown - Orca Chrome unknown - Voice Control (MacOS) Chrome unknown - Voice Control (MacOS) Firefox unknown - Mac Keyboard Firefox not applicable - Android Keyboard Firefox not applicable - Back to top Expectation for the input[type="radio"] element: convey its role

This expectation is from the input[type="radio"] element feature.

Rationale:

A screen reader user needs to know how they can interact with the element. Voice control software might use the role to help users activate controls that do not have a visible name.

Strength of this expectation for different types of assistive technologies:

Screen Readers: MUST
Voice Control: MUST

Examples:

A screen reader might be announce the role as "radio"
Voice control software will let the user say something like "click radio" to focus a the input or flag the role with a number.

Grading method:

Just one of the listed commands must pass for the expectation to pass.

AT Browser Has Support Output Dragon Naturally Speaking Chrome yes

Result: (pass)
- Test Case: Use Click <role> (Click Type)
  1. Launch Dragon Naturally Speaking and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Issue the command: Click <role> (Click Type)
  5. Record results for the relevant expectations
- Output: all radios were flagged for selection
- Command Notes: said "click radio"

JAWS Chrome yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"

JAWS Edge yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"

JAWS Firefox yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal, cat radio button, not checked, required, 1 of 3"

Narrator Edge yes

Result: (pass)
- Test Case: Use Down arrow (Jump to next item (scan mode)) to navigate forward to the start of `input[type="radio"]`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Jump to next item (scan mode))
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "cat, radio button, non-selected, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `input[type="radio"]`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "cat, radio button, non-selected, required, 1 of 3"

NVDA Chrome yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"

NVDA Edge yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"

NVDA Firefox yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, clickable, Cat, radio button, not checked, required, clickable, CatDog"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"

Orca Firefox yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, not selected, radio button. dog, not selected, radio button. catdog, not selected, radio button."
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "animal panel, cat, not selected, radio button"

TalkBack Chrome yes

Result: (pass)
- Test Case: Use Swipe right (or alt+right arrow) (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe right (or alt+right arrow) (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "not checked, cat, radio button. double tap to toggle."

Voice Access (Android) Chrome yes

Result: (pass)
- Test Case: Use "Show numbers" (Turn on the numbers overlay)
  1. Launch Voice Access (Android) and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Issue the command: "Show numbers" (Turn on the numbers overlay)
  5. Record results for the relevant expectations
- Output: role is flagged with a number
- Command Notes: said "show numbers"

Voice Control (iOS) Safari not applicable - Voice Control (MacOS) Safari yes

Result: (pass)
- Test Case: Use "Show numbers" (Turn on the numbers overlay)
  1. Launch Voice Control (MacOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Issue the command: "Show numbers" (Turn on the numbers overlay)
  5. Record results for the relevant expectations
- Output: role is flagged with a number
- Command Notes: said "show numbers"

VoiceOver (iOS) Safari yes

Result: (pass)
- Test Case: Use Swipe Right (Next item) to navigate forward to `input[type="radio"]`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe Right (Next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, radio button, unchecked, 1 of 3, required"

VoiceOver (macOS) Safari yes

Result: (pass)
- Test Case: Use VO + Right arrow (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + Right arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, required, radio button, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Cat required, radio button, 1 of 3, animal, animal group"

Windows Speech Recognition Edge yes

Result: (pass)
- Test Case: Use "Show numbers" (Turn on the numbers overlay)
  1. Launch Windows Speech Recognition and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Issue the command: "Show numbers" (Turn on the numbers overlay)
  5. Record results for the relevant expectations
- Output: role was flagged with a number
- Command Notes: said "show numbers"

Windows Speech Recognition Chrome yes

Result: (pass)
- Test Case: Use "Show numbers" (Turn on the numbers overlay)
  1. Launch Windows Speech Recognition and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Issue the command: "Show numbers" (Turn on the numbers overlay)
  5. Record results for the relevant expectations
- Output: role was flagged with a number
- Command Notes: said "show numbers"

These are less common combinations

AT Browser Has Support Output Dragon Naturally Speaking IE unknown - Dragon Naturally Speaking Firefox unknown - JAWS 2019.1906.10 IE 11 yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal, cat radio button, not checked, required"

This expectation is from the input[type="radio"] element feature.

Rationale:

A screen reader user needs to know if the checkbox is checked

Strength of this expectation for different types of assistive technologies:

Screen Readers: MUST
Voice Control: NA

Examples:

A screen reader might announce "checked" or "not checked"
A screen reader might announce the entire control again with the new state

Grading method:

Just one of the listed commands must pass for the expectation to pass.

AT Browser Has Support Output Dragon Naturally Speaking Chrome not applicable - JAWS Chrome yes

Result: (pass)
- Test Case: Use Space (Activate Form Control) on the target of `input[type="radio"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: target
    - Keyboard focus is: target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Space (Activate Form Control)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, checked, required, 1 of 3"

JAWS Edge yes

Result: (pass)
- Test Case: Use Space (Activate Form Control) on the target of `input[type="radio"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: target
    - Keyboard focus is: target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Space (Activate Form Control)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, checked, required, 1 of 3"

JAWS Firefox yes

Result: (pass)
- Test Case: Use Space (Activate Form Control) on the target of `input[type="radio"]`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: target
    - Keyboard focus is: target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Space (Activate Form Control)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, checked, required, 1 of 3"

Narrator Edge yes

Result: (pass)
- Test Case: Use Space (Activate Form Control) on the target of `input[type="radio"]`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: target
    - Keyboard focus is: target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Space (Activate Form Control)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: earcon was conveyed

NVDA Chrome yes

Result: (pass)
- Test Case: Use Space (Activate Form Control) on the target of `input[type="radio"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: target
    - Keyboard focus is: target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Space (Activate Form Control)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "checked"

NVDA Edge yes

Result: (pass)
- Test Case: Use Space (Activate Form Control) on the target of `input[type="radio"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: target
    - Keyboard focus is: target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Space (Activate Form Control)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "checked"

NVDA Firefox yes

Result: (pass)
- Test Case: Use Space (Activate Form Control) on the target of `input[type="radio"]`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: target
    - Keyboard focus is: target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Space (Activate Form Control)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "checked"

Orca Firefox yes

Result: (pass)
- Test Case: Use Space (Activate Form Control) on the target of `input[type="radio"]`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: target
    - Keyboard focus is: target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Space (Activate Form Control)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "selected"

TalkBack Chrome yes

Result: (pass)
- Test Case: Use double tap (Activate form control) on the target of `input[type="radio"]`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: target
    - Keyboard focus is: target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: double tap (Activate form control)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "checked"

Voice Access (Android) Chrome not applicable - Voice Control (iOS) Safari not applicable - Voice Control (MacOS) Safari not applicable - VoiceOver (iOS) Safari yes

Result: (pass)
- Test Case: Use Double tap (Activate Form Control) on the target of `input[type="radio"]`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: target
    - Keyboard focus is: target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Double tap (Activate Form Control)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "checked"

VoiceOver (macOS) Safari yes

Result: (pass)
- Test Case: Use Space (Activate Form Control) on the target of `input[type="radio"]`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: target
    - Keyboard focus is: target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Space (Activate Form Control)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "required, selected, cat, radio button, 1 of 3"

These are less common combinations

AT Browser Has Support Output Dragon Naturally Speaking IE not applicable - Dragon Naturally Speaking Firefox not applicable - JAWS 2019.1906.10 IE 11 yes

Result: (pass)
- Test Case: Use Space (Activate Form Control) on the target of `input[type="radio"]`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: target
    - Keyboard focus is: target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Space (Activate Form Control)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, checked, required"

This expectation is from the input[type="radio"] element feature.

Rationale:

A user needs to where the position is in the list

Strength of this expectation for different types of assistive technologies:

Screen Readers: MUST
Voice Control: NA

Examples:

A screen reader might something like "1 of 6".

Grading method:

Just one of the listed commands must pass for the expectation to pass.

AT Browser Has Support Output Dragon Naturally Speaking Chrome not applicable - JAWS Chrome yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"

JAWS Edge yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"

JAWS Firefox yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal, cat radio button, not checked, required, 1 of 3"

Narrator Edge yes

Result: (pass)
- Test Case: Use Down arrow (Jump to next item (scan mode)) to navigate forward to the start of `input[type="radio"]`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Jump to next item (scan mode))
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "cat, radio button, non-selected, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `input[type="radio"]`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "cat, radio button, non-selected, required, 1 of 3"

NVDA Chrome yes

Result: (fail)
- Test Case: Use down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"

NVDA Edge yes

Result: (fail)
- Test Case: Use down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"

NVDA Firefox yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, clickable, Cat, radio button, not checked, required, clickable, CatDog"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"

Orca Firefox none

Result: (fail)
- Test Case: Use down arrow (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, not selected, radio button. dog, not selected, radio button. catdog, not selected, radio button."
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (fail)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "animal panel, cat, not selected, radio button"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.

Result: (fail)
- Test Case: Use Swipe right (or alt+right arrow) (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe right (or alt+right arrow) (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "not checked, cat, radio button. double tap to toggle."
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.

Result: (pass)
- Test Case: Use Swipe Right (Next item) to navigate forward to `input[type="radio"]`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe Right (Next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, radio button, unchecked, 1 of 3, required"

VoiceOver (macOS) Safari yes

Result: (pass)
- Test Case: Use VO + Right arrow (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + Right arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, required, radio button, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Cat required, radio button, 1 of 3, animal, animal group"

These are less common combinations

AT Browser Has Support Output Dragon Naturally Speaking IE not applicable - Dragon Naturally Speaking Firefox not applicable - JAWS 2019.1906.10 IE 11 none

Result: (fail)
- Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="radio"]`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required"
Result: (fail)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal, cat radio button, not checked, required"

This expectation is from the input[type="radio"] element feature.

Rationale:

A screen reader user needs to know if the checkbox is checked

Strength of this expectation for different types of assistive technologies:

Screen Readers: MUST
Voice Control: NA

Examples:

A screen reader might announce "checked"

Grading method:

Just one of the listed commands must pass for the expectation to pass.

AT Browser Has Support Output Dragon Naturally Speaking Chrome not applicable - JAWS Chrome yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="radio"][checked]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"][checked]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, checked, required, 1 of 3"

JAWS Edge yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="radio"][checked]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"][checked]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, checked, required, 1 of 3"

JAWS Firefox yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="radio"][checked]`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"][checked]`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal, cat radio button, checked, required, 1 of 3"

Narrator Edge yes

Result: (pass)
- Test Case: Use Down arrow (Jump to next item (scan mode)) to navigate forward to the start of `input[type="radio"][checked]`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Jump to next item (scan mode))
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "cat, radio button, selected, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `input[type="radio"][checked]`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "cat, radio button, selected, required, 1 of 3"

NVDA Chrome yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `input[type="radio"][checked]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"][checked]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, checked, required, 1 of 3"

NVDA Edge yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `input[type="radio"][checked]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"][checked]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, checked, required, 1 of 3"

NVDA Firefox yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `input[type="radio"][checked]`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, checked, required, clickable, Cat, radio button, not checked, required, clickable, CatDog"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"][checked]`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, checked, required, 1 of 3"

Orca Firefox yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `input[type="radio"][checked]`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, selected, radio button. dog, not selected, radio button. catdog, not selected, radio button."
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"][checked]`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "animal panel, cat, selected, radio button"

TalkBack Chrome yes

Result: (pass)
- Test Case: Use Swipe right (or alt+right arrow) (Read next item) to navigate forward to `input[type="radio"][checked]`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe right (or alt+right arrow) (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "checked, cat, radio button. double tap to toggle."

Voice Access (Android) Chrome not applicable - Voice Control (iOS) Safari not applicable - Voice Control (MacOS) Safari not applicable - VoiceOver (iOS) Safari yes

Result: (pass)
- Test Case: Use Swipe Right (Next item) to navigate forward to `input[type="radio"][checked]`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe Right (Next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, radio button, checked, 1 of 3, required"

VoiceOver (macOS) Safari yes

Result: (pass)
- Test Case: Use VO + Right arrow (Read next item) to navigate forward to `input[type="radio"][checked]`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + Right arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, required, selected, radio button, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"][checked]`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Cat required, selected, radio button, 1 of 3, animal, animal group"

These are less common combinations

AT Browser Has Support Output Dragon Naturally Speaking IE not applicable - Dragon Naturally Speaking Firefox not applicable - JAWS 2019.1906.10 IE 11 yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="radio"][checked]`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, checked, required"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"][checked]`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"][checked]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal, cat radio button, checked, required"

This expectation is from the input[type="radio"] element feature.

Rationale:

A screen reader user needs to know if the checkbox is checked

Strength of this expectation for different types of assistive technologies:

Screen Readers: MUST
Voice Control: NA

Examples:

A screen reader might announce "unchecked" or imply that the element is not checked by not announcing the checked state at all.

Grading method:

Just one of the listed commands must pass for the expectation to pass.

AT Browser Has Support Output Dragon Naturally Speaking Chrome not applicable - JAWS Chrome yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"

JAWS Edge yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"

JAWS Firefox yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="radio"]:not(checked)`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]:not(checked)
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]:not(checked)`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]:not(checked)
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal, cat radio button, not checked, required, 1 of 3"

Narrator Edge yes

Result: (pass)
- Test Case: Use Down arrow (Jump to next item (scan mode)) to navigate forward to the start of `input[type="radio"]:not(checked)`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]:not(checked)
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Jump to next item (scan mode))
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "cat, radio button, non-selected, required, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `input[type="radio"]:not(checked)`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]:not(checked)
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "cat, radio button, non-selected, required, 1 of 3"

NVDA Chrome yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"

NVDA Edge yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"

NVDA Firefox yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `input[type="radio"]:not(checked)`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]:not(checked)
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, clickable, Cat, radio button, not checked, required, clickable, CatDog"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]:not(checked)`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]:not(checked)
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"

Orca Firefox yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to `input[type="radio"]:not(checked)`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]:not(checked)
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, not selected, radio button. dog, not selected, radio button. catdog, not selected, radio button."
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]:not(checked)`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]:not(checked)
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "animal panel, cat, not selected, radio button"

TalkBack Chrome yes

Result: (pass)
- Test Case: Use Swipe right (or alt+right arrow) (Read next item) to navigate forward to `input[type="radio"]:not(checked)`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]:not(checked)
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe right (or alt+right arrow) (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "not checked, cat, radio button. double tap to toggle."

Voice Access (Android) Chrome not applicable - Voice Control (iOS) Safari not applicable - Voice Control (MacOS) Safari not applicable - VoiceOver (iOS) Safari yes

Result: (pass)
- Test Case: Use Swipe Right (Next item) to navigate forward to `input[type="radio"]:not(checked)`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]:not(checked)
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe Right (Next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, radio button, unchecked, 1 of 3, required"

VoiceOver (macOS) Safari yes

Result: (pass)
- Test Case: Use VO + Right arrow (Read next item) to navigate forward to `input[type="radio"]:not(checked)`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]:not(checked)
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + Right arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, required, radio button, 1 of 3"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]:not(checked)`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]:not(checked)
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Cat required, radio button, 1 of 3, animal, animal group"

These are less common combinations

AT Browser Has Support Output Dragon Naturally Speaking IE not applicable - Dragon Naturally Speaking Firefox not applicable - JAWS 2019.1906.10 IE 11 yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="radio"]:not(checked)`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]:not(checked)
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="radio"]:not(checked)`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]:not(checked)
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal, cat radio button, not checked, required"

This expectation is from the input[type="radio"] element feature.

Rationale:

Screen reader users might want to quickly navigate to elements of this type.

Strength of this expectation for different types of assistive technologies:

Screen Readers: SHOULD
Voice Control: NA

Grading method:

Just one of the listed commands must pass for the expectation to pass.

AT Browser Has Support Output Dragon Naturally Speaking Chrome not applicable - JAWS Chrome yes

Result: (pass)
- Test Case: Use f (Next form field) to navigate forward to `input[type="radio"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: f (Next form field)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Insert + F3 (Open element list)
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Insert + F3 (Open element list)
    - After issuing the command, virtual focus should be: na
  6. Record results for the relevant expectations
- Output: in list of form field

JAWS Edge yes

Result: (pass)
- Test Case: Use f (Next form field) to navigate forward to `input[type="radio"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: f (Next form field)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Insert + F3 (Open element list)
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Insert + F3 (Open element list)
    - After issuing the command, virtual focus should be: na
  6. Record results for the relevant expectations
- Output: in list of form field

JAWS Firefox yes

Result: (pass)
- Test Case: Use f (Next form field) to navigate forward to `input[type="radio"]`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: f (Next form field)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Insert + F3 (Open element list)
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Insert + F3 (Open element list)
    - After issuing the command, virtual focus should be: na
  6. Record results for the relevant expectations
- Output: in list of form field

Narrator Edge yes

Result: (pass)
- Test Case: Use f (Next form field) to navigate forward to `input[type="radio"]`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: f (Next form field)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, radio button, non-selected, required, 1 of 3"

NVDA Chrome yes

Result: (pass)
- Test Case: Use f (Next form field) to navigate forward to `input[type="radio"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: f (Next form field)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "animal grouping, cat, radio button, not checked, required"
Result: (partial)
- Test Case: Use NVDA + F7 (Open Elements List)
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: NVDA + F7 (Open Elements List)
    - After issuing the command, virtual focus should be: na
  6. Record results for the relevant expectations
- Output: in list of form fields as "unlabeled; radio button; not checked, required; cat"
- Result Notes: partial support due to the 'unlabeled' part of the listing.

NVDA Edge yes

Result: (pass)
- Test Case: Use f (Next form field) to navigate forward to `input[type="radio"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: f (Next form field)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "animal grouping, cat, radio button, not checked, required"
Result: (partial)
- Test Case: Use NVDA + F7 (Open Elements List)
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: NVDA + F7 (Open Elements List)
    - After issuing the command, virtual focus should be: na
  6. Record results for the relevant expectations
- Output: in list of form fields as "unlabeled; radio button; not checked, required; cat"
- Result Notes: partial support due to the 'unlabeled' part of the listing.

NVDA Firefox yes

Result: (pass)
- Test Case: Use f (Next form field) to navigate forward to `input[type="radio"]`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: f (Next form field)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, radio button, not checked, required"
Result: (pass)
- Test Case: Use NVDA + F7 (Open Elements List)
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: NVDA + F7 (Open Elements List)
    - After issuing the command, virtual focus should be: na
  6. Record results for the relevant expectations
- Output: in list of form fields as "cat; radio button; not checked, required"

Orca Firefox yes

Result: (pass)
- Test Case: Use r (Next radio button) to navigate forward to `input[type="radio"]`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: r (Next radio button)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat, not selected, radio button"
Result: (pass)
- Test Case: Use alt + shift + r (list radio buttons) to navigate forward to `input[type="radio"]`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: alt + shift + r (list radio buttons)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: in list of radio buttons

TalkBack Chrome yes

Result: (pass)
- Test Case: Use Swipe down (alt+c) (next control (correct reading control must be selected)) to navigate forward to `input[type="radio"]`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe down (alt+c) (next control (correct reading control must be selected))
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "not checked, cat, radio button, double tap to toggle"

Voice Access (Android) Chrome not applicable - Voice Control (iOS) Safari not applicable - Voice Control (MacOS) Safari not applicable - VoiceOver (iOS) Safari yes

Result: (pass)
- Test Case: Use Swipe down (next form control (correct item type must be selected)) to navigate forward to `input[type="radio"]`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe down (next form control (correct item type must be selected))
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal, cat, radio button, checked, 1 of 3, required"

VoiceOver (macOS) Safari yes

Result: (pass)
- Test Case: Use VO + Command + J (Next Form Control) to navigate forward to `input[type="radio"]`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + Command + J (Next Form Control)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Cat, required, radio button, 1 of 3"
Result: (pass)
- Test Case: Use VO + U (Open Rotor)
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + U (Open Rotor)
    - After issuing the command, virtual focus should be: na
  6. Record results for the relevant expectations
- Output: in list of form controls

These are less common combinations

AT Browser Has Support Output Dragon Naturally Speaking IE not applicable - Dragon Naturally Speaking Firefox not applicable - JAWS 2019.1906.10 IE 11 yes

Result: (pass)
- Test Case: Use f (Next form field) to navigate forward to `input[type="radio"]`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: f (Next form field)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "cat radio button, not checked, required"
Result: (pass)
- Test Case: Use Insert + F3 (Open element list)
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:input[type="radio"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Insert + F3 (Open element list)
    - After issuing the command, virtual focus should be: na
  6. Record results for the relevant expectations
- Output: in list of form field

This expectation is from the legend element feature.

Rationale:

A screen reader user needs to know what to enter.

Strength of this expectation for different types of assistive technologies:

Screen Readers: MUST
Voice Control: NA

Grading method:

Just one of the listed commands must pass for the expectation to pass.

AT Browser Has Support Output Dragon Naturally Speaking Chrome not applicable - JAWS Chrome yes

Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, CatDog radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "group start, animal"
Result: (fail)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch JAWS and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "group end"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.

JAWS Edge yes

Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, cat radio button, not checked, required, 1 of 3"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal group, CatDog radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "group start, animal"
Result: (fail)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to the end of `fieldset`
  1. Launch JAWS and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "group end"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.

JAWS Firefox yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to the start of `legend, fieldset`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "group start, animal"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `legend, fieldset`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal, cat, radio button, not checked, required, 1 of 3"
Result: (fail)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to the end of `legend, fieldset`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "group end"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `legend, fieldset`
  1. Launch JAWS and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal, CatDog, radio button, not checked, required, 3 of 3"

Narrator Edge yes

Result: (pass)
- Test Case: Use Down arrow (Jump to next item (scan mode)) to navigate forward to the start of `legend, fieldset`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Jump to next item (scan mode))
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "animal"
Result: (fail)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `legend, fieldset`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "cat, radio button, non-selected, required, 1 of 3"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (fail)
- Test Case: Use Up arrow (Jump to previous item (scan mode)) to navigate backwards to the end of `legend, fieldset`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Jump to previous item (scan mode))
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "CatDog"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (fail)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `legend, fieldset`
  1. Launch Narrator and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "CatDog, radio button, non-selected, required, 3 of 3"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.

NVDA Chrome yes

Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"
Result: (fail)
- Test Case: Use up arrow (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "grouping, radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, catdog, radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch NVDA and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "grouping, animal"

NVDA Edge yes

Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"
Result: (fail)
- Test Case: Use up arrow (Read previous item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "grouping, radio button, not checked, required, Cat, radio button, not checked, required, dog, radio button, not checked, required, CatDog"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards to `*[aria-required="true"]`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:*[aria-required="true"]
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Animal grouping, catdog, radio button, not checked, required, 3 of 3"
Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to the start of `fieldset`
  1. Launch NVDA and Edge.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "grouping, animal"

NVDA Firefox yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to the start of `legend, fieldset`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "Animal"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `legend, fieldset`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"
Result: (fail)
- Test Case: Use up arrow (Read previous item) to navigate backwards to the end of `legend, fieldset`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "radio button, not checked, required, clickable, Cat, radio button, not checked, required, clickable, CatDog"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `legend, fieldset`
  1. Launch NVDA and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal grouping, cat, radio button, not checked, required, 1 of 3"

Orca Firefox yes

Result: (pass)
- Test Case: Use down arrow (Read next item) to navigate forward to the start of `legend, fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "animal panel"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `legend, fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal panel, cat, not selected, radio button"
Result: (pass)
- Test Case: Use up arrow (Read previous item) to navigate backwards to the end of `legend, fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "animal panel. cat, not selected, radio button. dog, not selected, radio button. catdog, not selected, radio button. "
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `legend, fieldset`
  1. Launch Orca and Firefox.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal panel, catdog, not selected, radio button"

TalkBack Chrome yes

Result: (pass)
- Test Case: Use Swipe right (or alt+right arrow) (Read next item) to navigate forward into `legend, fieldset`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe right (or alt+right arrow) (Read next item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal"
Result: (fail)
- Test Case: Use Swipe left (or alt+left arrow) (Read previous item) to navigate backwards into `legend, fieldset`
  1. Launch TalkBack and Chrome.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe left (or alt+left arrow) (Read previous item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "not checked, CatDog, radio button"
- Grading note: This command may be expected to fail. This result simply indicates that it did not yield support.

Voice Access (Android) Chrome not applicable - Voice Control (iOS) Safari not applicable - Voice Control (MacOS) Safari not applicable - VoiceOver (iOS) Safari yes

Result: (pass)
- Test Case: Use Swipe Right (Next item) to navigate forward into `legend, fieldset`
  1. Launch VoiceOver (iOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Swipe Right (Next item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "animal, form start"

VoiceOver (macOS) Safari yes

Result: (pass)
- Test Case: Use VO + Right arrow (Read next item) to navigate forward to `legend, fieldset`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + Right arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "animal, group"
Result: (pass)
- Test Case: Use VO + Right arrow (Read next item) to navigate forward to `legend, fieldset`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: VO + Right arrow (Read next item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "animal, group"
- Result Notes: the legend is in the reading order, in addition to the group
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward to `legend, fieldset`
  1. Launch VoiceOver (macOS) and Safari.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: target
  6. Record results for the relevant expectations
- Output: "Cat required, radio button, 1 of 3, animal, animal group"

These are less common combinations

AT Browser Has Support Output Dragon Naturally Speaking IE not applicable - Dragon Naturally Speaking Firefox not applicable - JAWS 2019.1906.10 IE 11 yes

Result: (pass)
- Test Case: Use Down arrow (Read next item) to navigate forward to the start of `legend, fieldset`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Down arrow (Read next item)
    - After issuing the command, virtual focus should be: start of target
  6. Record results for the relevant expectations
- Output: "group start, animal"
Result: (pass)
- Test Case: Use Tab (Read next focusable item) to navigate forward into `legend, fieldset`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: before target
    - Keyboard focus is: before target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Tab (Read next focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal, cat, radio button, not checked, required"
Result: (fail)
- Test Case: Use Up arrow (Read previous item) to navigate backwards to the end of `legend, fieldset`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Up arrow (Read previous item)
    - After issuing the command, virtual focus should be: end of target
  6. Record results for the relevant expectations
- Output: "group end"
Result: (pass)
- Test Case: Use Shift + Tab (Read previous focusable item) to navigate backwards into `legend, fieldset`
  1. Launch JAWS and IE.
  2. Navigate to the test page.
  3. Find the target element(s) that you will test against. Identify all elements that match this selector:legend, fieldset
    - If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
  4. Position and configure the screen reader so that the following conditions are met
    - Virtual focus is: after target
    - Keyboard focus is: after target
    - Mode is: auto (do not explicitly change the mode)
  5. Issue the command: Shift + Tab (Read previous focusable item)
    - After issuing the command, virtual focus should be: within target
  6. Record results for the relevant expectations
- Output: "Animal, CatDog, radio button, not checked, required"

Narrator Firefox unknown - Narrator Chrome unknown - Narrator IE unknown - NVDA IE unknown - TalkBack Firefox unknown - Voice Access (Android) Firefox not applicable - VoiceOver (iOS) Chrome unknown - VoiceOver (macOS) Chrome unknown - VoiceOver (macOS) Firefox unknown - Orca Chrome unknown - Voice Control (MacOS) Chrome not applicable - Voice Control (MacOS) Firefox not applicable - Mac Keyboard Firefox not applicable - Android Keyboard Firefox not applicable - Back to top Dates and Versions of tested combinations AT AT Version Browser Browser version OS version Date tested Dragon Naturally Speaking 15.30 Chrome 76 Windows 10 version 1903 2019-08-21 JAWS 2021.2107.12 Chrome 92 Windows 10 version 21h1 2021-07-28 JAWS 2021.2107.12 Edge 92 Windows 10 version 21h1 2021-07-28 JAWS 2019.1906.10 Firefox 68 Windows 10 version 1903 2019-08-21 Narrator Windows 10 version 1903 Edge 44 Windows 10 version 1903 2019-08-21 NVDA 2021.1 Chrome 92 Windows 10 version 21h1 2021-07-28 NVDA 2021.1 Edge 92 Windows 10 version 21h1 2021-07-28 NVDA 2019.2 Firefox 68 Windows 10 version 1903 2019-08-21 Orca 3.31.4 Firefox 69 Ubuntu 19.04 2019-09-15 TalkBack 7.3.0 Chrome 76 7 2019-08-21 Voice Access (Android) 3.1 Chrome 77 7 2019-10-02 Voice Control (iOS) 13.0 Safari 13.0 13.0 2019-09-23 Voice Control (MacOS) 10.15 Safari 13.0.2 10.15 2019-10-07 VoiceOver (iOS) 12.3.1 Safari 12.3.1 12.3.1 2019-08-21 VoiceOver (macOS) 10.14.6 Safari 12.1.2 10.14.5 2019-08-21 Windows Speech Recognition Windows 10 version 1903 Edge 44 Windows 10 version 1903 2019-10-18 Windows Speech Recognition Windows 10 version 1903 Chrome 77 Windows 10 version 1903 2019-10-18 History

2019-08-21 Test created
2019-09-15 added orca results
2019-09-23 Add vc_ios results
2019-10-02 Add va_and results
2019-10-07 Add vc_macos results
2019-10-18 Add wsr results
2021-07-28 Added Narrator results for NVDA and JAWS, updated NVDA+Chrome results.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4

Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://a11ysupport.io/tests/tech__aria__aria-required-on-html-radio-buttons below:

Test: aria-required attribute on each HTML radio button in a fieldset

Showing content from https://a11ysupport.io/tests/techariaaria-required-on-html-radio-buttons below: