From 8e893bd9a1244c9d0e61270af2e887c1af8529eb Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Wed, 18 Mar 2026 18:13:46 -0400
Subject: [PATCH 1/2] Extract rule: template-require-input-label

---
 README.md                                     |   1 +
 docs/rules/template-require-input-label.md    |  67 +++
 lib/rules/template-require-input-label.js     | 153 ++++++
 .../lib/rules/template-require-input-label.js | 469 ++++++++++++++++++
 4 files changed, 690 insertions(+)
 create mode 100644 docs/rules/template-require-input-label.md
 create mode 100644 lib/rules/template-require-input-label.js
 create mode 100644 tests/lib/rules/template-require-input-label.js

diff --git a/README.md b/README.md
index c17f530afa..2824b55a74 100644
--- a/README.md
+++ b/README.md
@@ -197,6 +197,7 @@ rules in templates can be disabled with eslint directives with mustache or html
 | [template-no-nested-interactive](docs/rules/template-no-nested-interactive.md)                         | disallow nested interactive elements                                             |    |    |    |
 | [template-no-nested-landmark](docs/rules/template-no-nested-landmark.md)                               | disallow nested landmark elements                                                |    |    |    |
 | [template-no-pointer-down-event-binding](docs/rules/template-no-pointer-down-event-binding.md)         | disallow pointer down event bindings                                             |    |    |    |
+| [template-require-input-label](docs/rules/template-require-input-label.md)                             | require label for form input elements                                            |    |    |    |
 | [template-require-lang-attribute](docs/rules/template-require-lang-attribute.md)                       | require lang attribute on html element                                           |    |    |    |
 | [template-require-mandatory-role-attributes](docs/rules/template-require-mandatory-role-attributes.md) | require mandatory ARIA attributes for ARIA roles                                 |    |    |    |
 | [template-require-media-caption](docs/rules/template-require-media-caption.md)                         | require captions for audio and video elements                                    |    |    |    |
