Notice: This is a work in progress. Please submit feedback or suggestions.

Test: Basic html number input test

Screen Reader support level: partial (45/49)

Voice Control support level: partial (12/14)

On this page

About this test

A basic html number input test.

Run this test and submit your results

Age of results

Results in this test range from a year ago to 2 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 2 years ago. Consider running this test and contributing results.

Test HTML

open the test page

HTML source is too long to display here.

Summary of Screen Reader support by expectation

* means that some support is hidden behind settings

Summary of Voice Control support by expectation

* means that some support is hidden behind settings

Detailed support results by expectation

Expectation for the input[type="number"] element: convey its name

This expectation is from the input[type="number"] 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.

ATBrowserHas SupportOutput
Dragon Naturally SpeakingChromeyes
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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: input was focused
    • Command Notes: said "click your favorite number"
JAWSChromeyes
  • Result: (pass)
    • Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox 11"
    • Result Notes: announced the name when entering the input and did not automatically switch to forms mode.
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox, 11, to set the value use the arrow keys or type the value"
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox, 11"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 fields as "Your favorite number? edit, 11"
JAWSIEpartial
  • Result: (fail)
    • Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "edit, 11"
    • Result Notes: announced the role and value when entering the input and did not automatically switch to forms mode.
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, 11, type in text"
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, 11"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 fields as "Your favorite number? edit, 11"
JAWSFirefoxyes
  • Result: (pass)
    • Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox 11"
    • Result Notes: announced the name when entering the input and did not automatically switch to forms mode.
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox, 11, to set the value use the arrow keys or type the value"
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox, 11"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 fields as "Your favorite number? edit, 11"
NarratorEdgeyes
  • Result: (pass)
    • Test Case: Use Down arrow (Read next item (scan mode)) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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 (scan mode))
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: "Your favorite number, number, 11, minimum zero, and maximum zero, 11."
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, 11, minimum zero, and maximum zero, 11 selected."
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, 11, minimum zero, and maximum zero, 11 selected"
NVDAChromepartial
  • Result: (pass)
    • Test Case: Use down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, editable, 11"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, editable, selected 11"
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, editable, 11"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 controls as "11; spin button; editable"
    • Result Notes: name is conveyed when the input is blank
NVDAFirefoxpartial
  • Result: (pass)
    • Test Case: Use down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "clickable, your favorite number, spin button has auto complete, editable, 11"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, has auto complete, editable, 11"
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, has auto complete, editable, 11"
  • Result: (partial)
    • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 controls as "11; spin button; has auto complete; editable;"
    • Result Notes: name is present if the input is blank