diff --git a/docs/rules/template-require-input-label.md b/docs/rules/template-require-input-label.md
new file mode 100644
index 0000000000..4ebfc1d822
--- /dev/null
+++ b/docs/rules/template-require-input-label.md
@@ -0,0 +1,67 @@
+# ember/template-require-input-label
+
+<!-- end auto-generated rule header -->
+
+Require form input elements to have an associated label for accessibility.
+
+## Rule Details
+
+This rule enforces that input, textarea, and select elements have a way to be labeled, either through an `id` attribute (which can be referenced by a `<label for="...">`) or through `aria-label` or `aria-labelledby` attributes.
+
+## Examples
+
+Examples of **incorrect** code for this rule:
+
+```gjs
+<template>
+  <input type="text" />
+</template>
+
+<template>
+  <textarea></textarea>
+</template>
+
+<template>
+  <select>
+    <option>Option 1</option>
+  </select>
+</template>
+```
+
+Examples of **correct** code for this rule:
+
+```gjs
+<template>
+  <label for="name">Name:</label>
+  <input id="name" type="text" />
+</template>
+
+<template>
+  <input aria-label="Name" type="text" />
+</template>
+
+<template>
+  <input aria-labelledby="name-label" type="text" />
+</template>
+
+<template>
+  <input type="hidden" />
+</template>
+```
+
+## Migration
+
+- the recommended fix is to add an associated label element.
+- another option is to add an aria-label to the input element.
+- wrapping the input element in a label element is also allowed; however this is less flexible for styling purposes, so use with awareness.
+
+## Options
+
+| Name        | Type       | Default | Description                                                          |
+| ----------- | ---------- | ------- | -------------------------------------------------------------------- |
+| `labelTags` | `string[]` | `[]`    | Additional tag names to treat as label elements (besides `<label>`). |
+
+## References
+
+- [WCAG 2.1 - Labels or Instructions](https://www.w3.org/WAI/WCAG21/Understanding/labels-or-instructions.html)
+- [MDN - aria-label](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-label)
diff --git a/lib/rules/template-require-input-label.js b/lib/rules/template-require-input-label.js
new file mode 100644
index 0000000000..9623b61817
--- /dev/null
+++ b/lib/rules/template-require-input-label.js
@@ -0,0 +1,153 @@
+function hasAttr(node, name) {
+  return node.attributes?.some((a) => a.name === name);
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'require label for form input elements',
+      category: 'Accessibility',
+      url: 'https://github.com/ember-cli/eslint-plugin-ember/tree/master/docs/rules/template-require-input-label.md',
+      templateMode: 'both',
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          labelTags: {
+            type: 'array',
+            items: { type: 'string' },
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      requireLabel: 'Input elements should have an associated label.',
+      multipleLabels: 'Input element has multiple labelling mechanisms.',
+    },
+    originallyFrom: {
+      name: 'ember-template-lint',
+      rule: 'lib/rules/require-input-label.js',
+      docs: 'docs/rule/require-input-label.md',
+      tests: 'test/unit/rules/require-input-label-test.js',
+    },
+  },
+
+  create(context) {
+    const options = context.options[0] || {};
+    const customLabelTags = options.labelTags || [];
+    const labelTags = new Set(['label', ...customLabelTags]);
+    const elementStack = [];
+
+    function hasValidLabelParent() {
+      for (let i = elementStack.length - 1; i >= 0; i--) {
+        const entry = elementStack[i];
+        if (labelTags.has(entry.tag)) {
+          // Custom label tags (not 'label') are always considered valid
+          if (entry.tag !== 'label') {
+            return true;
+          }
+          // For 'label' tag, valid only if it has more than one child (text content + input)
+          const children = entry.node.children || [];
+          return children.length > 1;
+        }
+      }
+      return false;
+    }
+
+    return {
+      GlimmerElementNode(node) {
+        elementStack.push({ tag: node.tag, node });
+
+        const tagName = node.tag?.toLowerCase();
+        if (tagName !== 'input' && tagName !== 'textarea' && tagName !== 'select') {
+          return;
+        }
+
+        // Skip if input has type="hidden"
+        const typeAttr = node.attributes?.find((a) => a.name === 'type');
+        if (typeAttr?.value?.type === 'GlimmerTextNode' && typeAttr.value.chars === 'hidden') {
+          return;
+        }
+
+        // Skip if has ...attributes (can't determine labelling)
+        if (hasAttr(node, '...attributes')) {
+          return;
+        }
+
+        let labelCount = 0;
+        const validLabel = hasValidLabelParent();
+        if (validLabel) {
+          labelCount++;
+        }
+
+        const hasId = hasAttr(node, 'id');
+        const hasAriaLabel = hasAttr(node, 'aria-label');
+        const hasAriaLabelledBy = hasAttr(node, 'aria-labelledby');
+        if (hasId) {
+          labelCount++;
+        }
+        if (hasAriaLabel) {
+          labelCount++;
+        }
+        if (hasAriaLabelledBy) {
+          labelCount++;
+        }
+
+        if (labelCount === 1) {
+          return;
+        }
+
+        // Special case: label parent + id is OK (common pattern)
+        if (validLabel && hasId) {
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: labelCount === 0 ? 'requireLabel' : 'multipleLabels',
+        });
+      },
+      'GlimmerElementNode:exit'() {
+        elementStack.pop();
+      },
+
+      GlimmerMustacheStatement(node) {
+        const name = node.path?.original;
+        if (name !== 'input' && name !== 'textarea') {
+          return;
+        }
+
+        const pairs = node.hash?.pairs || [];
+
+        function hasPair(key) {
+          return pairs.some((p) => p.key === key);
+        }
+
+        // Skip if type="hidden" (literal string only)
+        const typePair = pairs.find((p) => p.key === 'type');
+        if (typePair?.value?.type === 'GlimmerStringLiteral' && typePair.value.value === 'hidden') {
+          return;
+        }
+
+        // If in a valid label, it's valid
+        if (hasValidLabelParent()) {
+          return;
+        }
+
+        // If has id, it's valid
+        if (hasPair('id')) {
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: 'requireLabel',
+        });
+      },
+    };
+  },
+};
diff --git a/tests/lib/rules/template-require-input-label.js b/tests/lib/rules/template-require-input-label.js
new file mode 100644
index 0000000000..65d305fe78
--- /dev/null
+++ b/tests/lib/rules/template-require-input-label.js
@@ -0,0 +1,469 @@
+const eslint = require('eslint');
+const rule = require('../../../lib/rules/template-require-input-label');
+
+const { RuleTester } = eslint;
+
+const ruleTester = new RuleTester({
+  parser: require.resolve('ember-eslint-parser'),
+  parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
+});
+
+ruleTester.run('template-require-input-label', rule, {
+  valid: [
+    // Input with id (can be associated with label)
+    '<template><input id="name" type="text" /></template>',
+
+    // Input with aria-label
+    '<template><input aria-label="Name" type="text" /></template>',
+
+    // Input with aria-labelledby
+    '<template><input aria-labelledby="label-id" type="text" /></template>',
+
+    // Hidden input doesn't need label
+    '<template><input type="hidden" /></template>',
+
+    // Textarea with id
+    '<template><textarea id="comment"></textarea></template>',
+
+    // Select with id
+    '<template><select id="country"><option>US</option></select></template>',
+
+    // Dynamic aria-label
+    '<template><input aria-label={{labelText}} /></template>',
+
+    // Component-form inputs (capital I/T)
+    '<template><Input id="foo" /></template>',
+    '<template><Textarea id="foo" /></template>',
+
+    // Curly component syntax
+    '<template>{{input id="foo"}}</template>',
+    '<template>{{textarea id="foo"}}</template>',
+
+    // Hidden skip in other forms
+    '<template><Input type="hidden" /></template>',
+    '<template>{{input type="hidden"}}</template>',
+
+    // Textarea with aria-labelledby and aria-label
+    '<template><textarea aria-labelledby="someIdValue"></textarea></template>',
+    '<template><textarea aria-label={{labelText}}></textarea></template>',
+
+    // Select with aria-labelledby and aria-label
+    '<template><select aria-labelledby="someIdValue"></select></template>',
+    '<template><select aria-label={{labelText}}></select></template>',
+  ],
+  invalid: [
+    {
+      code: '<template><input type="text" /></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><textarea></textarea></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><select><option>Value</option></select></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+
+    {
+      code: '<template><div><input /></div></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><input /></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><input title="some title value" /></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><label><input></label></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><div>{{input}}</div></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><Input/></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><input aria-label="first label" aria-labelledby="second label"></template>',
+      output: null,
+      errors: [{ messageId: 'multipleLabels' }],
+    },
+    {
+      code: '<template><input id="label-input" aria-label="second label"></template>',
+      output: null,
+      errors: [{ messageId: 'multipleLabels' }],
+    },
+    {
+      code: '<template><label>Input label<input aria-label="Custom label"></label></template>',
+      output: null,
+      errors: [{ messageId: 'multipleLabels' }],
+    },
+    {
+      code: '<template>{{input type="button"}}</template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template>{{input type=myType}}</template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><input type="button"/></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><input type={{myType}}/></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><Input type="button"/></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><Input type={{myType}}/></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><div><textarea /></div></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><textarea /></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><textarea title="some title value" /></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><label><textarea /></label></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><div>{{textarea}}</div></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><Textarea /></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><textarea aria-label="first label" aria-labelledby="second label" /></template>',
+      output: null,
+      errors: [{ messageId: 'multipleLabels' }],
+    },
+    {
+      code: '<template><textarea id="label-input" aria-label="second label" /></template>',
+      output: null,
+      errors: [{ messageId: 'multipleLabels' }],
+    },
+    {
+      code: '<template><label>Textarea label<textarea aria-label="Custom label" /></label></template>',
+      output: null,
+      errors: [{ messageId: 'multipleLabels' }],
+    },
+    {
+      code: '<template><div><select></select></div></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><select></select></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><select title="some title value" /></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><label><select></select></label></template>',
+      output: null,
+      errors: [{ messageId: 'requireLabel' }],
+    },
+    {
+      code: '<template><select aria-label="first label" aria-labelledby="second label" /></template>',
+      output: null,
+      errors: [{ messageId: 'multipleLabels' }],
+    },
+    {
+      code: '<template><select id="label-input" aria-label="second label" /></template>',
+      output: null,
+      errors: [{ messageId: 'multipleLabels' }],
+    },
+    {
+      code: '<template><label>Select label<select aria-label="Custom label" /></label></template>',
+      output: null,
+      errors: [{ messageId: 'multipleLabels' }],
+    },
+  ],
+});
+
+const hbsRuleTester = new RuleTester({
+  parser: require.resolve('ember-eslint-parser/hbs'),
+  parserOptions: {
+    ecmaVersion: 2022,
+    sourceType: 'module',
+  },
+});
+
+hbsRuleTester.run('template-require-input-label', rule, {
+  valid: [
+    // Label with text content wrapping input
+    '<label>LabelText<input /></label>',
+    '<label>LabelText<input id="foo" /></label>',
+    '<label><input />LabelText</label>',
+    '<label>LabelText<Input /></label>',
+    '<label><Input />LabelText</label>',
+    '<label>Label Text<div><input /></div></label>',
+    '<label>text<Input id="foo" /></label>',
+    '<label>text{{input id="foo"}}</label>',
+    '<label>Text here<Input /></label>',
+    '<label>Text here {{input}}</label>',
+
+    // Self-labelling attributes
+    '<input id="probablyHasLabel" />',
+    '<input aria-label={{labelText}} />',
+    '<input aria-labelledby="someIdValue" />',
+    '<div></div>',
+    '<Input id="foo" />',
+    '{{input id="foo"}}',
+
+    // ...attributes spread (can't determine labelling)
+    '<input ...attributes/>',
+    '<Input ...attributes />',
+    '<input id="label-input" ...attributes>',
+
+    // Same logic for textareas
+    '<label>LabelText<textarea /></label>',
+    '<label><textarea />LabelText</label>',
+    '<label>LabelText<Textarea /></label>',
+    '<label><Textarea />LabelText</label>',
+    '<label>Label Text<div><textarea /></div></label>',
+    '<label>Text here<Textarea /></label>',
+    '<label>Text here {{textarea}}</label>',
+    '<textarea id="probablyHasLabel" />',
+    '<textarea aria-label={{labelText}} />',
+    '<textarea aria-labelledby="someIdValue" />',
+    '<Textarea id="foo" />',
+    '{{textarea id="foo"}}',
+    '<textarea ...attributes/>',
+    '<Textarea ...attributes />',
+    '<textarea id="label-input" ...attributes />',
+
+    // Same logic for selects
+    '<label>LabelText<select></select></label>',
+    '<label><select></select>LabelText</label>',
+    '<label>Label Text<div><select></select></div></label>',
+    '<select id="probablyHasLabel" ></select>',
+    '<select aria-label={{labelText}} ></select>',
+    '<select aria-labelledby="someIdValue" ></select>',
+    '<select ...attributes></select>',
+    '<select id="label-input" ...attributes ></select>',
+
+    // Hidden inputs
+    '<input type="hidden"/>',
+    '<Input type="hidden" />',
+    '{{input type="hidden"}}',
+
+    // Custom label tags
+    {
+      code: '<CustomLabel><input /></CustomLabel>',
+      options: [{ labelTags: ['CustomLabel'] }],
+    },
+    {
+      code: '<web-label><input /></web-label>',
+      options: [{ labelTags: ['web-label'] }],
+    },
+  ],
+  invalid: [
+    {
+      code: '<my-label><input /></my-label>',
+      output: null,
+      options: [{ labelTags: ['web-label'] }],
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<div><input /></div>',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<input />',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<input title="some title value" />',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<label><input></label>',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<div>{{input}}</div>',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<Input/>',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<input aria-label="first label" aria-labelledby="second label">',
+      output: null,
+      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
+    },
+    {
+      code: '<input id="label-input" aria-label="second label">',
+      output: null,
+      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
+    },
+    {
+      code: '<label>Input label<input aria-label="Custom label"></label>',
+      output: null,
+      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
+    },
+    {
+      code: '{{input type="button"}}',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '{{input type=myType}}',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<input type="button"/>',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<input type={{myType}}/>',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<Input type="button"/>',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<Input type={{myType}}/>',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<div><textarea /></div>',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<textarea />',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<textarea title="some title value" />',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<label><textarea /></label>',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<div>{{textarea}}</div>',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<Textarea />',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<textarea aria-label="first label" aria-labelledby="second label" />',
+      output: null,
+      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
+    },
+    {
+      code: '<textarea id="label-input" aria-label="second label" />',
+      output: null,
+      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
+    },
+    {
+      code: '<label>Textarea label<textarea aria-label="Custom label" /></label>',
+      output: null,
+      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
+    },
+    {
+      code: '<div><select></select></div>',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<select></select>',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<select title="some title value" />',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<label><select></select></label>',
+      output: null,
+      errors: [{ message: 'Input elements should have an associated label.' }],
+    },
+    {
+      code: '<select aria-label="first label" aria-labelledby="second label" />',
+      output: null,
+      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
+    },
+    {
+      code: '<select id="label-input" aria-label="second label" />',
+      output: null,
+      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
+    },
+    {
+      code: '<label>Select label<select aria-label="Custom label" /></label>',
+      output: null,
+      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
+    },
+  ],
+});

From 29f41dff062f6edb4246c8f7eec6146ebf02d85c Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Fri, 20 Mar 2026 10:11:15 -0400
Subject: [PATCH 2/2] Sync with template-lint

---
 docs/rules/template-require-input-label.md    |  99 ++++--
 lib/rules/template-require-input-label.js     |  80 ++++-
 .../lib/rules/template-require-input-label.js | 329 ++++--------------
 3 files changed, 220 insertions(+), 288 deletions(-)

diff --git a/docs/rules/template-require-input-label.md b/docs/rules/template-require-input-label.md
index 4ebfc1d822..0907383514 100644
--- a/docs/rules/template-require-input-label.md
+++ b/docs/rules/template-require-input-label.md
@@ -2,48 +2,101 @@
 
 <!-- end auto-generated rule header -->
 
-Require form input elements to have an associated label for accessibility.
+Users with assistive technology need user-input form elements to have
+associated labels.
 
-## Rule Details
+The rule applies to the following HTML tags:
 
-This rule enforces that input, textarea, and select elements have a way to be labeled, either through an `id` attribute (which can be referenced by a `<label for="...">`) or through `aria-label` or `aria-labelledby` attributes.
+- `<input>`
+- `<textarea>`
+- `<select>`
+
+The rule also applies to the following ember components:
+
+- `<Textarea />`
+- `<Input />`
+- `{{textarea}}`
+- `{{input}}`
+
+The label is **essential** for users. Leaving it out will cause **three**
+different WCAG criteria to fail:
+
+- [1.3.1, Info and Relationships](https://www.w3.org/WAI/WCAG21/Understanding/info-and-relationships.html)
+- [3.3.2, Labels or Instructions](https://www.w3.org/WAI/WCAG21/Understanding/labels-or-instructions.html)
+- [4.1.2, Name, Role, Value](https://www.w3.org/WAI/WCAG21/Understanding/name-role-value.html)
+
+It is also associated with this common failure:
+
+- [#68: Failure of Success Criterion 4.1.2 due to a user interface control not having a programmatically determined name](https://www.w3.org/WAI/WCAG21/Techniques/failures/F68)
+
+This rule checks to see if the input is contained by a label element. If it is
+not, it checks to see if the input has any of these three attributes: `id`,
+`aria-label`, or `aria-labelledby`. While the `id` element on the input is not
+a concrete indicator of the presence of an associated `<label>` element with a
+`for` attribute, it is a good indicator that one likely exists.
+
+This rule does not allow an input to use a `title` attribute for a valid label.
+This is because implementation by browsers is unreliable and incomplete.
+
+This rule is unable to determine if a valid label is present if `...attributes`
+is used, and must allow it to pass. However, developers are encouraged to write
+tests to ensure that a valid label is present for each input element present.
 
 ## Examples
 
-Examples of **incorrect** code for this rule:
+This rule **forbids** the following:
 
 ```gjs
 <template>
-  <input type="text" />
+  <div><input /></div>
 </template>
+```
 
+```gjs
 <template>
-  <textarea></textarea>
+  <input title="some label text" />
 </template>
+```
 
+```gjs
 <template>
-  <select>
-    <option>Option 1</option>
-  </select>
+  <textarea />
 </template>
 ```
 
-Examples of **correct** code for this rule:
+This rule **allows** the following:
 
 ```gjs
 <template>
-  <label for="name">Name:</label>
-  <input id="name" type="text" />
+  <label>Some Label Text<input /></label>
 </template>
+```
 
+```gjs
 <template>
-  <input aria-label="Name" type="text" />
+  <input id="someId" />
 </template>
+```
+
+```gjs
+<template>
+  <input aria-label="Label Text Here" />
+</template>
+```
+
+```gjs
+<template>
+  <input aria-labelledby="someButtonId" />
+</template>
+```
 
+```gjs
 <template>
-  <input aria-labelledby="name-label" type="text" />
+  <input ...attributes />
 </template>
+```
 
+```gjs
 <template>
   <input type="hidden" />
 </template>
@@ -55,13 +108,19 @@ Examples of **correct** code for this rule:
 - another option is to add an aria-label to the input element.
 - wrapping the input element in a label element is also allowed; however this is less flexible for styling purposes, so use with awareness.
 
-## Options
+## Configuration
 
-| Name        | Type       | Default | Description                                                          |
-| ----------- | ---------- | ------- | -------------------------------------------------------------------- |
-| `labelTags` | `string[]` | `[]`    | Additional tag names to treat as label elements (besides `<label>`). |
+- boolean - `true` to enable / `false` to disable
+- object -- An object with the following keys:
+  - `labelTags` -- An array of component names for that may be used as label replacements (in addition to the HTML `label` tag)
 
 ## References
 
-- [WCAG 2.1 - Labels or Instructions](https://www.w3.org/WAI/WCAG21/Understanding/labels-or-instructions.html)
-- [MDN - aria-label](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Attributes/aria-label)
+- [Understanding Success Criterion 1.3.1: Info and Relationships](https://www.w3.org/WAI/WCAG21/Understanding/info-and-relationships)
+- [Understanding Success Criterion 3.3.2: Labels or Instructions](https://www.w3.org/WAI/WCAG21/Understanding/labels-or-instructions.html)
+- [Understanding Success Criterion 4.1.2: Name, Role, Value](https://www.w3.org/WAI/WCAG21/Understanding/name-role-value.html)
+- [Using label elements to associate text labels and form controls](https://www.w3.org/WAI/WCAG21/Techniques/html/H44.html)
+- [Using aria-labelledby to provide a name for user interface controls](https://www.w3.org/WAI/WCAG21/Techniques/aria/ARIA16)
+- [Using aria-label to provide an invisible label where a visible label cannot be used](https://www.w3.org/WAI/WCAG21/Techniques/aria/ARIA14.html)
+- [Failure due to a user interface control not having a programmatically determined name](https://www.w3.org/WAI/WCAG21/Techniques/failures/F68)
+- [Failure due to visually formatting a set of phone number fields but not including a text label](https://www.w3.org/WAI/WCAG21/Techniques/failures/F82)
diff --git a/lib/rules/template-require-input-label.js b/lib/rules/template-require-input-label.js
index 9623b61817..3ed99cfe8e 100644
--- a/lib/rules/template-require-input-label.js
+++ b/lib/rules/template-require-input-label.js
@@ -2,6 +2,40 @@ function hasAttr(node, name) {
   return node.attributes?.some((a) => a.name === name);
 }
 
+function isString(value) {
+  return typeof value === 'string';
+}
+
+function isRegExp(value) {
+  return value instanceof RegExp;
+}
+
+function allowedFormat(value) {
+  return isString(value) || isRegExp(value);
+}
+
+function parseConfig(config) {
+  if (config === false) {
+    return false;
+  }
+
+  if (config === true || config === undefined) {
+    return { labelTags: ['label'] };
+  }
+
+  if (config && typeof config === 'object' && Array.isArray(config.labelTags)) {
+    return {
+      labelTags: ['label', ...config.labelTags.filter(allowedFormat)],
+    };
+  }
+
+  return { labelTags: ['label'] };
+}
+
+function matchesLabelTag(tag, configuredTag) {
+  return isRegExp(configuredTag) ? configuredTag.test(tag) : configuredTag === tag;
+}
+
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {
   meta: {
@@ -14,19 +48,23 @@ module.exports = {
     },
     schema: [
       {
-        type: 'object',
-        properties: {
-          labelTags: {
-            type: 'array',
-            items: { type: 'string' },
+        anyOf: [
+          { type: 'boolean' },
+          {
+            type: 'object',
+            properties: {
+              labelTags: {
+                type: 'array',
+              },
+            },
+            additionalProperties: false,
           },
-        },
-        additionalProperties: false,
+        ],
       },
     ],
     messages: {
-      requireLabel: 'Input elements should have an associated label.',
-      multipleLabels: 'Input element has multiple labelling mechanisms.',
+      requireLabel: 'form elements require a valid associated label.',
+      multipleLabels: 'form elements should not have multiple labels.',
     },
     originallyFrom: {
       name: 'ember-template-lint',
@@ -37,20 +75,27 @@ module.exports = {
   },
 
   create(context) {
-    const options = context.options[0] || {};
-    const customLabelTags = options.labelTags || [];
-    const labelTags = new Set(['label', ...customLabelTags]);
+    const config = parseConfig(context.options[0]);
+    if (config === false) {
+      return {};
+    }
+
+    const filename = context.getFilename();
+    const isStrictMode = filename.endsWith('.gjs') || filename.endsWith('.gts');
     const elementStack = [];
 
     function hasValidLabelParent() {
       for (let i = elementStack.length - 1; i >= 0; i--) {
         const entry = elementStack[i];
-        if (labelTags.has(entry.tag)) {
-          // Custom label tags (not 'label') are always considered valid
+        const hasMatchingLabelTag = config.labelTags.some((configuredTag) =>
+          matchesLabelTag(entry.tag, configuredTag)
+        );
+
+        if (hasMatchingLabelTag) {
           if (entry.tag !== 'label') {
             return true;
           }
-          // For 'label' tag, valid only if it has more than one child (text content + input)
+
           const children = entry.node.children || [];
           return children.length > 1;
         }
@@ -62,6 +107,10 @@ module.exports = {
       GlimmerElementNode(node) {
         elementStack.push({ tag: node.tag, node });
 
+        if (isStrictMode && (node.tag === 'Input' || node.tag === 'Textarea')) {
+          return;
+        }
+
         const tagName = node.tag?.toLowerCase();
         if (tagName !== 'input' && tagName !== 'textarea' && tagName !== 'select') {
           return;
@@ -101,7 +150,6 @@ module.exports = {
           return;
         }
 
-        // Special case: label parent + id is OK (common pattern)
         if (validLabel && hasId) {
           return;
         }
diff --git a/tests/lib/rules/template-require-input-label.js b/tests/lib/rules/template-require-input-label.js
index 65d305fe78..527382ee31 100644
--- a/tests/lib/rules/template-require-input-label.js
+++ b/tests/lib/rules/template-require-input-label.js
@@ -3,6 +3,9 @@ const rule = require('../../../lib/rules/template-require-input-label');
 
 const { RuleTester } = eslint;
 
+const NO_LABEL = 'form elements require a valid associated label.';
+const MULTIPLE_LABELS = 'form elements should not have multiple labels.';
+
 const ruleTester = new RuleTester({
   parser: require.resolve('ember-eslint-parser'),
   parserOptions: { ecmaVersion: 2022, sourceType: 'module' },
@@ -10,218 +13,117 @@ const ruleTester = new RuleTester({
 
 ruleTester.run('template-require-input-label', rule, {
   valid: [
-    // Input with id (can be associated with label)
-    '<template><input id="name" type="text" /></template>',
-
-    // Input with aria-label
-    '<template><input aria-label="Name" type="text" /></template>',
-
-    // Input with aria-labelledby
-    '<template><input aria-labelledby="label-id" type="text" /></template>',
-
-    // Hidden input doesn't need label
-    '<template><input type="hidden" /></template>',
-
-    // Textarea with id
-    '<template><textarea id="comment"></textarea></template>',
-
-    // Select with id
-    '<template><select id="country"><option>US</option></select></template>',
-
-    // Dynamic aria-label
+    '<template><label>LabelText<input /></label></template>',
+    '<template><label><input />LabelText</label></template>',
+    '<template><label>Label Text<div><input /></div></label></template>',
+    '<template><input id="probablyHasLabel" /></template>',
     '<template><input aria-label={{labelText}} /></template>',
-
-    // Component-form inputs (capital I/T)
+    '<template><input aria-labelledby="someIdValue" /></template>',
+    '<template><div></div></template>',
     '<template><Input id="foo" /></template>',
-    '<template><Textarea id="foo" /></template>',
-
-    // Curly component syntax
     '<template>{{input id="foo"}}</template>',
+    '<template><input ...attributes /></template>',
+    '<template><label>LabelText<textarea /></label></template>',
+    '<template><textarea id="probablyHasLabel" /></template>',
+    '<template><textarea aria-label={{labelText}} /></template>',
+    '<template><textarea aria-labelledby="someIdValue" /></template>',
+    '<template><Textarea id="foo" /></template>',
     '<template>{{textarea id="foo"}}</template>',
-
-    // Hidden skip in other forms
+    '<template><textarea ...attributes /></template>',
+    '<template><label>LabelText<select></select></label></template>',
+    '<template><select id="probablyHasLabel"></select></template>',
+    '<template><select aria-label={{labelText}}></select></template>',
+    '<template><select aria-labelledby="someIdValue"></select></template>',
+    '<template><select ...attributes></select></template>',
+    '<template><input type="hidden" /></template>',
     '<template><Input type="hidden" /></template>',
     '<template>{{input type="hidden"}}</template>',
-
-    // Textarea with aria-labelledby and aria-label
-    '<template><textarea aria-labelledby="someIdValue"></textarea></template>',
-    '<template><textarea aria-label={{labelText}}></textarea></template>',
-
-    // Select with aria-labelledby and aria-label
-    '<template><select aria-labelledby="someIdValue"></select></template>',
-    '<template><select aria-label={{labelText}}></select></template>',
-  ],
-  invalid: [
+    { filename: 'layout.gjs', code: '<template><Input /></template>' },
+    { filename: 'layout.gts', code: '<template><Textarea /></template>' },
     {
-      code: '<template><input type="text" /></template>',
-      output: null,
-      errors: [{ messageId: 'requireLabel' }],
+      code: '<template><CustomLabel><input /></CustomLabel></template>',
+      options: [{ labelTags: ['CustomLabel'] }],
     },
     {
-      code: '<template><textarea></textarea></template>',
-      output: null,
-      errors: [{ messageId: 'requireLabel' }],
+      code: '<template><web-label><input /></web-label></template>',
+      options: [{ labelTags: [/web-label/] }],
     },
     {
-      code: '<template><select><option>Value</option></select></template>',
-      output: null,
-      errors: [{ messageId: 'requireLabel' }],
+      code: '<template><input /></template>',
+      options: [false],
     },
-
+  ],
+  invalid: [
     {
-      code: '<template><div><input /></div></template>',
+      code: '<template><my-label><input /></my-label></template>',
       output: null,
-      errors: [{ messageId: 'requireLabel' }],
+      options: [{ labelTags: [/web-label/] }],
+      errors: [{ message: NO_LABEL }],
     },
     {
-      code: '<template><input /></template>',
+      code: '<template><div><input /></div></template>',
       output: null,
-      errors: [{ messageId: 'requireLabel' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<template><input title="some title value" /></template>',
       output: null,
-      errors: [{ messageId: 'requireLabel' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<template><label><input></label></template>',
       output: null,
-      errors: [{ messageId: 'requireLabel' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<template><div>{{input}}</div></template>',
       output: null,
-      errors: [{ messageId: 'requireLabel' }],
-    },
-    {
-      code: '<template><Input/></template>',
-      output: null,
-      errors: [{ messageId: 'requireLabel' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<template><input aria-label="first label" aria-labelledby="second label"></template>',
       output: null,
-      errors: [{ messageId: 'multipleLabels' }],
+      errors: [{ message: MULTIPLE_LABELS }],
     },
     {
       code: '<template><input id="label-input" aria-label="second label"></template>',
       output: null,
-      errors: [{ messageId: 'multipleLabels' }],
+      errors: [{ message: MULTIPLE_LABELS }],
     },
     {
       code: '<template><label>Input label<input aria-label="Custom label"></label></template>',
       output: null,
-      errors: [{ messageId: 'multipleLabels' }],
+      errors: [{ message: MULTIPLE_LABELS }],
     },
     {
       code: '<template>{{input type="button"}}</template>',
       output: null,
-      errors: [{ messageId: 'requireLabel' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<template>{{input type=myType}}</template>',
       output: null,
-      errors: [{ messageId: 'requireLabel' }],
-    },
-    {
-      code: '<template><input type="button"/></template>',
-      output: null,
-      errors: [{ messageId: 'requireLabel' }],
-    },
-    {
-      code: '<template><input type={{myType}}/></template>',
-      output: null,
-      errors: [{ messageId: 'requireLabel' }],
-    },
-    {
-      code: '<template><Input type="button"/></template>',
-      output: null,
-      errors: [{ messageId: 'requireLabel' }],
-    },
-    {
-      code: '<template><Input type={{myType}}/></template>',
-      output: null,
-      errors: [{ messageId: 'requireLabel' }],
-    },
-    {
-      code: '<template><div><textarea /></div></template>',
-      output: null,
-      errors: [{ messageId: 'requireLabel' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<template><textarea /></template>',
       output: null,
-      errors: [{ messageId: 'requireLabel' }],
-    },
-    {
-      code: '<template><textarea title="some title value" /></template>',
-      output: null,
-      errors: [{ messageId: 'requireLabel' }],
-    },
-    {
-      code: '<template><label><textarea /></label></template>',
-      output: null,
-      errors: [{ messageId: 'requireLabel' }],
-    },
-    {
-      code: '<template><div>{{textarea}}</div></template>',
-      output: null,
-      errors: [{ messageId: 'requireLabel' }],
-    },
-    {
-      code: '<template><Textarea /></template>',
-      output: null,
-      errors: [{ messageId: 'requireLabel' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<template><textarea aria-label="first label" aria-labelledby="second label" /></template>',
       output: null,
-      errors: [{ messageId: 'multipleLabels' }],
-    },
-    {
-      code: '<template><textarea id="label-input" aria-label="second label" /></template>',
-      output: null,
-      errors: [{ messageId: 'multipleLabels' }],
-    },
-    {
-      code: '<template><label>Textarea label<textarea aria-label="Custom label" /></label></template>',
-      output: null,
-      errors: [{ messageId: 'multipleLabels' }],
-    },
-    {
-      code: '<template><div><select></select></div></template>',
-      output: null,
-      errors: [{ messageId: 'requireLabel' }],
+      errors: [{ message: MULTIPLE_LABELS }],
     },
     {
       code: '<template><select></select></template>',
       output: null,
-      errors: [{ messageId: 'requireLabel' }],
-    },
-    {
-      code: '<template><select title="some title value" /></template>',
-      output: null,
-      errors: [{ messageId: 'requireLabel' }],
-    },
-    {
-      code: '<template><label><select></select></label></template>',
-      output: null,
-      errors: [{ messageId: 'requireLabel' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<template><select aria-label="first label" aria-labelledby="second label" /></template>',
       output: null,
-      errors: [{ messageId: 'multipleLabels' }],
-    },
-    {
-      code: '<template><select id="label-input" aria-label="second label" /></template>',
-      output: null,
-      errors: [{ messageId: 'multipleLabels' }],
-    },
-    {
-      code: '<template><label>Select label<select aria-label="Custom label" /></label></template>',
-      output: null,
-      errors: [{ messageId: 'multipleLabels' }],
+      errors: [{ message: MULTIPLE_LABELS }],
     },
   ],
 });
@@ -236,32 +138,22 @@ const hbsRuleTester = new RuleTester({
 
 hbsRuleTester.run('template-require-input-label', rule, {
   valid: [
-    // Label with text content wrapping input
     '<label>LabelText<input /></label>',
-    '<label>LabelText<input id="foo" /></label>',
     '<label><input />LabelText</label>',
     '<label>LabelText<Input /></label>',
     '<label><Input />LabelText</label>',
     '<label>Label Text<div><input /></div></label>',
     '<label>text<Input id="foo" /></label>',
-    '<label>text{{input id="foo"}}</label>',
     '<label>Text here<Input /></label>',
-    '<label>Text here {{input}}</label>',
-
-    // Self-labelling attributes
     '<input id="probablyHasLabel" />',
     '<input aria-label={{labelText}} />',
     '<input aria-labelledby="someIdValue" />',
     '<div></div>',
     '<Input id="foo" />',
     '{{input id="foo"}}',
-
-    // ...attributes spread (can't determine labelling)
     '<input ...attributes/>',
     '<Input ...attributes />',
     '<input id="label-input" ...attributes>',
-
-    // Same logic for textareas
     '<label>LabelText<textarea /></label>',
     '<label><textarea />LabelText</label>',
     '<label>LabelText<Textarea /></label>',
@@ -277,193 +169,126 @@ hbsRuleTester.run('template-require-input-label', rule, {
     '<textarea ...attributes/>',
     '<Textarea ...attributes />',
     '<textarea id="label-input" ...attributes />',
-
-    // Same logic for selects
     '<label>LabelText<select></select></label>',
     '<label><select></select>LabelText</label>',
     '<label>Label Text<div><select></select></div></label>',
-    '<select id="probablyHasLabel" ></select>',
-    '<select aria-label={{labelText}} ></select>',
-    '<select aria-labelledby="someIdValue" ></select>',
+    '<select id="probablyHasLabel"></select>',
+    '<select aria-label={{labelText}}></select>',
+    '<select aria-labelledby="someIdValue"></select>',
     '<select ...attributes></select>',
     '<select id="label-input" ...attributes ></select>',
-
-    // Hidden inputs
     '<input type="hidden"/>',
     '<Input type="hidden" />',
     '{{input type="hidden"}}',
-
-    // Custom label tags
     {
       code: '<CustomLabel><input /></CustomLabel>',
       options: [{ labelTags: ['CustomLabel'] }],
     },
     {
       code: '<web-label><input /></web-label>',
-      options: [{ labelTags: ['web-label'] }],
+      options: [{ labelTags: [/web-label/] }],
+    },
+    {
+      code: '<input />',
+      options: [false],
     },
   ],
   invalid: [
     {
       code: '<my-label><input /></my-label>',
       output: null,
-      options: [{ labelTags: ['web-label'] }],
-      errors: [{ message: 'Input elements should have an associated label.' }],
+      options: [{ labelTags: [/web-label/] }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<div><input /></div>',
       output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<input />',
       output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<input title="some title value" />',
       output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<label><input></label>',
       output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<div>{{input}}</div>',
       output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<Input/>',
       output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<input aria-label="first label" aria-labelledby="second label">',
       output: null,
-      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
+      errors: [{ message: MULTIPLE_LABELS }],
     },
     {
       code: '<input id="label-input" aria-label="second label">',
       output: null,
-      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
+      errors: [{ message: MULTIPLE_LABELS }],
     },
     {
       code: '<label>Input label<input aria-label="Custom label"></label>',
       output: null,
-      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
+      errors: [{ message: MULTIPLE_LABELS }],
     },
     {
       code: '{{input type="button"}}',
       output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '{{input type=myType}}',
       output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
-    },
-    {
-      code: '<input type="button"/>',
-      output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
-    },
-    {
-      code: '<input type={{myType}}/>',
-      output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<Input type="button"/>',
       output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<Input type={{myType}}/>',
       output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
-    },
-    {
-      code: '<div><textarea /></div>',
-      output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<textarea />',
       output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
-    },
-    {
-      code: '<textarea title="some title value" />',
-      output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
-    },
-    {
-      code: '<label><textarea /></label>',
-      output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
-    },
-    {
-      code: '<div>{{textarea}}</div>',
-      output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<Textarea />',
       output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<textarea aria-label="first label" aria-labelledby="second label" />',
       output: null,
-      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
-    },
-    {
-      code: '<textarea id="label-input" aria-label="second label" />',
-      output: null,
-      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
-    },
-    {
-      code: '<label>Textarea label<textarea aria-label="Custom label" /></label>',
-      output: null,
-      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
-    },
-    {
-      code: '<div><select></select></div>',
-      output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
+      errors: [{ message: MULTIPLE_LABELS }],
     },
     {
       code: '<select></select>',
       output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
-    },
-    {
-      code: '<select title="some title value" />',
-      output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
-    },
-    {
-      code: '<label><select></select></label>',
-      output: null,
-      errors: [{ message: 'Input elements should have an associated label.' }],
+      errors: [{ message: NO_LABEL }],
     },
     {
       code: '<select aria-label="first label" aria-labelledby="second label" />',
       output: null,
-      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
-    },
-    {
-      code: '<select id="label-input" aria-label="second label" />',
-      output: null,
-      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
-    },
-    {
-      code: '<label>Select label<select aria-label="Custom label" /></label>',
-      output: null,
-      errors: [{ message: 'Input element has multiple labelling mechanisms.' }],
+      errors: [{ message: MULTIPLE_LABELS }],
     },
   ],
 });