OrcaFirefoxyes
  • Result: (pass)
    • Test Case: Use down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, 11, spin button"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, entry, 11, selected"
  • Result: (pass)
    • Test Case: Use e (Next edit field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: e (Next edit field)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: "your favorite number, 11, spin button"
  • Result: (pass)
    • Test Case: Use alt + shift + f (Open list of form fields) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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 + f (Open list of form fields)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: in list of form controls as "your favorite number?; spin button; 11"
TalkBackChromeyes
  • Result: (pass)
    • Test Case: Use Swipe right (or alt+right arrow) (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button"
  • Result: (pass)
    • Test Case: Use Swipe down (alt+c) (next control (correct reading control must be selected)) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button"
Voice Access (Android)Chromenone
  • Result: (fail)
    • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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: input was not focused
    • Command Notes: said "tap your favorite number"
Voice Control (iOS)Safariyes
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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: input was focused
    • Command Notes: said tap your favorite number
Voice Control (MacOS)Safariyes
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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: input was focused
    • Command Notes: said "click your favorite number"
VoiceOver (iOS)Safariyes
  • Result: (pass)
    • Test Case: Use Swipe Right (Next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number? 11, text field, double tap to edit."
  • Result: (pass)
    • Test Case: Use Swipe down (next form control (correct item type must be selected)) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "Your favorite number? 11, text field, double tab to edit"
VoiceOver (macOS)Safariyes
  • Result: (pass)
    • Test Case: Use VO + Right arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "11, contents selected, your favorite number? incrementable edit text"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "11, contents selected, your favorite number? incrementable edit text"
  • Result: (pass)
    • Test Case: Use VO + Command + J (Next Form Control) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "11, contents selected, your favorite number? incrementable edit text"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 as "11 your favorite number? incrementable edit text"
Windows Speech RecognitionChromeyes
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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 yur favorite number"

Extended Support for: input[type="number"] element: convey its name

These are less common combinations

ATBrowserHas SupportOutput
Dragon Naturally SpeakingIEunknown-
Dragon Naturally SpeakingFirefoxunknown-
JAWSEdgeunknown-
NarratorFirefoxunknown-
NarratorChromeunknown-
NarratorIEunknown-
NVDAIEunknown-
NVDAEdgeunknown-
TalkBackFirefoxunknown-
Voice Access (Android)Firefoxunknown-
VoiceOver (iOS)Chromeunknown-
VoiceOver (macOS)Chromeunknown-
VoiceOver (macOS)Firefoxunknown-
OrcaChromeunknown-
Voice Control (MacOS)Chromeunknown-
Voice Control (MacOS)Firefoxunknown-
Windows Speech Recognition 1903Edge 44yes
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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 your favorite number"
Back to top

Expectation for the input[type="number"] element: convey its role

This expectation is from the input[type="number"] 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 "number", "text input", "edit", "edit text", "spinbox", "spin button", "incrementable" etc.
  • Voice control software will let the user say something like "click edit" 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.

ATBrowserHas SupportOutput
Dragon Naturally SpeakingChromeyes
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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: input was flagged for disambiguation
    • Command Notes: said "click edit"
JAWSChromeyes
  • Result: (pass)
    • Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox 11"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox, 11, to set the value use the arrow keys or type the value"
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox, 11"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 fields as "Your favorite number? edit, 11"
JAWSIEyes
  • Result: (pass)
    • Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "edit, 11"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, 11, type in text"
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, 11"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 fields as "Your favorite number? edit, 11"
JAWSFirefoxyes
  • Result: (pass)
    • Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox 11"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox, 11, to set the value use the arrow keys or type the value"
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox, 11"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 fields as "Your favorite number? edit, 11"
NarratorEdgeyes
  • Result: (pass)
    • Test Case: Use Down arrow (Read next item (scan mode)) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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 (scan mode))
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: "Your favorite number, number, 11, minimum zero, and maximum zero, 11."
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, 11, minimum zero, and maximum zero, 11 selected."
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, 11, minimum zero, and maximum zero, 11 selected"
NVDAChromeyes
  • Result: (pass)
    • Test Case: Use down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, editable, 11"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, editable, selected 11"
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, editable, 11"
  • Result: (pass)
    • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 controls as "11; spin button; editable"
NVDAFirefoxyes
  • Result: (pass)
    • Test Case: Use down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "clickable, your favorite number, spin button has auto complete, editable, 11"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, has auto complete, editable, 11"
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, has auto complete, editable, 11"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 controls as "11; spin button; has auto complete; editable;"
OrcaFirefoxyes
  • Result: (pass)
    • Test Case: Use down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, 11, spin button"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, entry, 11, selected"
  • Result: (pass)
    • Test Case: Use e (Next edit field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: e (Next edit field)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: "your favorite number, 11, spin button"
  • Result: (pass)
    • Test Case: Use alt + shift + f (Open list of form fields) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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 + f (Open list of form fields)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: in list of form controls as "your favorite number?; spin button; 11"
TalkBackChromeyes
  • Result: (pass)
    • Test Case: Use Swipe right (or alt+right arrow) (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button"
  • Result: (pass)
    • Test Case: Use Swipe down (alt+c) (next control (correct reading control must be selected)) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button"
Voice Access (Android)Chromeyes
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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"
Voice Control (iOS)Safarinot applicable-
Voice Control (MacOS)Safariyes
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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: input was flagged for disambiguation
VoiceOver (iOS)Safariyes
  • Result: (pass)
    • Test Case: Use Swipe Right (Next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number? 11, text field, double tap to edit."
  • Result: (pass)
    • Test Case: Use Swipe down (next form control (correct item type must be selected)) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "Your favorite number? 11, text field, double tab to edit"
VoiceOver (macOS)Safariyes
  • Result: (pass)
    • Test Case: Use VO + Right arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "11, contents selected, your favorite number? incrementable edit text"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "11, contents selected, your favorite number? incrementable edit text"
  • Result: (pass)
    • Test Case: Use VO + Command + J (Next Form Control) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "11, contents selected, your favorite number? incrementable edit text"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 as "11 your favorite number? incrementable edit text"
Windows Speech RecognitionChromeyes
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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"

Extended Support for: input[type="number"] element: convey its role

These are less common combinations

ATBrowserHas SupportOutput
Dragon Naturally SpeakingIEunknown-
Dragon Naturally SpeakingFirefoxunknown-
JAWSEdgeunknown-
NarratorFirefoxunknown-
NarratorChromeunknown-
NarratorIEunknown-
NVDAIEunknown-
NVDAEdgeunknown-
TalkBackFirefoxunknown-
Voice Access (Android)Firefoxunknown-
VoiceOver (iOS)Chromeunknown-
VoiceOver (macOS)Chromeunknown-
VoiceOver (macOS)Firefoxunknown-
OrcaChromeunknown-
Voice Control (MacOS)Chromeunknown-
Voice Control (MacOS)Firefoxunknown-
Windows Speech Recognition 1903Edge 44yes
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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"
Back to top

Expectation for the input[type="number"] element: convey the current value

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

Rationale:

A screen reader user needs to know the current value of the input.

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.

ATBrowserHas SupportOutput
Dragon Naturally SpeakingChromenot applicable-
JAWSChromeyes
  • Result: (pass)
    • Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox 11"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox, 11, to set the value use the arrow keys or type the value"
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox, 11"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 fields as "Your favorite number? edit, 11"
JAWSIEyes
  • Result: (pass)
    • Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "edit, 11"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, 11, type in text"
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, 11"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 fields as "Your favorite number? edit, 11"
JAWSFirefoxyes
  • Result: (pass)
    • Test Case: Use Down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox 11"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox, 11, to set the value use the arrow keys or type the value"
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox, 11"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 fields as "Your favorite number? edit, 11"
NarratorEdgeyes
  • Result: (pass)
    • Test Case: Use Down arrow (Read next item (scan mode)) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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 (scan mode))
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: "Your favorite number, number, 11, minimum zero, and maximum zero, 11."
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, 11, minimum zero, and maximum zero, 11 selected."
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, 11, minimum zero, and maximum zero, 11 selected"
NVDAChromeyes
  • Result: (pass)
    • Test Case: Use down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, editable, 11"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, editable, selected 11"
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, editable, 11"
  • Result: (pass)
    • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 controls as "11; spin button; editable"
NVDAFirefoxyes
  • Result: (pass)
    • Test Case: Use down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "clickable, your favorite number, spin button has auto complete, editable, 11"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, has auto complete, editable, 11"
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, has auto complete, editable, 11"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 controls as "11; spin button; has auto complete; editable;"
OrcaFirefoxyes
  • Result: (pass)
    • Test Case: Use down arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, 11, spin button"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, entry, 11, selected"
  • Result: (pass)
    • Test Case: Use e (Next edit field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: e (Next edit field)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: "your favorite number, 11, spin button"
  • Result: (pass)
    • Test Case: Use alt + shift + f (Open list of form fields) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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 + f (Open list of form fields)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: in list of form controls as "your favorite number?; spin button; 11"
TalkBackChromenone
  • Result: (fail)
    • Test Case: Use Swipe right (or alt+right arrow) (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button"
  • Result: (fail)
    • Test Case: Use Swipe down (alt+c) (next control (correct reading control must be selected)) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button"
Voice Access (Android)Chromenot applicable-
Voice Control (iOS)Safarinot applicable-
Voice Control (MacOS)Safarinot applicable-
VoiceOver (iOS)Safariyes
  • Result: (pass)
    • Test Case: Use Swipe Right (Next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number? 11, text field, double tap to edit."
  • Result: (pass)
    • Test Case: Use Swipe down (next form control (correct item type must be selected)) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "Your favorite number? 11, text field, double tab to edit"
VoiceOver (macOS)Safariyes
  • Result: (pass)
    • Test Case: Use VO + Right arrow (Read next item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "11, contents selected, your favorite number? incrementable edit text"
  • Result: (pass)
    • Test Case: Use Tab (Read next focusable item) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "11, contents selected, your favorite number? incrementable edit text"
  • Result: (pass)
    • Test Case: Use VO + Command + J (Next Form Control) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "11, contents selected, your favorite number? incrementable edit text"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 as "11 your favorite number? incrementable edit text"
Windows Speech RecognitionChromenot applicable-

Extended Support for: input[type="number"] element: convey the current value

These are less common combinations

ATBrowserHas SupportOutput
Dragon Naturally SpeakingIEnot applicable-
Dragon Naturally SpeakingFirefoxnot applicable-
JAWSEdgeunknown-
NarratorFirefoxunknown-
NarratorChromeunknown-
NarratorIEunknown-
NVDAIEunknown-
NVDAEdgeunknown-
TalkBackFirefoxunknown-
Voice Access (Android)Firefoxnot applicable-
VoiceOver (iOS)Chromeunknown-
VoiceOver (macOS)Chromeunknown-
VoiceOver (macOS)Firefoxunknown-
OrcaChromeunknown-
Voice Control (MacOS)Chromenot applicable-
Voice Control (MacOS)Firefoxnot applicable-
Windows Speech Recognition 1903Edge 44not applicable-
Back to top

Expectation for the input[type="number"] element: convey changes in value

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

Rationale:

The user needs to know that the value was successfully changed.

Strength of this expectation for different types of assistive technologies:

  • Screen Readers: MUST
  • Voice Control: NA

Examples:

  • When the user enter texts, the screen reader will announce it back to them.

Grading method:

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

ATBrowserHas SupportOutput
Dragon Naturally SpeakingChromenot applicable-
JAWSChromeyes
  • Result: (pass)
    • Test Case: Use <enter text> (enter text) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <enter text> (enter text)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: name of key was announced
JAWSIEyes
  • Result: (pass)
    • Test Case: Use <enter text> (enter text) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <enter text> (enter text)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: name of key was announced
JAWSFirefoxyes
  • Result: (pass)
    • Test Case: Use <enter text> (enter text) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <enter text> (enter text)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: name of key was announced
NarratorEdgeyes
  • Result: (pass)
    • Test Case: Use <enter text> (enter text) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <enter text> (enter text)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: name of key was announced
NVDAChromeyes
  • Result: (pass)
    • Test Case: Use <enter text> (enter text) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <enter text> (enter text)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: name of key was announced
NVDAFirefoxyes
  • Result: (pass)
    • Test Case: Use <enter text> (enter text) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <enter text> (enter text)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: name of key was announced
OrcaFirefoxyes
  • Result: (pass)
    • Test Case: Use <enter text> (enter text) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <enter text> (enter text)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: name of key was announced
TalkBackChromeyes
  • Result: (pass)
    • Test Case: Use <enter text> (enter text) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <enter text> (enter text)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: name of key was announced
Voice Access (Android)Chromenot applicable-
Voice Control (iOS)Safarinot applicable-
Voice Control (MacOS)Safarinot applicable-
VoiceOver (iOS)Safariyes
  • Result: (pass)
    • Test Case: Use <enter text> (enter text) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <enter text> (enter text)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: name of key was announced
VoiceOver (macOS)Safariyes
  • Result: (pass)
    • Test Case: Use <enter text> (enter text) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <enter text> (enter text)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: name of key was announced
Windows Speech RecognitionChromenot applicable-

Extended Support for: input[type="number"] element: convey changes in value

These are less common combinations

ATBrowserHas SupportOutput
Dragon Naturally SpeakingIEnot applicable-
Dragon Naturally SpeakingFirefoxnot applicable-
JAWSEdgeunknown-
NarratorFirefoxunknown-
NarratorChromeunknown-
NarratorIEunknown-
NVDAIEunknown-
NVDAEdgeunknown-
TalkBackFirefoxunknown-
Voice Access (Android)Firefoxnot applicable-
VoiceOver (iOS)Chromeunknown-
VoiceOver (macOS)Chromeunknown-
VoiceOver (macOS)Firefoxunknown-
OrcaChromeunknown-
Voice Control (MacOS)Chromenot applicable-
Voice Control (MacOS)Firefoxnot applicable-
Windows Speech Recognition 1903Edge 44not applicable-
Back to top

Expectation for the input[type="number"] element: allow data entry

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

Rationale:

Users need to be able to enter data

Strength of this expectation for different types of assistive technologies:

  • Screen Readers: NA
  • Voice Control: MUST

Examples:

  • Voice control software might allow someone to dictate data into a field once it is focused.

Grading method:

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

ATBrowserHas SupportOutput
Dragon Naturally SpeakingChromeyes
  • Result: (pass)
    • Test Case: Use "{speak text to type}" (dictate)
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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: "{speak text to type}" (dictate)
      5. Record results for the relevant expectations
    • Output: value was updated
    • Command Notes: said "ten"
JAWSChromenot applicable-
JAWSIEnot applicable-
JAWSFirefoxnot applicable-
NarratorEdgenot applicable-
NVDAChromenot applicable-
NVDAFirefoxnot applicable-
OrcaFirefoxnot applicable-
TalkBackChromenot applicable-
Voice Access (Android)Chromeyes
  • Result: (pass)
    • Test Case: Use "{speak text to type}" (dictate)
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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: "{speak text to type}" (dictate)
      5. Record results for the relevant expectations
    • Output: input was recognized
    • Command Notes: said "10" - number kept being interpreted as a command. Instead I entered data by controlling the on-screen keyboard.
Voice Control (iOS)Safariyes
  • Result: (pass)
    • Test Case: Use "{speak text to type}" (dictate)
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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: "{speak text to type}" (dictate)
      5. Record results for the relevant expectations
    • Output: input was recognized
    • Command Notes: said "cats"
Voice Control (MacOS)Safariyes
  • Result: (pass)
    • Test Case: Use "{speak text to type}" (dictate)
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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: "{speak text to type}" (dictate)
      5. Record results for the relevant expectations
    • Output: input was recognized
    • Command Notes: said "10"
VoiceOver (iOS)Safarinot applicable-
VoiceOver (macOS)Safarinot applicable-
Windows Speech RecognitionChromenone
  • Result: (fail)
    • Test Case: Use "{speak text to type}" (dictate)
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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: "{speak text to type}" (dictate)
      5. Record results for the relevant expectations
    • Output: input was not recognized
    • Command Notes: said "numeral 10" and "ten"

Extended Support for: input[type="number"] element: allow data entry

These are less common combinations

ATBrowserHas SupportOutput
Dragon Naturally SpeakingIEunknown-
Dragon Naturally SpeakingFirefoxunknown-
JAWSEdgenot applicable-
NarratorFirefoxnot applicable-
NarratorChromenot applicable-
NarratorIEnot applicable-
NVDAIEnot applicable-
NVDAEdgenot applicable-
TalkBackFirefoxnot applicable-
Voice Access (Android)Firefoxunknown-
VoiceOver (iOS)Chromenot applicable-
VoiceOver (macOS)Chromenot applicable-
VoiceOver (macOS)Firefoxnot applicable-
OrcaChromenot applicable-
Voice Control (MacOS)Chromeunknown-
Voice Control (MacOS)Firefoxunknown-
Windows Speech Recognition 1903Edge 44unknown-
Back to top

Expectation for the input[type="number"] element: convey when input is rejected

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

Rationale:

The number input only allows numbers to be entered. Characters that the user attempts to enter that are outside of the allowed characters are rejected by the input and never displayed visually. Because a sighted user gets this visual feedback that their input was not accepted, a blind screen reader user also needs to know when input is not accepted. Otherwise, the user might assume that the data was accepted.

Strength of this expectation for different types of assistive technologies:

  • Screen Readers: MUST
  • Voice Control: NA

Examples:

  • the behavior might be implied if the control is conveyed as something like "number", "spinbox", "spin button", or "incrementable"
  • some AT/browser combinations will allow invalid input but convey the field as invalid
  • screen readers might announce an earcon when the user tries to enter data beyond the maximum length.
  • screen readers might imply that the input was rejected by not announcing anything when a user tries to enter data (usually the keypress is echoed)

Grading method:

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

ATBrowserHas SupportOutput
Dragon Naturally SpeakingChromenot applicable-
JAWSChromeyes
  • Result: (pass)
    • Test Case: Enter invalid text into the number input using enter text (<enter text>)
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
      4. set mode to auto (do not explicitly change the mode)
      5. issue command
        • summary: navigate forward to the number input
        • Using the command: "Tab" (Read next focusable item)
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • keyboard focus location: target
          • virtual cursor location: target
      6. issue command
        • summary: type "two"
        • Using the command: "<enter text>" (enter text)
        • Observe: the input should be rejected and the screen reader should have conveyed that the input was rejected.
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • keyboard focus location: target
          • virtual cursor location: target
      7. is the expectation met?
    • Output: Each keypress was echoed, with no indication that the input was rejected
    • Result Notes: pass because the behavior is implied by "spinbox"
JAWSIEnot applicable
  • Result: (na)
    • Test Case: Enter invalid text into the number input using enter text (<enter text>)
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
      4. set mode to auto (do not explicitly change the mode)
      5. issue command
        • summary: navigate forward to the number input
        • Using the command: "Tab" (Read next focusable item)
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • keyboard focus location: target
          • virtual cursor location: target
      6. issue command
        • summary: type "two"
        • Using the command: "<enter text>" (enter text)
        • Observe: the input should be rejected and the screen reader should have conveyed that the input was rejected.
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • keyboard focus location: target
          • virtual cursor location: target
      7. is the expectation met?
    • Output: Key presses were echoed
    • Result Notes: na because IE does not support this feature
JAWSFirefoxyes
  • Result: (pass)
    • Test Case: Enter invalid text into the number input using enter text (<enter text>)
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
      4. set mode to auto (do not explicitly change the mode)
      5. issue command
        • summary: navigate forward to the number input
        • Using the command: "Tab" (Read next focusable item)
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • keyboard focus location: target
          • virtual cursor location: target
      6. issue command
        • summary: type "two"
        • Using the command: "<enter text>" (enter text)
        • Observe: the input should be rejected and the screen reader should have conveyed that the input was rejected.
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • keyboard focus location: target
          • virtual cursor location: target
      7. is the expectation met?
    • Output: "<key press> invalid entry"
    • Result Notes: it appears that firefox allows invalid input but marks the field as invalid instead of outright rejecting the input.
NarratorEdgeyes
  • Result: (pass)
    • Test Case: Enter invalid text into the number input using enter text (<enter text>)
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
      4. set mode to auto (do not explicitly change the mode)
      5. issue command
        • summary: navigate forward to the number input
        • Using the command: "Tab" (Read next focusable item)
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • keyboard focus location: target
          • virtual cursor location: target
      6. issue command
        • summary: type "two"
        • Using the command: "<enter text>" (enter text)
        • Observe: the input should be rejected and the screen reader should have conveyed that the input was rejected.
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • keyboard focus location: target
          • virtual cursor location: target
      7. is the expectation met?
    • Output: key press was echoed but input was rejected
    • Result Notes: pass because the behavior is implied by the "number role"
NVDAChromeyes
  • Result: (pass)
    • Test Case: Enter invalid text into the number input using enter text (<enter text>)
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
      4. set mode to auto (do not explicitly change the mode)
      5. issue command
        • summary: navigate forward to the number input
        • Using the command: "Tab" (Read next focusable item)
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • keyboard focus location: target
          • virtual cursor location: target
      6. issue command
        • summary: type "two"
        • Using the command: "<enter text>" (enter text)
        • Observe: the input should be rejected and the screen reader should have conveyed that the input was rejected.
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • keyboard focus location: target
          • virtual cursor location: target
      7. is the expectation met?
    • Output: key press was echoed
    • Result Notes: pass because the behavior is implied by the "spin button announcement"
NVDAFirefoxyes
  • Result: (pass)
    • Test Case: Enter invalid text into the number input using enter text (<enter text>)
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
      4. set mode to auto (do not explicitly change the mode)
      5. issue command
        • summary: navigate forward to the number input
        • Using the command: "Tab" (Read next focusable item)
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • keyboard focus location: target
          • virtual cursor location: target
      6. issue command
        • summary: type "two"
        • Using the command: "<enter text>" (enter text)
        • Observe: the input should be rejected and the screen reader should have conveyed that the input was rejected.
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • keyboard focus location: target
          • virtual cursor location: target
      7. is the expectation met?
    • Output: <key press> invalid entry
    • Result Notes: Firefox allows invalid input to be provided, but marks the field as invalid.
OrcaFirefoxyes
  • Result: (pass)
    • Test Case: Enter invalid text into the number input using enter text (<enter text>)
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
      4. set mode to auto (do not explicitly change the mode)
      5. issue command
        • summary: navigate forward to the number input
        • Using the command: "Tab" (Read next focusable item)
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • keyboard focus location: target
          • virtual cursor location: target
      6. issue command
        • summary: type "two"
        • Using the command: "<enter text>" (enter text)
        • Observe: the input should be rejected and the screen reader should have conveyed that the input was rejected.
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • keyboard focus location: target
          • virtual cursor location: target
      7. is the expectation met?
    • Output: Invalid data could be entered, but field was also conveyed as invalid
TalkBackChromeyes
  • Result: (pass)
    • Test Case: Enter invalid text into the number input using enter text (<enter text>)
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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 command
        • summary: navigate forward to the number input
        • Using the command: "Swipe right (or alt+right arrow)" (Read next item)
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • virtual cursor location: target
      5. issue command
        • summary: type "two"
        • Using the command: "<enter text>" (enter text)
        • Observe: the input should be rejected and the screen reader should have conveyed that the input was rejected.
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • virtual cursor location: target
      6. is the expectation met?
    • Output: Unable to enter non-numerical characters.
    • Result Notes: A number keyboard was opened and it was not possible to switch to the default keyboard. If you enter an invalid number (something like 11+) then it announces "invalid entry".
Voice Access (Android)Chromenot applicable-
Voice Control (iOS)Safarinot applicable-
Voice Control (MacOS)Safarinot applicable-
VoiceOver (iOS)Safariyes
  • Result: (pass)
    • Test Case: Enter invalid text into the number input using enter text (<enter text>)
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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 command
        • summary: navigate forward to the number input
        • Using the command: "Swipe Right" (Next item)
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • virtual cursor location: target
      5. issue command
        • summary: type "two"
        • Using the command: "<enter text>" (enter text)
        • Observe: the input should be rejected and the screen reader should have conveyed that the input was rejected.
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • virtual cursor location: target
      6. is the expectation met?
    • Output: Text can be entered, but VO announces the input as "invalid data" after navigating back to it
VoiceOver (macOS)Safariyes
  • Result: (pass)
    • Test Case: Enter invalid text into the number input using enter text (<enter text>)
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be more specific, please open a GitHub Issue.
      4. set mode to auto (do not explicitly change the mode)
      5. issue command
        • summary: navigate forward to the number input
        • Using the command: "Tab" (Read next focusable item)
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • keyboard focus location: target
          • virtual cursor location: target
      6. issue command
        • summary: type "two"
        • Using the command: "<enter text>" (enter text)
        • Observe: the input should be rejected and the screen reader should have conveyed that the input was rejected.
        • Ensure AT location after executing the command
          • Target: `input[type="number"]`
          • keyboard focus location: target
          • virtual cursor location: target
      7. is the expectation met?
    • Output: invalid data could be entered, and VO announces "invalid data" when navigating back to the control
Windows Speech RecognitionChromenot applicable-

Extended Support for: input[type="number"] element: convey when input is rejected

These are less common combinations

ATBrowserHas SupportOutput
Dragon Naturally SpeakingIEnot applicable-
Dragon Naturally SpeakingFirefoxnot applicable-
JAWSEdgeunknown-
NarratorFirefoxunknown-
NarratorChromeunknown-
NarratorIEunknown-
NVDAIEunknown-
NVDAEdgeunknown-
TalkBackFirefoxunknown-
Voice Access (Android)Firefoxnot applicable-
VoiceOver (iOS)Chromeunknown-
VoiceOver (macOS)Chromeunknown-
VoiceOver (macOS)Firefoxunknown-
OrcaChromeunknown-
Voice Control (MacOS)Chromenot applicable-
Voice Control (MacOS)Firefoxnot applicable-
Windows Speech Recognition 1903Edge 44not applicable-
Back to top

Expectation for the input[type="number"] element: allow incrementing and decrementing the value

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

Rationale:

users might want to increment and decrement the value

Strength of this expectation for different types of assistive technologies:

  • Screen Readers: MAY
  • Voice Control: MAY

Examples:

  • Desktop screen readers might allow users to adjust the value by pressing up and down arrows
  • Mobile screen readers might allow users to adjust the value by swiping up or down
  • Voice control software might allow someone to say something like "increment <name>"

Grading method:

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

ATBrowserHas SupportOutput
Dragon Naturally SpeakingChromeyes
  • Result: (pass)
    • Test Case: Use "press <key>" (press a keyboard command)
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. 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: "press <key>" (press a keyboard command)
      5. Record results for the relevant expectations
    • Output: value was incremented and decremented
    • Command Notes: said "press up arrow" and "press down arrow"
JAWSChromeyes
  • Result: (pass)
    • Test Case: Use <keyboard command> (Keyboard command while in forms or application mode) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <keyboard command> (Keyboard command while in forms or application mode)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: value was incremented and decremented
    • Result Notes: Used up and down arrows.
JAWSIEnot applicable
  • Result: (na)
    • Test Case: Use <keyboard command> (Keyboard command while in forms or application mode) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <keyboard command> (Keyboard command while in forms or application mode)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: value was not incremented or decremented
    • Result Notes: na because IE does not support this feature
JAWSFirefoxyes
  • Result: (pass)
    • Test Case: Use <keyboard command> (Keyboard command while in forms or application mode) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <keyboard command> (Keyboard command while in forms or application mode)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: value was incremented and decremented
    • Result Notes: Used up and down arrows.
NarratorEdgenone
  • Result: (fail)
    • Test Case: Use <keyboard command> (Keyboard command while in forms or application mode) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <keyboard command> (Keyboard command while in forms or application mode)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: value was not incremented and decremented
    • Result Notes: Used up and down arrows.
NVDAChromeyes
  • Result: (pass)
    • Test Case: Use <keyboard command> (Keyboard command while in forms or application mode) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <keyboard command> (Keyboard command while in forms or application mode)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: value was incremented and decremented
    • Result Notes: Used up and down arrows.
NVDAFirefoxyes
  • Result: (pass)
    • Test Case: Use <keyboard command> (Keyboard command while in forms or application mode) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <keyboard command> (Keyboard command while in forms or application mode)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: value was incremented and decremented
    • Result Notes: Used up and down arrows.
OrcaFirefoxyes
  • Result: (pass)
    • Test Case: Use <keyboard command> (Keyboard command while in forms or application mode) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <keyboard command> (Keyboard command while in forms or application mode)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: value was incremented and decremented
    • Result Notes: Used up and down arrows.
TalkBackChromenot applicable-
Voice Access (Android)Chromenot applicable-
Voice Control (iOS)Safarinot applicable-
Voice Control (MacOS)Safarinot applicable-
VoiceOver (iOS)Safarinot applicable-
VoiceOver (macOS)Safariyes
  • Result: (pass)
    • Test Case: Use <keyboard command> (Keyboard command while in forms or application mode) on the target of `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: <keyboard command> (Keyboard command while in forms or application mode)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: value was incremented and decremented
    • Result Notes: Used up and down arrows.
Windows Speech RecognitionChromenot applicable-

Extended Support for: input[type="number"] element: allow incrementing and decrementing the value

These are less common combinations

ATBrowserHas SupportOutput
Dragon Naturally SpeakingIEunknown-
Dragon Naturally SpeakingFirefoxunknown-
JAWSEdgeunknown-
NarratorFirefoxunknown-
NarratorChromeunknown-
NarratorIEunknown-
NVDAIEunknown-
NVDAEdgeunknown-
TalkBackFirefoxnot applicable-
Voice Access (Android)Firefoxnot applicable-
VoiceOver (iOS)Chromeunknown-
VoiceOver (macOS)Chromeunknown-
VoiceOver (macOS)Firefoxunknown-
OrcaChromeunknown-
Voice Control (MacOS)Chromenot applicable-
Voice Control (MacOS)Firefoxnot applicable-
Windows Speech Recognition 1903Edge 44not applicable-
Back to top

Expectation for the input[type="number"] element: provide shortcuts to jump to this role

This expectation is from the input[type="number"] 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.

ATBrowserHas SupportOutput
Dragon Naturally SpeakingChromenot applicable-
JAWSChromeyes
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox, 11"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 fields as "Your favorite number? edit, 11"
JAWSIEyes
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, 11"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 fields as "Your favorite number? edit, 11"
JAWSFirefoxyes
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, edit, spinbox, 11"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 fields as "Your favorite number? edit, 11"
NarratorEdgeyes
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, 11, minimum zero, and maximum zero, 11 selected"
NVDAChromeyes
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, editable, 11"
  • Result: (pass)
    • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 controls as "11; spin button; editable"
NVDAFirefoxyes
  • Result: (pass)
    • Test Case: Use f (Next form field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button, has auto complete, editable, 11"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 controls as "11; spin button; has auto complete; editable;"
OrcaFirefoxyes
  • Result: (pass)
    • Test Case: Use e (Next edit field) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: e (Next edit field)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: "your favorite number, 11, spin button"
  • Result: (pass)
    • Test Case: Use alt + shift + f (Open list of form fields) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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 + f (Open list of form fields)
        • After issuing the command, virtual focus should be: target
      6. Record results for the relevant expectations
    • Output: in list of form controls as "your favorite number?; spin button; 11"
TalkBackChromeyes
  • Result: (pass)
    • Test Case: Use Swipe down (alt+c) (next control (correct reading control must be selected)) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "your favorite number, spin button"
Voice Access (Android)Chromenot applicable-
Voice Control (iOS)Safarinot applicable-
Voice Control (MacOS)Safarinot applicable-
VoiceOver (iOS)Safariyes
  • Result: (pass)
    • Test Case: Use Swipe down (next form control (correct item type must be selected)) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "Your favorite number? 11, text field, double tab to edit"
VoiceOver (macOS)Safariyes
  • Result: (pass)
    • Test Case: Use VO + Command + J (Next Form Control) to navigate forward to `input[type="number"]`
      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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the selector should be 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: "11, contents selected, your favorite number? incrementable edit text"
  • 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="number"]
        • If multiple elements match the selector, repeat this test for all instances. However, choose a single instance to report against. If you feel that the 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 as "11 your favorite number? incrementable edit text"
Windows Speech RecognitionChromenot applicable-

Extended Support for: input[type="number"] element: provide shortcuts to jump to this role

These are less common combinations

ATBrowserHas SupportOutput
Dragon Naturally SpeakingIEnot applicable-
Dragon Naturally SpeakingFirefoxnot applicable-
JAWSEdgeunknown-
NarratorFirefoxunknown-
NarratorChromeunknown-
NarratorIEunknown-
NVDAIEunknown-
NVDAEdgeunknown-
TalkBackFirefoxunknown-
Voice Access (Android)Firefoxnot applicable-
VoiceOver (iOS)Chromeunknown-
VoiceOver (macOS)Chromeunknown-
VoiceOver (macOS)Firefoxunknown-
OrcaChromeunknown-
Voice Control (MacOS)Chromenot applicable-
Voice Control (MacOS)Firefoxnot applicable-
Windows Speech Recognition 1903Edge 44not applicable-
Back to top

Dates and Versions of tested combinations

ATAT VersionBrowserBrowser versionOS versionDate tested
Dragon Naturally Speaking15.30Chrome7719032019-10-14
JAWS2021.2102.34Chrome8920H22020-03-17
JAWS2021.2102.34IE1120H22020-03-17
JAWS2021.2102.34Firefox8620H22020-03-17
Narrator20H2Edge8920H22020-03-17
NVDA2020.4Chrome8920H22020-03-17
NVDA2020.4Firefox8620H22020-03-17
Orca3.38.0Firefox86Ubuntu 20.102020-03-17
TalkBack9.1Chrome897.02020-03-17
Voice Access (Android)3.1Chrome777.02019-10-14
Voice Control (iOS)13.1Safari13.113.12019-10-14
Voice Control (MacOS)10.15Safari13.0.210.152019-10-14
VoiceOver (iOS)14.4.1Safari4.4.114.4.12020-03-17
VoiceOver (macOS)11.2.3Safari14.0.311.2.32020-03-17
Windows Speech Recognition1903Chrome7719032019-10-18

History

  • 2019-10-14 Add test
  • 2019-10-18 Add wsr results
  • 2020-03-17 Add expectation for rejected input and re-test all screen readers.