diff --git a/__tests__/__util__/helpers/getESLintCoreRule.js b/__tests__/__util__/helpers/getESLintCoreRule.js
new file mode 100644
index 000000000..ee04494f0
--- /dev/null
+++ b/__tests__/__util__/helpers/getESLintCoreRule.js
@@ -0,0 +1,9 @@
+import { version } from 'eslint/package.json';
+import semver from 'semver';
+
+const isESLintV8 = semver.major(version) >= 8;
+
+// eslint-disable-next-line global-require, import/no-dynamic-require, import/no-unresolved
+const getESLintCoreRule = (ruleId) => (isESLintV8 ? require('eslint/use-at-your-own-risk').builtinRules.get(ruleId) : require(`eslint/lib/rules/${ruleId}`));
+
+export default getESLintCoreRule;
diff --git a/__tests__/__util__/helpers/parsers.js b/__tests__/__util__/helpers/parsers.js
new file mode 100644
index 000000000..fc75cf337
--- /dev/null
+++ b/__tests__/__util__/helpers/parsers.js
@@ -0,0 +1,186 @@
+import path from 'path';
+import semver from 'semver';
+import entries from 'object.entries';
+import { version } from 'eslint/package.json';
+import flatMap from 'array.prototype.flatmap';
+
+let tsParserVersion;
+try {
+  // eslint-disable-next-line import/no-unresolved, global-require
+  tsParserVersion = require('@typescript-eslint/parser/package.json').version;
+} catch (e) { /**/ }
+
+const disableNewTS = semver.satisfies(tsParserVersion, '>= 4.1') // this rule is not useful on v4.1+ of the TS parser
+  ? (x) => ({ ...x, features: [].concat(x.features, 'no-ts-new') })
+  : (x) => x;
+
+function minEcmaVersion(features, parserOptions) {
+  const minEcmaVersionForFeatures = {
+    'class fields': 2022,
+    'optional chaining': 2020,
+    'nullish coalescing': 2020,
+  };
+  const result = Math.max(
+    ...[].concat(
+      (parserOptions && parserOptions.ecmaVersion) || [],
+      flatMap(entries(minEcmaVersionForFeatures), (entry) => {
+        const f = entry[0];
+        const y = entry[1];
+        return features.has(f) ? y : [];
+      }),
+    ).map((y) => (y > 5 && y < 2015 ? y + 2009 : y)), // normalize editions to years
+  );
+  return Number.isFinite(result) ? result : undefined;
+}
+
+const NODE_MODULES = '../../node_modules';
+
+const parsers = {
+  BABEL_ESLINT: path.join(__dirname, NODE_MODULES, 'babel-eslint'),
+  '@BABEL_ESLINT': path.join(__dirname, NODE_MODULES, '@babel/eslint-parser'),
+  TYPESCRIPT_ESLINT: path.join(__dirname, NODE_MODULES, 'typescript-eslint-parser'),
+  '@TYPESCRIPT_ESLINT': path.join(__dirname, NODE_MODULES, '@typescript-eslint/parser'),
+  disableNewTS,
+  babelParserOptions: function parserOptions(test, features) {
+    return {
+      ...test.parserOptions,
+      requireConfigFile: false,
+      babelOptions: {
+        presets: [
+          '@babel/preset-react',
+        ],
+        plugins: [
+          '@babel/plugin-syntax-do-expressions',
+          '@babel/plugin-syntax-function-bind',
+          ['@babel/plugin-syntax-decorators', { legacy: true }],
+        ],
+        parserOpts: {
+          allowSuperOutsideMethod: false,
+          allowReturnOutsideFunction: false,
+        },
+      },
+      ecmaFeatures: {
+
+        ...test.parserOptions && test.parserOptions.ecmaFeatures,
+        jsx: true,
+        modules: true,
+        legacyDecorators: features.has('decorators'),
+      },
+    };
+  },
+  all: function all(tests) {
+    const t = flatMap(tests, (test) => {
+      /* eslint no-param-reassign: 0 */
+      if (typeof test === 'string') {
+        test = { code: test };
+      }
+      if ('parser' in test) {
+        delete test.features;
+        return test;
+      }
+      const features = new Set([].concat(test.features || []));
+      delete test.features;
+
+      const es = minEcmaVersion(features, test.parserOptions);
+
+      function addComment(testObject, parser) {
+        const extras = [].concat(
+          `features: [${Array.from(features).join(',')}]`,
+          `parser: ${parser}`,
+          testObject.parserOptions ? `parserOptions: ${JSON.stringify(testObject.parserOptions)}` : [],
+          testObject.options ? `options: ${JSON.stringify(testObject.options)}` : [],
+          testObject.settings ? `settings: ${JSON.stringify(testObject.settings)}` : [],
+        );
+
+        const extraComment = `\n// ${extras.join(', ')}`;
+
+        // Augment expected fix code output with extraComment
+        const nextCode = { code: testObject.code + extraComment };
+        const nextOutput = testObject.output && { output: testObject.output + extraComment };
+
+        // Augment expected suggestion outputs with extraComment
+        // `errors` may be a number (expected number of errors) or an array of
+        // error objects.
+        const nextErrors = testObject.errors
+          && typeof testObject.errors !== 'number'
+          && {
+            errors: testObject.errors.map(
+              (errorObject) => {
+                const nextSuggestions = errorObject.suggestions && {
+                  suggestions: errorObject.suggestions.map((suggestion) => ({ ...suggestion, output: suggestion.output + extraComment })),
+                };
+
+                return { ...errorObject, ...nextSuggestions };
+              },
+            ),
+          };
+
+        return {
+
+          ...testObject,
+          ...nextCode,
+          ...nextOutput,
+          ...nextErrors,
+        };
+      }
+
+      const skipBase = (features.has('class fields') && semver.satisfies(version, '< 8'))
+        || (es >= 2020 && semver.satisfies(version, '< 6'))
+        || features.has('no-default')
+        || features.has('bind operator')
+        || features.has('do expressions')
+        || features.has('decorators')
+        || features.has('flow')
+        || features.has('ts')
+        || features.has('types')
+        || (features.has('fragment') && semver.satisfies(version, '< 5'));
+
+      const skipBabel = features.has('no-babel');
+      const skipOldBabel = skipBabel
+        || features.has('no-babel-old')
+        || features.has('optional chaining')
+        || semver.satisfies(version, '>= 8');
+      const skipNewBabel = skipBabel
+        || features.has('no-babel-new')
+        || !semver.satisfies(version, '^7.5.0') // require('@babel/eslint-parser/package.json').peerDependencies.eslint
+        || features.has('flow')
+        || features.has('types')
+        || features.has('ts');
+      const skipTS = semver.satisfies(version, '<= 5') // TODO: make these pass on eslint 5
+        || features.has('no-ts')
+        || features.has('flow')
+        || features.has('jsx namespace')
+        || features.has('bind operator')
+        || features.has('do expressions');
+      const tsOld = !skipTS && !features.has('no-ts-old');
+      const tsNew = !skipTS && !features.has('no-ts-new');
+
+      return [].concat(
+        skipBase ? [] : addComment(
+          {
+            ...test,
+            ...typeof es === 'number' && {
+              parserOptions: { ...test.parserOptions, ecmaVersion: es },
+            },
+          },
+          'default',
+        ),
+        skipOldBabel ? [] : addComment({
+          ...test,
+          parser: parsers.BABEL_ESLINT,
+          parserOptions: parsers.babelParserOptions(test, features),
+        }, 'babel-eslint'),
+        skipNewBabel ? [] : addComment({
+          ...test,
+          parser: parsers['@BABEL_ESLINT'],
+          parserOptions: parsers.babelParserOptions(test, features),
+        }, '@babel/eslint-parser'),
+        tsOld ? addComment({ ...test, parser: parsers.TYPESCRIPT_ESLINT }, 'typescript-eslint') : [],
+        tsNew ? addComment({ ...test, parser: parsers['@TYPESCRIPT_ESLINT'] }, '@typescript-eslint/parser') : [],
+      );
+    });
+    return t;
+  },
+};
+
+export default parsers;
diff --git a/__tests__/src/rules/accessible-emoji-test.js b/__tests__/src/rules/accessible-emoji-test.js
index dc3d19683..a1d21f461 100644
--- a/__tests__/src/rules/accessible-emoji-test.js
+++ b/__tests__/src/rules/accessible-emoji-test.js
@@ -10,6 +10,7 @@
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
 import rule from '../../../src/rules/accessible-emoji';
+import parsers from '../../__util__/helpers/parsers';
 
 // -----------------------------------------------------------------------------
 // Tests
@@ -23,7 +24,7 @@ const expectedError = {
 };
 
 ruleTester.run('accessible-emoji', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<div />;' },
     { code: '<span />' },
     { code: '<span>No emoji here!</span>' },
@@ -42,8 +43,8 @@ ruleTester.run('accessible-emoji', rule, {
       code: '<CustomInput type="hidden">🐼</CustomInput>',
       settings: { 'jsx-a11y': { components: { CustomInput: 'input' } } },
     },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<span>🐼</span>', errors: [expectedError] },
     { code: '<span>foo🐼bar</span>', errors: [expectedError] },
     { code: '<span>foo 🐼 bar</span>', errors: [expectedError] },
@@ -52,5 +53,5 @@ ruleTester.run('accessible-emoji', rule, {
     { code: '<Foo>🐼</Foo>', errors: [expectedError] },
     { code: '<span aria-hidden="false">🐼</span>', errors: [expectedError] },
     { code: '<CustomInput type="hidden">🐼</CustomInput>', errors: [expectedError] },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/alt-text-test.js b/__tests__/src/rules/alt-text-test.js
index bd2463d73..07b2c8259 100644
--- a/__tests__/src/rules/alt-text-test.js
+++ b/__tests__/src/rules/alt-text-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/alt-text';
 
 // -----------------------------------------------------------------------------
@@ -28,19 +29,29 @@ Use alt="" for presentational images.`,
   type: 'JSXOpeningElement',
 });
 
-const ariaLabelValueError = 'The aria-label attribute must have a value. The alt attribute is preferred over aria-label for images.';
-const ariaLabelledbyValueError = 'The aria-labelledby attribute must have a value. The alt attribute is preferred over aria-labelledby for images.';
+const ariaLabelValueError = {
+  message: 'The aria-label attribute must have a value. The alt attribute is preferred over aria-label for images.',
+};
+const ariaLabelledbyValueError = {
+  message: 'The aria-labelledby attribute must have a value. The alt attribute is preferred over aria-labelledby for images.',
+};
 
 const preferAltError = () => ({
   message: 'Prefer alt="" over a presentational role. First rule of aria is to not use aria if it can be achieved via native HTML.',
   type: 'JSXOpeningElement',
 });
 
-const objectError = 'Embedded <object> elements must have alternative text by providing inner text, aria-label or aria-labelledby props.';
+const objectError = {
+  message: 'Embedded <object> elements must have alternative text by providing inner text, aria-label or aria-labelledby props.',
+};
 
-const areaError = 'Each area of an image map must have a text alternative through the `alt`, `aria-label`, or `aria-labelledby` prop.';
+const areaError = {
+  message: 'Each area of an image map must have a text alternative through the `alt`, `aria-label`, or `aria-labelledby` prop.',
+};
 
-const inputImageError = '<input> elements with type="image" must have a text alternative through the `alt`, `aria-label`, or `aria-labelledby` prop.';
+const inputImageError = {
+  message: '<input> elements with type="image" must have a text alternative through the `alt`, `aria-label`, or `aria-labelledby` prop.',
+};
 
 const componentsSettings = {
   'jsx-a11y': {
@@ -58,7 +69,7 @@ const array = [{
 }];
 
 ruleTester.run('alt-text', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     // DEFAULT ELEMENT 'img' TESTS
     { code: '<img alt="foo" />;' },
     { code: '<img alt={"foo"} />;' },
@@ -166,8 +177,8 @@ ruleTester.run('alt-text', rule, {
     { code: '<InputImage alt="" />', options: array },
     { code: '<InputImage alt="This is descriptive!" />', options: array },
     { code: '<InputImage alt={altText} />', options: array },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     // DEFAULT ELEMENT 'img' TESTS
     { code: '<img />;', errors: [missingPropError('img')] },
     { code: '<img alt />;', errors: [altValueError('img')] },
@@ -273,5 +284,5 @@ ruleTester.run('alt-text', rule, {
     { code: '<InputImage>Foo</InputImage>', errors: [inputImageError], options: array },
     { code: '<InputImage {...this.props} />', errors: [inputImageError], options: array },
     { code: '<Input type="image" />', errors: [inputImageError], settings: componentsSettings },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/anchor-ambiguous-text-test.js b/__tests__/src/rules/anchor-ambiguous-text-test.js
index da57274cd..cbbc39501 100644
--- a/__tests__/src/rules/anchor-ambiguous-text-test.js
+++ b/__tests__/src/rules/anchor-ambiguous-text-test.js
@@ -10,6 +10,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/anchor-ambiguous-text';
 
 // -----------------------------------------------------------------------------
@@ -34,7 +35,7 @@ const expectedErrorGenerator = (words) => ({
 const expectedError = expectedErrorGenerator(DEFAULT_AMBIGUOUS_WORDS);
 
 ruleTester.run('anchor-ambiguous-text', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<a>documentation</a>;' },
     { code: '<a>${here}</a>;' },
     { code: '<a aria-label="tutorial on using eslint-plugin-jsx-a11y">click here</a>;' },
@@ -69,8 +70,8 @@ ruleTester.run('anchor-ambiguous-text', rule, {
       }],
       settings: { 'jsx-a11y': { components: { Link: 'a' } } },
     },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<a>here</a>;', errors: [expectedError] },
     { code: '<a>HERE</a>;', errors: [expectedError] },
     { code: '<a>click here</a>;', errors: [expectedError] },
@@ -113,5 +114,5 @@ ruleTester.run('anchor-ambiguous-text', rule, {
         words: ['a disallowed word'],
       }],
     },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/anchor-has-content-test.js b/__tests__/src/rules/anchor-has-content-test.js
index eb47e8e55..c55dbb9fb 100644
--- a/__tests__/src/rules/anchor-has-content-test.js
+++ b/__tests__/src/rules/anchor-has-content-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/anchor-has-content';
 
 // -----------------------------------------------------------------------------
@@ -23,7 +24,7 @@ const expectedError = {
 };
 
 ruleTester.run('anchor-has-content', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<div />;' },
     { code: '<a>Foo</a>' },
     { code: '<a><Bar /></a>' },
@@ -39,8 +40,8 @@ ruleTester.run('anchor-has-content', rule, {
     { code: '<a title={title} />' },
     { code: '<a aria-label={ariaLabel} />' },
     { code: '<a title={title} aria-label={ariaLabel} />' },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<a />', errors: [expectedError] },
     { code: '<a><Bar aria-hidden /></a>', errors: [expectedError] },
     { code: '<a>{undefined}</a>', errors: [expectedError] },
@@ -49,5 +50,5 @@ ruleTester.run('anchor-has-content', rule, {
       errors: [expectedError],
       settings: { 'jsx-a11y': { components: { Link: 'a' } } },
     },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/anchor-is-valid-test.js b/__tests__/src/rules/anchor-is-valid-test.js
index 5b368d9e7..9fb4025e9 100644
--- a/__tests__/src/rules/anchor-is-valid-test.js
+++ b/__tests__/src/rules/anchor-is-valid-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/anchor-is-valid';
 
 // -----------------------------------------------------------------------------
@@ -88,7 +89,7 @@ const componentsSettings = {
 };
 
 ruleTester.run('anchor-is-valid', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     // DEFAULT ELEMENT 'a' TESTS
     { code: '<Anchor />' },
     { code: '<a {...props} />' },
@@ -279,8 +280,8 @@ ruleTester.run('anchor-is-valid', rule, {
     { code: '<Anchor hrefLeft={undefined} />', options: componentsAndSpecialLinkAndInvalidHrefAspect },
     { code: '<Anchor hrefLeft={null} />', options: componentsAndSpecialLinkAndInvalidHrefAspect },
 
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     // DEFAULT ELEMENT 'a' TESTS
     // NO HREF
     { code: '<a />', errors: [noHrefexpectedError] },
@@ -288,8 +289,8 @@ ruleTester.run('anchor-is-valid', rule, {
     { code: '<a href={null} />', errors: [noHrefexpectedError] },
     // INVALID HREF
     { code: '<a href="" />;', errors: [invalidHrefexpectedError] },
-    { code: '<a href="#" />', errors: [invalidHrefErrorMessage] },
-    { code: '<a href={"#"} />', errors: [invalidHrefErrorMessage] },
+    { code: '<a href="#" />', errors: [invalidHrefexpectedError] },
+    { code: '<a href={"#"} />', errors: [invalidHrefexpectedError] },
     { code: '<a href="javascript:void(0)" />', errors: [invalidHrefexpectedError] },
     { code: '<a href={"javascript:void(0)"} />', errors: [invalidHrefexpectedError] },
     // SHOULD BE BUTTON
@@ -308,13 +309,13 @@ ruleTester.run('anchor-is-valid', rule, {
     { code: '<Link href={null} />', errors: [noHrefexpectedError], options: components },
     // INVALID HREF
     { code: '<Link href="" />', errors: [invalidHrefexpectedError], options: components },
-    { code: '<Link href="#" />', errors: [invalidHrefErrorMessage], options: components },
-    { code: '<Link href={"#"} />', errors: [invalidHrefErrorMessage], options: components },
+    { code: '<Link href="#" />', errors: [invalidHrefexpectedError], options: components },
+    { code: '<Link href={"#"} />', errors: [invalidHrefexpectedError], options: components },
     { code: '<Link href="javascript:void(0)" />', errors: [invalidHrefexpectedError], options: components },
     { code: '<Link href={"javascript:void(0)"} />', errors: [invalidHrefexpectedError], options: components },
     { code: '<Anchor href="" />', errors: [invalidHrefexpectedError], options: components },
-    { code: '<Anchor href="#" />', errors: [invalidHrefErrorMessage], options: components },
-    { code: '<Anchor href={"#"} />', errors: [invalidHrefErrorMessage], options: components },
+    { code: '<Anchor href="#" />', errors: [invalidHrefexpectedError], options: components },
+    { code: '<Anchor href={"#"} />', errors: [invalidHrefexpectedError], options: components },
     { code: '<Anchor href="javascript:void(0)" />', errors: [invalidHrefexpectedError], options: components },
     { code: '<Anchor href={"javascript:void(0)"} />', errors: [invalidHrefexpectedError], options: components },
     // SHOULD BE BUTTON
@@ -354,8 +355,8 @@ ruleTester.run('anchor-is-valid', rule, {
     { code: '<a hrefLeft={null} />', errors: [noHrefexpectedError], options: specialLink },
     // INVALID HREF
     { code: '<a hrefLeft="" />;', errors: [invalidHrefexpectedError], options: specialLink },
-    { code: '<a hrefLeft="#" />', errors: [invalidHrefErrorMessage], options: specialLink },
-    { code: '<a hrefLeft={"#"} />', errors: [invalidHrefErrorMessage], options: specialLink },
+    { code: '<a hrefLeft="#" />', errors: [invalidHrefexpectedError], options: specialLink },
+    { code: '<a hrefLeft={"#"} />', errors: [invalidHrefexpectedError], options: specialLink },
     { code: '<a hrefLeft="javascript:void(0)" />', errors: [invalidHrefexpectedError], options: specialLink },
     { code: '<a hrefLeft={"javascript:void(0)"} />', errors: [invalidHrefexpectedError], options: specialLink },
     // SHOULD BE BUTTON
@@ -377,8 +378,8 @@ ruleTester.run('anchor-is-valid', rule, {
     { code: '<Anchor hrefLeft={null} />', errors: [noHrefexpectedError], options: componentsAndSpecialLink },
     // INVALID HREF
     { code: '<Anchor hrefLeft="" />;', errors: [invalidHrefexpectedError], options: componentsAndSpecialLink },
-    { code: '<Anchor hrefLeft="#" />', errors: [invalidHrefErrorMessage], options: componentsAndSpecialLink },
-    { code: '<Anchor hrefLeft={"#"} />', errors: [invalidHrefErrorMessage], options: componentsAndSpecialLink },
+    { code: '<Anchor hrefLeft="#" />', errors: [invalidHrefexpectedError], options: componentsAndSpecialLink },
+    { code: '<Anchor hrefLeft={"#"} />', errors: [invalidHrefexpectedError], options: componentsAndSpecialLink },
     {
       code: '<Anchor hrefLeft="javascript:void(0)" />',
       errors: [invalidHrefexpectedError],
@@ -408,149 +409,149 @@ ruleTester.run('anchor-is-valid', rule, {
 
     // WITH ASPECTS TESTS
     // NO HREF
-    { code: '<a />', options: noHrefAspect, errors: [noHrefErrorMessage] },
-    { code: '<a />', options: noHrefPreferButtonAspect, errors: [noHrefErrorMessage] },
-    { code: '<a />', options: noHrefInvalidHrefAspect, errors: [noHrefErrorMessage] },
-    { code: '<a href={undefined} />', options: noHrefAspect, errors: [noHrefErrorMessage] },
-    { code: '<a href={undefined} />', options: noHrefPreferButtonAspect, errors: [noHrefErrorMessage] },
-    { code: '<a href={undefined} />', options: noHrefInvalidHrefAspect, errors: [noHrefErrorMessage] },
-    { code: '<a href={null} />', options: noHrefAspect, errors: [noHrefErrorMessage] },
-    { code: '<a href={null} />', options: noHrefPreferButtonAspect, errors: [noHrefErrorMessage] },
-    { code: '<a href={null} />', options: noHrefInvalidHrefAspect, errors: [noHrefErrorMessage] },
+    { code: '<a />', options: noHrefAspect, errors: [noHrefexpectedError] },
+    { code: '<a />', options: noHrefPreferButtonAspect, errors: [noHrefexpectedError] },
+    { code: '<a />', options: noHrefInvalidHrefAspect, errors: [noHrefexpectedError] },
+    { code: '<a href={undefined} />', options: noHrefAspect, errors: [noHrefexpectedError] },
+    { code: '<a href={undefined} />', options: noHrefPreferButtonAspect, errors: [noHrefexpectedError] },
+    { code: '<a href={undefined} />', options: noHrefInvalidHrefAspect, errors: [noHrefexpectedError] },
+    { code: '<a href={null} />', options: noHrefAspect, errors: [noHrefexpectedError] },
+    { code: '<a href={null} />', options: noHrefPreferButtonAspect, errors: [noHrefexpectedError] },
+    { code: '<a href={null} />', options: noHrefInvalidHrefAspect, errors: [noHrefexpectedError] },
 
     // INVALID HREF
-    { code: '<a href="" />;', options: invalidHrefAspect, errors: [invalidHrefErrorMessage] },
-    { code: '<a href="" />;', options: noHrefInvalidHrefAspect, errors: [invalidHrefErrorMessage] },
-    { code: '<a href="" />;', options: preferButtonInvalidHrefAspect, errors: [invalidHrefErrorMessage] },
-    { code: '<a href="#" />;', options: invalidHrefAspect, errors: [invalidHrefErrorMessage] },
-    { code: '<a href="#" />;', options: noHrefInvalidHrefAspect, errors: [invalidHrefErrorMessage] },
-    { code: '<a href="#" />;', options: preferButtonInvalidHrefAspect, errors: [invalidHrefErrorMessage] },
-    { code: '<a href={"#"} />;', options: invalidHrefAspect, errors: [invalidHrefErrorMessage] },
-    { code: '<a href={"#"} />;', options: noHrefInvalidHrefAspect, errors: [invalidHrefErrorMessage] },
-    { code: '<a href={"#"} />;', options: preferButtonInvalidHrefAspect, errors: [invalidHrefErrorMessage] },
-    { code: '<a href="javascript:void(0)" />;', options: invalidHrefAspect, errors: [invalidHrefErrorMessage] },
-    { code: '<a href="javascript:void(0)" />;', options: noHrefInvalidHrefAspect, errors: [invalidHrefErrorMessage] },
+    { code: '<a href="" />;', options: invalidHrefAspect, errors: [invalidHrefexpectedError] },
+    { code: '<a href="" />;', options: noHrefInvalidHrefAspect, errors: [invalidHrefexpectedError] },
+    { code: '<a href="" />;', options: preferButtonInvalidHrefAspect, errors: [invalidHrefexpectedError] },
+    { code: '<a href="#" />;', options: invalidHrefAspect, errors: [invalidHrefexpectedError] },
+    { code: '<a href="#" />;', options: noHrefInvalidHrefAspect, errors: [invalidHrefexpectedError] },
+    { code: '<a href="#" />;', options: preferButtonInvalidHrefAspect, errors: [invalidHrefexpectedError] },
+    { code: '<a href={"#"} />;', options: invalidHrefAspect, errors: [invalidHrefexpectedError] },
+    { code: '<a href={"#"} />;', options: noHrefInvalidHrefAspect, errors: [invalidHrefexpectedError] },
+    { code: '<a href={"#"} />;', options: preferButtonInvalidHrefAspect, errors: [invalidHrefexpectedError] },
+    { code: '<a href="javascript:void(0)" />;', options: invalidHrefAspect, errors: [invalidHrefexpectedError] },
+    { code: '<a href="javascript:void(0)" />;', options: noHrefInvalidHrefAspect, errors: [invalidHrefexpectedError] },
     {
       code: '<a href="javascript:void(0)" />;',
       options: preferButtonInvalidHrefAspect,
-      errors: [invalidHrefErrorMessage],
+      errors: [invalidHrefexpectedError],
     },
-    { code: '<a href={"javascript:void(0)"} />;', options: invalidHrefAspect, errors: [invalidHrefErrorMessage] },
-    { code: '<a href={"javascript:void(0)"} />;', options: noHrefInvalidHrefAspect, errors: [invalidHrefErrorMessage] },
+    { code: '<a href={"javascript:void(0)"} />;', options: invalidHrefAspect, errors: [invalidHrefexpectedError] },
+    { code: '<a href={"javascript:void(0)"} />;', options: noHrefInvalidHrefAspect, errors: [invalidHrefexpectedError] },
     {
       code: '<a href={"javascript:void(0)"} />;',
       options: preferButtonInvalidHrefAspect,
-      errors: [invalidHrefErrorMessage],
+      errors: [invalidHrefexpectedError],
     },
 
     // SHOULD BE BUTTON
-    { code: '<a onClick={() => void 0} />', options: preferButtonAspect, errors: [preferButtonErrorMessage] },
+    { code: '<a onClick={() => void 0} />', options: preferButtonAspect, errors: [preferButtonexpectedError] },
     {
       code: '<a onClick={() => void 0} />',
       options: preferButtonInvalidHrefAspect,
-      errors: [preferButtonErrorMessage],
+      errors: [preferButtonexpectedError],
     },
-    { code: '<a onClick={() => void 0} />', options: noHrefPreferButtonAspect, errors: [preferButtonErrorMessage] },
-    { code: '<a onClick={() => void 0} />', options: noHrefAspect, errors: [noHrefErrorMessage] },
-    { code: '<a onClick={() => void 0} />', options: noHrefInvalidHrefAspect, errors: [noHrefErrorMessage] },
-    { code: '<a href="#" onClick={() => void 0} />', options: preferButtonAspect, errors: [preferButtonErrorMessage] },
+    { code: '<a onClick={() => void 0} />', options: noHrefPreferButtonAspect, errors: [preferButtonexpectedError] },
+    { code: '<a onClick={() => void 0} />', options: noHrefAspect, errors: [noHrefexpectedError] },
+    { code: '<a onClick={() => void 0} />', options: noHrefInvalidHrefAspect, errors: [noHrefexpectedError] },
+    { code: '<a href="#" onClick={() => void 0} />', options: preferButtonAspect, errors: [preferButtonexpectedError] },
     {
       code: '<a href="#" onClick={() => void 0} />',
       options: noHrefPreferButtonAspect,
-      errors: [preferButtonErrorMessage],
+      errors: [preferButtonexpectedError],
     },
     {
       code: '<a href="#" onClick={() => void 0} />',
       options: preferButtonInvalidHrefAspect,
-      errors: [preferButtonErrorMessage],
+      errors: [preferButtonexpectedError],
     },
-    { code: '<a href="#" onClick={() => void 0} />', options: invalidHrefAspect, errors: [invalidHrefErrorMessage] },
+    { code: '<a href="#" onClick={() => void 0} />', options: invalidHrefAspect, errors: [invalidHrefexpectedError] },
     {
       code: '<a href="#" onClick={() => void 0} />',
       options: noHrefInvalidHrefAspect,
-      errors: [invalidHrefErrorMessage],
+      errors: [invalidHrefexpectedError],
     },
     {
       code: '<a href="javascript:void(0)" onClick={() => void 0} />',
       options: preferButtonAspect,
-      errors: [preferButtonErrorMessage],
+      errors: [preferButtonexpectedError],
     },
     {
       code: '<a href="javascript:void(0)" onClick={() => void 0} />',
       options: noHrefPreferButtonAspect,
-      errors: [preferButtonErrorMessage],
+      errors: [preferButtonexpectedError],
     },
     {
       code: '<a href="javascript:void(0)" onClick={() => void 0} />',
       options: preferButtonInvalidHrefAspect,
-      errors: [preferButtonErrorMessage],
+      errors: [preferButtonexpectedError],
     },
     {
       code: '<a href="javascript:void(0)" onClick={() => void 0} />',
       options: invalidHrefAspect,
-      errors: [invalidHrefErrorMessage],
+      errors: [invalidHrefexpectedError],
     },
     {
       code: '<a href="javascript:void(0)" onClick={() => void 0} />',
       options: noHrefInvalidHrefAspect,
-      errors: [invalidHrefErrorMessage],
+      errors: [invalidHrefexpectedError],
     },
     {
       code: '<a href={"javascript:void(0)"} onClick={() => void 0} />',
       options: preferButtonAspect,
-      errors: [preferButtonErrorMessage],
+      errors: [preferButtonexpectedError],
     },
     {
       code: '<a href={"javascript:void(0)"} onClick={() => void 0} />',
       options: noHrefPreferButtonAspect,
-      errors: [preferButtonErrorMessage],
+      errors: [preferButtonexpectedError],
     },
     {
       code: '<a href={"javascript:void(0)"} onClick={() => void 0} />',
       options: preferButtonInvalidHrefAspect,
-      errors: [preferButtonErrorMessage],
+      errors: [preferButtonexpectedError],
     },
     {
       code: '<a href={"javascript:void(0)"} onClick={() => void 0} />',
       options: invalidHrefAspect,
-      errors: [invalidHrefErrorMessage],
+      errors: [invalidHrefexpectedError],
     },
     {
       code: '<a href={"javascript:void(0)"} onClick={() => void 0} />',
       options: noHrefInvalidHrefAspect,
-      errors: [invalidHrefErrorMessage],
+      errors: [invalidHrefexpectedError],
     },
 
     // CUSTOM COMPONENTS AND SPECIALLINK AND ASPECT
     {
       code: '<Anchor hrefLeft={undefined} />',
       options: componentsAndSpecialLinkAndNoHrefAspect,
-      errors: [noHrefErrorMessage],
+      errors: [noHrefexpectedError],
     },
     {
       code: '<Anchor hrefLeft={null} />',
       options: componentsAndSpecialLinkAndNoHrefAspect,
-      errors: [noHrefErrorMessage],
+      errors: [noHrefexpectedError],
     },
     {
       code: '<Anchor hrefLeft={undefined} />',
       options: componentsAndSpecialLinkAndNoHrefAspect,
-      errors: [noHrefErrorMessage],
+      errors: [noHrefexpectedError],
     },
     {
       code: '<Anchor hrefLeft={null} />',
       options: componentsAndSpecialLinkAndNoHrefAspect,
-      errors: [noHrefErrorMessage],
+      errors: [noHrefexpectedError],
     },
     {
       code: '<Anchor hrefLeft={undefined} />',
       options: componentsAndSpecialLinkAndNoHrefAspect,
-      errors: [noHrefErrorMessage],
+      errors: [noHrefexpectedError],
     },
     {
       code: '<Anchor hrefLeft={null} />',
       options: componentsAndSpecialLinkAndNoHrefAspect,
-      errors: [noHrefErrorMessage],
+      errors: [noHrefexpectedError],
     },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/aria-activedescendant-has-tabindex-test.js b/__tests__/src/rules/aria-activedescendant-has-tabindex-test.js
index 6c251cf23..5310ac9ac 100644
--- a/__tests__/src/rules/aria-activedescendant-has-tabindex-test.js
+++ b/__tests__/src/rules/aria-activedescendant-has-tabindex-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/aria-activedescendant-has-tabindex';
 
 // -----------------------------------------------------------------------------
@@ -23,7 +24,7 @@ const expectedError = {
 };
 
 ruleTester.run('aria-activedescendant-has-tabindex', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     {
       code: '<CustomComponent />;',
     },
@@ -79,8 +80,8 @@ ruleTester.run('aria-activedescendant-has-tabindex', rule, {
     {
       code: '<input aria-activedescendant={someID} tabIndex={-1} />;',
     },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     {
       code: '<div aria-activedescendant={someID} />;',
       errors: [expectedError],
@@ -90,5 +91,5 @@ ruleTester.run('aria-activedescendant-has-tabindex', rule, {
       errors: [expectedError],
       settings: { 'jsx-a11y': { components: { CustomComponent: 'div' } } },
     },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/aria-props-test.js b/__tests__/src/rules/aria-props-test.js
index 89aa9864d..1236fa7c7 100644
--- a/__tests__/src/rules/aria-props-test.js
+++ b/__tests__/src/rules/aria-props-test.js
@@ -10,6 +10,7 @@
 import { aria } from 'aria-query';
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/aria-props';
 import getSuggestion from '../../../src/util/getSuggestion';
 
@@ -43,7 +44,7 @@ const basicValidityTests = ariaAttributes.map((prop) => ({
 }));
 
 ruleTester.run('aria-props', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     // Variables should pass, as we are only testing literals.
     { code: '<div />' },
     { code: '<div></div>' },
@@ -53,8 +54,8 @@ ruleTester.run('aria-props', rule, {
     { code: '<div fooaria-hidden="true"></div>' },
     { code: '<Bar baz />' },
     { code: '<input type="text" aria-errormessage="foobar" />' },
-  ].concat(basicValidityTests).map(parserOptionsMapper),
-  invalid: [
+  )).concat(basicValidityTests).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<div aria-="foobar" />', errors: [errorMessage('aria-')] },
     {
       code: '<div aria-labeledby="foobar" />',
@@ -64,5 +65,5 @@ ruleTester.run('aria-props', rule, {
       code: '<div aria-skldjfaria-klajsd="foobar" />',
       errors: [errorMessage('aria-skldjfaria-klajsd')],
     },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/aria-proptypes-test.js b/__tests__/src/rules/aria-proptypes-test.js
index f9ff1c8f7..67be3304a 100644
--- a/__tests__/src/rules/aria-proptypes-test.js
+++ b/__tests__/src/rules/aria-proptypes-test.js
@@ -11,6 +11,7 @@ import { aria } from 'aria-query';
 import { RuleTester } from 'eslint';
 import expect from 'expect';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/aria-proptypes';
 
 const { validityCheck } = rule;
@@ -29,22 +30,24 @@ const errorMessage = (name) => {
 
   switch (type) {
     case 'tristate':
-      return `The value for ${name} must be a boolean or the string "mixed".`;
+      return { message: `The value for ${name} must be a boolean or the string "mixed".` };
     case 'token':
-      return `The value for ${name} must be a single token from the following: ${permittedValues}.`;
+      return { message: `The value for ${name} must be a single token from the following: ${permittedValues}.` };
     case 'tokenlist':
-      return `The value for ${name} must be a list of one or more \
-tokens from the following: ${permittedValues}.`;
+      return {
+        message: `The value for ${name} must be a list of one or more \
+tokens from the following: ${permittedValues}.`,
+      };
     case 'idlist':
-      return `The value for ${name} must be a list of strings that represent DOM element IDs (idlist)`;
+      return { message: `The value for ${name} must be a list of strings that represent DOM element IDs (idlist)` };
     case 'id':
-      return `The value for ${name} must be a string that represents a DOM element ID`;
+      return { message: `The value for ${name} must be a string that represents a DOM element ID` };
     case 'boolean':
     case 'string':
     case 'integer':
     case 'number':
     default:
-      return `The value for ${name} must be a ${type}.`;
+      return { message: `The value for ${name} must be a ${type}.` };
   }
 };
 
@@ -58,7 +61,7 @@ describe('validityCheck', () => {
 });
 
 ruleTester.run('aria-proptypes', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     // DON'T TEST INVALID ARIA-* PROPS
     { code: '<div aria-foo="true" />' },
     { code: '<div abcaria-foo="true" />' },
@@ -211,8 +214,8 @@ ruleTester.run('aria-proptypes', rule, {
     { code: '<div aria-labelledby={foo.bar} />' },
     { code: '<div aria-labelledby={null} />' },
     { code: '<div aria-labelledby={undefined} />' },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     // BOOLEAN
     { code: '<div aria-hidden="yes" />', errors: [errorMessage('aria-hidden')] },
     { code: '<div aria-hidden="no" />', errors: [errorMessage('aria-hidden')] },
@@ -302,5 +305,5 @@ ruleTester.run('aria-proptypes', rule, {
       code: '<div aria-relevant="additions removalss " />',
       errors: [errorMessage('aria-relevant')],
     },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/aria-role-test.js b/__tests__/src/rules/aria-role-test.js
index cf1ffccf9..410749666 100644
--- a/__tests__/src/rules/aria-role-test.js
+++ b/__tests__/src/rules/aria-role-test.js
@@ -10,6 +10,7 @@
 import { roles } from 'aria-query';
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/aria-role';
 
 // -----------------------------------------------------------------------------
@@ -56,7 +57,7 @@ const customDivSettings = {
 };
 
 ruleTester.run('aria-role', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     // Variables should pass, as we are only testing literals.
     { code: '<div />' },
     { code: '<div></div>' },
@@ -81,9 +82,9 @@ ruleTester.run('aria-role', rule, {
     {
       code: '<svg role="graphics-document document" />',
     },
-  ].concat(validTests).map(parserOptionsMapper),
+  )).concat(validTests).map(parserOptionsMapper),
 
-  invalid: [
+  invalid: parsers.all([].concat(
     { code: '<div role="foobar" />', errors: [errorMessage] },
     { code: '<div role="datepicker"></div>', errors: [errorMessage] },
     { code: '<div role="range"></div>', errors: [errorMessage] },
@@ -104,5 +105,5 @@ ruleTester.run('aria-role', rule, {
       options: ignoreNonDOMSchema,
       settings: customDivSettings,
     },
-  ].concat(invalidTests).map(parserOptionsMapper),
+  )).concat(invalidTests).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/aria-unsupported-elements-test.js b/__tests__/src/rules/aria-unsupported-elements-test.js
index 1e1b94212..31b348841 100644
--- a/__tests__/src/rules/aria-unsupported-elements-test.js
+++ b/__tests__/src/rules/aria-unsupported-elements-test.js
@@ -11,6 +11,7 @@
 import { dom } from 'aria-query';
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/aria-unsupported-elements';
 
 // -----------------------------------------------------------------------------
@@ -68,7 +69,7 @@ const invalidAriaValidityTests = domElements
   }));
 
 ruleTester.run('aria-unsupported-elements', rule, {
-  valid: roleValidityTests.concat(ariaValidityTests).map(parserOptionsMapper),
-  invalid: invalidRoleValidityTests.concat(invalidAriaValidityTests)
+  valid: parsers.all([].concat(roleValidityTests.concat(ariaValidityTests))).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(invalidRoleValidityTests.concat(invalidAriaValidityTests)))
     .map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/autocomplete-valid-test.js b/__tests__/src/rules/autocomplete-valid-test.js
index 49f194067..57b1257c0 100644
--- a/__tests__/src/rules/autocomplete-valid-test.js
+++ b/__tests__/src/rules/autocomplete-valid-test.js
@@ -10,6 +10,7 @@
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
 import { axeFailMessage } from '../../__util__/axeMapping';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/autocomplete-valid';
 
 // -----------------------------------------------------------------------------
@@ -37,7 +38,7 @@ const componentsSettings = {
 };
 
 ruleTester.run('autocomplete-valid', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     // INAPPLICABLE
     { code: '<input type="text" />;' },
     // // PASSED AUTOCOMPLETE
@@ -63,8 +64,8 @@ ruleTester.run('autocomplete-valid', rule, {
     { code: '<input type="number" autocomplete="url" />;', errors: inappropriateAutocomplete },
     { code: '<input type="month" autocomplete="tel" />;', errors: inappropriateAutocomplete },
     { code: '<Foo type="month" autocomplete="tel"></Foo>;', errors: inappropriateAutocomplete, options: [{ inputComponents: ['Foo'] }] },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     // FAILED "autocomplete-valid"
     { code: '<input type="text" autocomplete="foo" />;', errors: invalidAutocomplete },
     { code: '<input type="text" autocomplete="name invalid" />;', errors: invalidAutocomplete },
@@ -72,5 +73,5 @@ ruleTester.run('autocomplete-valid', rule, {
     { code: '<input type="text" autocomplete="home url" />;', errors: invalidAutocomplete },
     { code: '<Bar autocomplete="baz"></Bar>;', errors: invalidAutocomplete, options: [{ inputComponents: ['Bar'] }] },
     { code: '<Input type="text" autocomplete="baz" />', errors: invalidAutocomplete, settings: componentsSettings },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/click-events-have-key-events-test.js b/__tests__/src/rules/click-events-have-key-events-test.js
index 5460504f6..683a71b7b 100644
--- a/__tests__/src/rules/click-events-have-key-events-test.js
+++ b/__tests__/src/rules/click-events-have-key-events-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/click-events-have-key-events';
 
 // -----------------------------------------------------------------------------
@@ -25,7 +26,7 @@ const expectedError = {
 };
 
 ruleTester.run('click-events-have-key-events', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<div onClick={() => void 0} onKeyDown={foo}/>;' },
     { code: '<div onClick={() => void 0} onKeyUp={foo} />;' },
     { code: '<div onClick={() => void 0} onKeyPress={foo}/>;' },
@@ -52,8 +53,8 @@ ruleTester.run('click-events-have-key-events', rule, {
     { code: '<TestComponent onClick={doFoo} />' },
     { code: '<Button onClick={doFoo} />' },
     { code: '<Footer onClick={doFoo} />' },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<div onClick={() => void 0} />;', errors: [expectedError] },
     {
       code: '<div onClick={() => void 0} role={undefined} />;',
@@ -72,5 +73,5 @@ ruleTester.run('click-events-have-key-events', rule, {
     { code: '<a onClick={() => void 0} />', errors: [expectedError] },
     { code: '<a tabIndex="0" onClick={() => void 0} />', errors: [expectedError] },
     { code: '<Footer onClick={doFoo} />', errors: [expectedError], settings: { 'jsx-a11y': { components: { Footer: 'footer' } } } },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/control-has-associated-label-test.js b/__tests__/src/rules/control-has-associated-label-test.js
index fd2950830..73bf2be6e 100644
--- a/__tests__/src/rules/control-has-associated-label-test.js
+++ b/__tests__/src/rules/control-has-associated-label-test.js
@@ -10,6 +10,7 @@
 import { RuleTester } from 'eslint';
 import { configs } from '../../../src/index';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import ruleOptionsMapperFactory from '../../__util__/ruleOptionsMapperFactory';
 import rule from '../../../src/rules/control-has-associated-label';
 
@@ -287,40 +288,40 @@ const neverValid = [
 
 const recommendedOptions = (configs.recommended.rules[ruleName][1] || {});
 ruleTester.run(`${ruleName}:recommended`, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
-  ]
+  ))
     .map(ruleOptionsMapperFactory(recommendedOptions))
     .map(parserOptionsMapper),
-  invalid: [
+  invalid: parsers.all([].concat(
     ...neverValid,
-  ]
+  ))
     .map(ruleOptionsMapperFactory(recommendedOptions))
     .map(parserOptionsMapper),
 });
 
 const strictOptions = (configs.strict.rules[ruleName][1] || {});
 ruleTester.run(`${ruleName}:strict`, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
-  ]
+  ))
     .map(ruleOptionsMapperFactory(strictOptions))
     .map(parserOptionsMapper),
-  invalid: [
+  invalid: parsers.all([].concat(
     ...neverValid,
-  ]
+  ))
     .map(ruleOptionsMapperFactory(strictOptions))
     .map(parserOptionsMapper),
 });
 
 ruleTester.run(`${ruleName}:no-config`, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<input type="hidden" />' },
     { code: '<input type="text" aria-hidden="true" />' },
-  ]
+  ))
     .map(parserOptionsMapper),
-  invalid: [
+  invalid: parsers.all([].concat(
     { code: '<input type="text" />', errors: [expectedError] },
-  ]
+  ))
     .map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/heading-has-content-test.js b/__tests__/src/rules/heading-has-content-test.js
index a2a201be0..f9955440e 100644
--- a/__tests__/src/rules/heading-has-content-test.js
+++ b/__tests__/src/rules/heading-has-content-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/heading-has-content';
 
 // -----------------------------------------------------------------------------
@@ -37,7 +38,7 @@ const componentsSettings = {
 };
 
 ruleTester.run('heading-has-content', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     // DEFAULT ELEMENT TESTS
     { code: '<div />;' },
     { code: '<h1>Foo</h1>' },
@@ -64,8 +65,8 @@ ruleTester.run('heading-has-content', rule, {
     // CUSTOM ELEMENT TESTS FOR COMPONENTS SETTINGS
     { code: '<Heading>Foo</Heading>', settings: componentsSettings },
     { code: '<h1><CustomInput type="hidden" /></h1>' },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     // DEFAULT ELEMENT TESTS
     { code: '<h1 />', errors: [expectedError] },
     { code: '<h1><Bar aria-hidden /></h1>', errors: [expectedError] },
@@ -80,5 +81,5 @@ ruleTester.run('heading-has-content', rule, {
     // CUSTOM ELEMENT TESTS FOR COMPONENTS SETTINGS
     { code: '<Heading />', errors: [expectedError], settings: componentsSettings },
     { code: '<h1><CustomInput type="hidden" /></h1>', errors: [expectedError], settings: componentsSettings },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/html-has-lang-test.js b/__tests__/src/rules/html-has-lang-test.js
index ba9e58d0a..4af612b9c 100644
--- a/__tests__/src/rules/html-has-lang-test.js
+++ b/__tests__/src/rules/html-has-lang-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/html-has-lang';
 
 // -----------------------------------------------------------------------------
@@ -23,7 +24,7 @@ const expectedError = {
 };
 
 ruleTester.run('html-has-lang', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<div />;' },
     { code: '<html lang="en" />' },
     { code: '<html lang="en-US" />' },
@@ -31,11 +32,11 @@ ruleTester.run('html-has-lang', rule, {
     { code: '<html lang />' },
     { code: '<HTML />' },
     { code: '<HTMLTop lang="en" />', errors: [expectedError], settings: { 'jsx-a11y': { components: { HTMLTop: 'html' } } } },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<html />', errors: [expectedError] },
     { code: '<html {...props} />', errors: [expectedError] },
     { code: '<html lang={undefined} />', errors: [expectedError] },
     { code: '<HTMLTop />', errors: [expectedError], settings: { 'jsx-a11y': { components: { HTMLTop: 'html' } } } },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/iframe-has-title-test.js b/__tests__/src/rules/iframe-has-title-test.js
index 716be75e0..0bf60311f 100644
--- a/__tests__/src/rules/iframe-has-title-test.js
+++ b/__tests__/src/rules/iframe-has-title-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/iframe-has-title';
 
 // -----------------------------------------------------------------------------
@@ -31,14 +32,14 @@ const componentsSettings = {
 };
 
 ruleTester.run('html-has-lang', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<div />;' },
     { code: '<iframe title="Unique title" />' },
     { code: '<iframe title={foo} />' },
     { code: '<FooComponent />' },
     { code: '<FooComponent title="Unique title" />', settings: componentsSettings },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<iframe />', errors: [expectedError] },
     { code: '<iframe {...props} />', errors: [expectedError] },
     { code: '<iframe title={undefined} />', errors: [expectedError] },
@@ -50,5 +51,5 @@ ruleTester.run('html-has-lang', rule, {
     { code: '<iframe title={""} />', errors: [expectedError] },
     { code: '<iframe title={42} />', errors: [expectedError] },
     { code: '<FooComponent />', errors: [expectedError], settings: componentsSettings },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/img-redundant-alt-test.js b/__tests__/src/rules/img-redundant-alt-test.js
index 868577a07..ccacb210c 100644
--- a/__tests__/src/rules/img-redundant-alt-test.js
+++ b/__tests__/src/rules/img-redundant-alt-test.js
@@ -11,6 +11,7 @@ import { RuleTester } from 'eslint';
 import semver from 'semver';
 import { version as eslintVersion } from 'eslint/package.json';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/img-redundant-alt';
 
 // -----------------------------------------------------------------------------
@@ -38,7 +39,7 @@ const expectedError = {
 };
 
 ruleTester.run('img-redundant-alt', rule, {
-  valid: [].concat(
+  valid: parsers.all([].concat(
     { code: '<img alt="foo" />;' },
     { code: '<img alt="picture of me taking a photo of an image" aria-hidden />' },
     { code: '<img aria-hidden alt="photo of image" />' },
@@ -73,8 +74,8 @@ ruleTester.run('img-redundant-alt', rule, {
     { code: '<img alt="ImageMagick" />;' },
     { code: '<Image alt="Photo of a friend" />' },
     { code: '<Image alt="Foo" />', settings: componentsSettings },
-  ).map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<img alt="Photo of friend." />;', errors: [expectedError] },
     { code: '<img alt="Picture of friend." />;', errors: [expectedError] },
     { code: '<img alt="Image of friend." />;', errors: [expectedError] },
@@ -128,5 +129,5 @@ ruleTester.run('img-redundant-alt', rule, {
     { code: '<img alt="Word2" />;', options: array, errors: [expectedError] },
     { code: '<Image alt="Word1" />;', options: array, errors: [expectedError] },
     { code: '<Image alt="Word2" />;', options: array, errors: [expectedError] },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/interactive-supports-focus-test.js b/__tests__/src/rules/interactive-supports-focus-test.js
index 19bac9f57..3220942ac 100644
--- a/__tests__/src/rules/interactive-supports-focus-test.js
+++ b/__tests__/src/rules/interactive-supports-focus-test.js
@@ -15,6 +15,7 @@ import {
 } from 'jsx-ast-utils';
 import { configs } from '../../../src/index';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/interactive-supports-focus';
 import ruleOptionsMapperFactory from '../../__util__/ruleOptionsMapperFactory';
 
@@ -208,7 +209,7 @@ const failReducer = (roles, handlers, messageTemplate) => (
 );
 
 ruleTester.run(`${ruleName}:recommended`, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
     ...passReducer(
       interactiveRoles,
@@ -220,10 +221,10 @@ ruleTester.run(`${ruleName}:recommended`, rule, {
       eventHandlers.filter((handler) => includes(triggeringHandlers, handler)),
       tabindexTemplate,
     ),
-  ]
+  ))
     .map(ruleOptionsMapperFactory(recommendedOptions))
     .map(parserOptionsMapper),
-  invalid: [
+  invalid: parsers.all([].concat(
     ...neverValid,
     ...failReducer(recommendedRoles, triggeringHandlers, tabbableTemplate),
     ...failReducer(
@@ -231,13 +232,13 @@ ruleTester.run(`${ruleName}:recommended`, rule, {
       triggeringHandlers,
       focusableTemplate,
     ),
-  ]
+  ))
     .map(ruleOptionsMapperFactory(recommendedOptions))
     .map(parserOptionsMapper),
 });
 
 ruleTester.run(`${ruleName}:strict`, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
     ...passReducer(
       interactiveRoles,
@@ -249,10 +250,10 @@ ruleTester.run(`${ruleName}:strict`, rule, {
       eventHandlers.filter((handler) => includes(triggeringHandlers, handler)),
       tabindexTemplate,
     ),
-  ]
+  ))
     .map(ruleOptionsMapperFactory(strictOptions))
     .map(parserOptionsMapper),
-  invalid: [
+  invalid: parsers.all([].concat(
     ...neverValid,
     ...failReducer(strictRoles, triggeringHandlers, tabbableTemplate),
     ...failReducer(
@@ -260,7 +261,7 @@ ruleTester.run(`${ruleName}:strict`, rule, {
       triggeringHandlers,
       focusableTemplate,
     ),
-  ]
+  ))
     .map(ruleOptionsMapperFactory(strictOptions))
     .map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/label-has-associated-control-test.js b/__tests__/src/rules/label-has-associated-control-test.js
index 9d1ee028f..d0b4c3b31 100644
--- a/__tests__/src/rules/label-has-associated-control-test.js
+++ b/__tests__/src/rules/label-has-associated-control-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/label-has-associated-control';
 import ruleOptionsMapperFactory from '../../__util__/ruleOptionsMapperFactory';
 
@@ -149,18 +150,18 @@ const neverValid = [
 ];
 // htmlFor valid
 ruleTester.run(ruleName, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
     ...htmlForValid,
-  ]
+  ))
     .map(ruleOptionsMapperFactory({
       assert: 'htmlFor',
     }))
     .map(parserOptionsMapper),
-  invalid: [
+  invalid: parsers.all([].concat(
     ...neverValid,
     ...nestingInvalid,
-  ]
+  ))
     .map(ruleOptionsMapperFactory({
       assert: 'htmlFor',
     }))
@@ -169,18 +170,18 @@ ruleTester.run(ruleName, rule, {
 
 // nesting valid
 ruleTester.run(ruleName, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
     ...nestingValid,
-  ]
+  ))
     .map(ruleOptionsMapperFactory({
       assert: 'nesting',
     }))
     .map(parserOptionsMapper),
-  invalid: [
+  invalid: parsers.all([].concat(
     ...neverValid,
     ...htmlForInvalid,
-  ]
+  ))
     .map(ruleOptionsMapperFactory({
       assert: 'nesting',
     }))
@@ -189,31 +190,31 @@ ruleTester.run(ruleName, rule, {
 
 // either valid
 ruleTester.run(ruleName, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
     ...htmlForValid,
     ...nestingValid,
-  ]
+  ))
     .map(ruleOptionsMapperFactory({
       assert: 'either',
     }))
     .map(parserOptionsMapper),
-  invalid: [
+  invalid: parsers.all([].concat(
     ...neverValid,
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
 
 // both valid
 ruleTester.run(ruleName, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
     ...bothValid,
-  ]
+  ))
     .map(ruleOptionsMapperFactory({
       assert: 'both',
     }))
     .map(parserOptionsMapper),
-  invalid: [
+  invalid: parsers.all([].concat(
     ...neverValid,
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/label-has-for-test.js b/__tests__/src/rules/label-has-for-test.js
index 9fffa6093..9b4bd1478 100644
--- a/__tests__/src/rules/label-has-for-test.js
+++ b/__tests__/src/rules/label-has-for-test.js
@@ -10,6 +10,7 @@
 import { RuleTester } from 'eslint';
 import assign from 'object.assign';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/label-has-for';
 
 // -----------------------------------------------------------------------------
@@ -50,7 +51,7 @@ const optionsChildrenAllowed = [{
 }];
 
 ruleTester.run('label-has-for', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     // DEFAULT ELEMENT 'label' TESTS
     { code: '<div />' },
     { code: '<label htmlFor="foo"><input /></label>' },
@@ -90,8 +91,8 @@ ruleTester.run('label-has-for', rule, {
     { code: '<label htmlFor="children">{children}</label>', options: optionsChildrenAllowed },
     { code: '<label htmlFor={id}>{ labelText }<div><input id={id} type="checkbox" name={id} value={value} /></div></label>', options: optionsRequiredEvery },
     { code: '<label htmlFor={id}>{ labelText }<div><div><div><div><input id={id} type="checkbox" name={id} value={value} /></div></div></div></div></label>', options: optionsRequiredEvery },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     // DEFAULT ELEMENT 'label' TESTS
     { code: '<label id="foo" />', errors: [expectedEveryError], options: optionsRequiredEvery },
     { code: '<label htmlFor={undefined} />', errors: [expectedEveryError], options: optionsRequiredEvery },
@@ -218,5 +219,5 @@ ruleTester.run('label-has-for', rule, {
       errors: [expectedEveryError],
       options: optionsRequiredEvery,
     },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/lang-test.js b/__tests__/src/rules/lang-test.js
index ef785a8b3..eaab8da44 100644
--- a/__tests__/src/rules/lang-test.js
+++ b/__tests__/src/rules/lang-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/lang';
 
 // -----------------------------------------------------------------------------
@@ -31,7 +32,7 @@ const componentsSettings = {
 };
 
 ruleTester.run('lang', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<div />;' },
     { code: '<div foo="bar" />;' },
     { code: '<div lang="foo" />;' },
@@ -45,11 +46,11 @@ ruleTester.run('lang', rule, {
     { code: '<HTML lang="foo" />' },
     { code: '<Foo lang={undefined} />' },
     { code: '<Foo lang="en" />', settings: componentsSettings },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<html lang="foo" />', errors: [expectedError] },
     { code: '<html lang="zz-LL" />', errors: [expectedError] },
     { code: '<html lang={undefined} />', errors: [expectedError] },
     { code: '<Foo lang={undefined} />', settings: componentsSettings, errors: [expectedError] },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/media-has-caption-test.js b/__tests__/src/rules/media-has-caption-test.js
index 23d56194d..ab08eeae6 100644
--- a/__tests__/src/rules/media-has-caption-test.js
+++ b/__tests__/src/rules/media-has-caption-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/media-has-caption';
 
 // -----------------------------------------------------------------------------
@@ -41,7 +42,7 @@ const componentsSettings = {
 };
 
 ruleTester.run('media-has-caption', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<div />;' },
     { code: '<MyDiv />;' },
     { code: '<audio><track kind="captions" /></audio>' },
@@ -143,8 +144,8 @@ ruleTester.run('media-has-caption', rule, {
       code: '<Audio muted={true}></Audio>',
       settings: componentsSettings,
     },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<audio><track /></audio>', errors: [expectedError] },
     {
       code: '<audio><track kind="subtitles" /></audio>',
@@ -205,5 +206,5 @@ ruleTester.run('media-has-caption', rule, {
       settings: componentsSettings,
       errors: [expectedError],
     },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/mouse-events-have-key-events-test.js b/__tests__/src/rules/mouse-events-have-key-events-test.js
index 638c9a51b..e7a7e9bb2 100644
--- a/__tests__/src/rules/mouse-events-have-key-events-test.js
+++ b/__tests__/src/rules/mouse-events-have-key-events-test.js
@@ -10,6 +10,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/mouse-events-have-key-events';
 
 // -----------------------------------------------------------------------------
@@ -36,7 +37,7 @@ const pointerLeaveError = {
 };
 
 ruleTester.run('mouse-events-have-key-events', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<div onMouseOver={() => void 0} onFocus={() => void 0} />;' },
     {
       code: '<div onMouseOver={() => void 0} onFocus={() => void 0} {...props} />;',
@@ -94,8 +95,8 @@ ruleTester.run('mouse-events-have-key-events', rule, {
       code: '<div onMouseLeave={() => {}} />',
       options: [{ hoverOutHandlers: ['onPointerLeave'] }],
     },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<div onMouseOver={() => void 0} />;', errors: [mouseOverError] },
     { code: '<div onMouseOut={() => void 0} />', errors: [mouseOutError] },
     {
@@ -149,5 +150,5 @@ ruleTester.run('mouse-events-have-key-events', rule, {
       options: [{ hoverOutHandlers: ['onPointerLeave'] }],
       errors: [pointerLeaveError],
     },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/no-access-key-test.js b/__tests__/src/rules/no-access-key-test.js
index 7987d054b..fc9943853 100644
--- a/__tests__/src/rules/no-access-key-test.js
+++ b/__tests__/src/rules/no-access-key-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/no-access-key';
 
 // -----------------------------------------------------------------------------
@@ -23,12 +24,12 @@ const expectedError = {
 };
 
 ruleTester.run('no-access-key', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<div />;' },
     { code: '<div {...props} />' },
     { code: '<div accessKey={undefined} />' },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<div accesskey="h" />', errors: [expectedError] },
     { code: '<div accessKey="h" />', errors: [expectedError] },
     { code: '<div accessKey="h" {...props} />', errors: [expectedError] },
@@ -43,5 +44,5 @@ ruleTester.run('no-access-key', rule, {
     { code: '<div accessKey={accessKey} />', errors: [expectedError] },
     { code: '<div accessKey={`${undefined}`} />', errors: [expectedError] },
     { code: '<div accessKey={`${undefined}${undefined}`} />', errors: [expectedError] },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/no-aria-hidden-on-focusable-test.js b/__tests__/src/rules/no-aria-hidden-on-focusable-test.js
index 6d908b0aa..b341a2cbb 100644
--- a/__tests__/src/rules/no-aria-hidden-on-focusable-test.js
+++ b/__tests__/src/rules/no-aria-hidden-on-focusable-test.js
@@ -9,7 +9,9 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/no-aria-hidden-on-focusable';
+
 // -----------------------------------------------------------------------------
 // Tests
 // -----------------------------------------------------------------------------
@@ -22,7 +24,7 @@ const expectedError = {
 };
 
 ruleTester.run('no-aria-hidden-on-focusable', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<div aria-hidden="true" />;' },
     { code: '<div onClick={() => void 0} aria-hidden="true" />;' },
     { code: '<img aria-hidden="true" />' },
@@ -30,13 +32,13 @@ ruleTester.run('no-aria-hidden-on-focusable', rule, {
     { code: '<button aria-hidden="true" tabIndex="-1" />' },
     { code: '<button />' },
     { code: '<a href="/" />' },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<div aria-hidden="true" tabIndex="0" />;', errors: [expectedError] },
     { code: '<input aria-hidden="true" />;', errors: [expectedError] },
     { code: '<a href="/" aria-hidden="true" />', errors: [expectedError] },
     { code: '<button aria-hidden="true" />', errors: [expectedError] },
     { code: '<textarea aria-hidden="true" />', errors: [expectedError] },
     { code: '<p tabindex="0" aria-hidden="true">text</p>;', errors: [expectedError] },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/no-autofocus-test.js b/__tests__/src/rules/no-autofocus-test.js
index ce762765f..13bddc724 100644
--- a/__tests__/src/rules/no-autofocus-test.js
+++ b/__tests__/src/rules/no-autofocus-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/no-autofocus';
 
 // -----------------------------------------------------------------------------
@@ -37,7 +38,7 @@ const componentsSettings = {
 };
 
 ruleTester.run('no-autofocus', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<div />;' },
     { code: '<div autofocus />;' },
     { code: '<input autofocus="true" />;' },
@@ -46,8 +47,8 @@ ruleTester.run('no-autofocus', rule, {
     { code: '<div><div autofocus /></div>', options: ignoreNonDOMSchema },
     { code: '<Button />', settings: componentsSettings },
     { code: '<Button />', options: ignoreNonDOMSchema, settings: componentsSettings },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<div autoFocus />', errors: [expectedError] },
     { code: '<div autoFocus={true} />', errors: [expectedError] },
     { code: '<div autoFocus={false} />', errors: [expectedError] },
@@ -63,5 +64,5 @@ ruleTester.run('no-autofocus', rule, {
       options: ignoreNonDOMSchema,
       settings: componentsSettings,
     },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/no-distracting-elements-test.js b/__tests__/src/rules/no-distracting-elements-test.js
index 5e77ae03c..16a7b1b31 100644
--- a/__tests__/src/rules/no-distracting-elements-test.js
+++ b/__tests__/src/rules/no-distracting-elements-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/no-distracting-elements';
 
 // -----------------------------------------------------------------------------
@@ -31,14 +32,14 @@ const componentsSettings = {
 };
 
 ruleTester.run('no-marquee', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<div />;' },
     { code: '<Marquee />' },
     { code: '<div marquee />' },
     { code: '<Blink />' },
     { code: '<div blink />' },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<marquee />', errors: [expectedError('marquee')] },
     { code: '<marquee {...props} />', errors: [expectedError('marquee')] },
     { code: '<marquee lang={undefined} />', errors: [expectedError('marquee')] },
@@ -46,5 +47,5 @@ ruleTester.run('no-marquee', rule, {
     { code: '<blink {...props} />', errors: [expectedError('blink')] },
     { code: '<blink foo={undefined} />', errors: [expectedError('blink')] },
     { code: '<Blink />', settings: componentsSettings, errors: [expectedError('blink')] },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/no-interactive-element-to-noninteractive-role-test.js b/__tests__/src/rules/no-interactive-element-to-noninteractive-role-test.js
index 49384d54b..9edb85e52 100644
--- a/__tests__/src/rules/no-interactive-element-to-noninteractive-role-test.js
+++ b/__tests__/src/rules/no-interactive-element-to-noninteractive-role-test.js
@@ -11,6 +11,7 @@
 import { RuleTester } from 'eslint';
 import { configs } from '../../../src/index';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/no-interactive-element-to-noninteractive-role';
 import ruleOptionsMapperFactory from '../../__util__/ruleOptionsMapperFactory';
 
@@ -378,28 +379,28 @@ const neverValid = [
 
 const recommendedOptions = (configs.recommended.rules[ruleName][1] || {});
 ruleTester.run(`${ruleName}:recommended`, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
     { code: '<tr role="presentation" />;' },
     { code: '<canvas role="img" />;' },
     { code: '<Component role="presentation" />;' },
-  ]
+  ))
     .map(ruleOptionsMapperFactory(recommendedOptions))
     .map(parserOptionsMapper),
-  invalid: [
+  invalid: parsers.all([].concat(
     ...neverValid,
-  ]
+  ))
     .map(ruleOptionsMapperFactory(recommendedOptions))
     .map(parserOptionsMapper),
 });
 
 ruleTester.run(`${ruleName}:strict`, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     ...neverValid,
     { code: '<tr role="presentation" />;', errors: [expectedError] },
     { code: '<canvas role="img" />;', errors: [expectedError] },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/no-noninteractive-element-interactions-test.js b/__tests__/src/rules/no-noninteractive-element-interactions-test.js
index c74abae18..d13c136d7 100644
--- a/__tests__/src/rules/no-noninteractive-element-interactions-test.js
+++ b/__tests__/src/rules/no-noninteractive-element-interactions-test.js
@@ -10,6 +10,7 @@
 import { RuleTester } from 'eslint';
 import { configs } from '../../../src/index';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/no-noninteractive-element-interactions';
 import ruleOptionsMapperFactory from '../../__util__/ruleOptionsMapperFactory';
 
@@ -396,7 +397,7 @@ const neverValid = [
 
 const recommendedOptions = configs.recommended.rules[`jsx-a11y/${ruleName}`][1] || {};
 ruleTester.run(`${ruleName}:recommended`, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
     // All the possible handlers
     { code: '<div role="article" onCopy={() => {}} />;' },
@@ -459,24 +460,24 @@ ruleTester.run(`${ruleName}:recommended`, rule, {
     { code: '<div role="article" onAnimationEnd={() => {}} />;' },
     { code: '<div role="article" onAnimationIteration={() => {}} />;' },
     { code: '<div role="article" onTransitionEnd={() => {}} />;' },
-  ]
+  ))
     .map(ruleOptionsMapperFactory(recommendedOptions))
     .map(parserOptionsMapper),
-  invalid: [
+  invalid: parsers.all([].concat(
     ...neverValid,
-  ]
+  ))
     .map(ruleOptionsMapperFactory(recommendedOptions))
     .map(parserOptionsMapper),
 });
 
 const strictOptions = configs.strict.rules[`jsx-a11y/${ruleName}`][1] || {};
 ruleTester.run(`${ruleName}:strict`, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
-  ]
+  ))
     .map(ruleOptionsMapperFactory(strictOptions))
     .map(parserOptionsMapper),
-  invalid: [
+  invalid: parsers.all([].concat(
     ...neverValid,
     // All the possible handlers
     { code: '<div role="article" onFocus={() => {}} />;', errors: [expectedError] },
@@ -497,7 +498,7 @@ ruleTester.run(`${ruleName}:strict`, rule, {
     { code: '<div role="article" onMouseMove={() => {}} />;', errors: [expectedError] },
     { code: '<div role="article" onMouseOut={() => {}} />;', errors: [expectedError] },
     { code: '<div role="article" onMouseOver={() => {}} />;', errors: [expectedError] },
-  ]
+  ))
     .map(ruleOptionsMapperFactory(strictOptions))
     .map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/no-noninteractive-element-to-interactive-role-test.js b/__tests__/src/rules/no-noninteractive-element-to-interactive-role-test.js
index 2f25c95ab..da1f4f802 100644
--- a/__tests__/src/rules/no-noninteractive-element-to-interactive-role-test.js
+++ b/__tests__/src/rules/no-noninteractive-element-to-interactive-role-test.js
@@ -12,6 +12,7 @@
 import { RuleTester } from 'eslint';
 import { configs } from '../../../src/index';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/no-noninteractive-element-to-interactive-role';
 import ruleOptionsMapperFactory from '../../__util__/ruleOptionsMapperFactory';
 
@@ -440,7 +441,7 @@ const neverValid = [
 
 const recommendedOptions = (configs.recommended.rules[ruleName][1] || {});
 ruleTester.run(`${ruleName}:recommended`, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
     { code: '<ul role="menu" />;' },
     { code: '<ul role="menubar" />;' },
@@ -461,21 +462,21 @@ ruleTester.run(`${ruleName}:recommended`, rule, {
     { code: '<Component role="treeitem" />;' },
     { code: '<fieldset role="radiogroup" />;' },
     { code: '<fieldset role="presentation" />;' },
-  ]
+  ))
     .map(ruleOptionsMapperFactory(recommendedOptions))
     .map(parserOptionsMapper),
-  invalid: [
+  invalid: parsers.all([].concat(
     ...neverValid,
-  ]
+  ))
     .map(ruleOptionsMapperFactory(recommendedOptions))
     .map(parserOptionsMapper),
 });
 
 ruleTester.run(`${ruleName}:strict`, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     ...neverValid,
     { code: '<ul role="menu" />;', errors: [expectedError] },
     { code: '<ul role="menubar" />;', errors: [expectedError] },
@@ -493,5 +494,5 @@ ruleTester.run(`${ruleName}:strict`, rule, {
     { code: '<li role="menuitem" />;', errors: [expectedError] },
     { code: '<li role="row" />;', errors: [expectedError] },
     { code: '<li role="treeitem" />;', errors: [expectedError] },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/no-noninteractive-tabindex-test.js b/__tests__/src/rules/no-noninteractive-tabindex-test.js
index 2c8f1ac4b..c832f3778 100644
--- a/__tests__/src/rules/no-noninteractive-tabindex-test.js
+++ b/__tests__/src/rules/no-noninteractive-tabindex-test.js
@@ -10,6 +10,7 @@
 import { RuleTester } from 'eslint';
 import { configs } from '../../../src/index';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/no-noninteractive-tabindex';
 import ruleOptionsMapperFactory from '../../__util__/ruleOptionsMapperFactory';
 
@@ -62,7 +63,7 @@ const recommendedOptions = (
 );
 
 ruleTester.run(`${ruleName}:recommended`, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
     { code: '<div role="tabpanel" tabIndex="0" />' },
     // Expressions should pass in recommended mode
@@ -87,21 +88,21 @@ ruleTester.run(`${ruleName}:recommended`, rule, {
       options: [{ allowExpressionValues: true }],
       errors: [expectedError],
     },
-  ]
+  ))
     .map(ruleOptionsMapperFactory(recommendedOptions))
     .map(parserOptionsMapper),
-  invalid: [
+  invalid: parsers.all([].concat(
     ...neverValid,
-  ]
+  ))
     .map(ruleOptionsMapperFactory(recommendedOptions))
     .map(parserOptionsMapper),
 });
 
 ruleTester.run(`${ruleName}:strict`, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     ...neverValid,
     { code: '<div role="tabpanel" tabIndex="0" />', errors: [expectedError] },
     // Expressions should fail in strict mode
@@ -118,5 +119,5 @@ ruleTester.run(`${ruleName}:strict`, rule, {
       options: [{ allowExpressionValues: false }],
       errors: [expectedError],
     },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/no-onchange-test.js b/__tests__/src/rules/no-onchange-test.js
index a29170b81..f45734436 100644
--- a/__tests__/src/rules/no-onchange-test.js
+++ b/__tests__/src/rules/no-onchange-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/no-onchange';
 
 // -----------------------------------------------------------------------------
@@ -32,7 +33,7 @@ const componentsSettings = {
 };
 
 ruleTester.run('no-onchange', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<select onBlur={() => {}} />;' },
     { code: '<select onBlur={handleOnBlur} />;' },
     { code: '<option />;' },
@@ -45,12 +46,12 @@ ruleTester.run('no-onchange', rule, {
     { code: '<input {...props} />' },
     { code: '<Input onChange={() => {}} />;', settings: componentsSettings },
     { code: '<CustomOption onChange={() => {}} />' },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<select onChange={() => {}} />;', errors: [expectedError] },
     { code: '<select onChange={handleOnChange} />;', errors: [expectedError] },
     { code: '<option onChange={() => {}} />', errors: [expectedError] },
     { code: '<option onChange={() => {}} {...props} />', errors: [expectedError] },
     { code: '<CustomOption onChange={() => {}} />;', errors: [expectedError], settings: componentsSettings },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/no-redundant-roles-test.js b/__tests__/src/rules/no-redundant-roles-test.js
index 786bdf858..60cc2185e 100644
--- a/__tests__/src/rules/no-redundant-roles-test.js
+++ b/__tests__/src/rules/no-redundant-roles-test.js
@@ -10,6 +10,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/no-redundant-roles';
 import ruleOptionsMapperFactory from '../../__util__/ruleOptionsMapperFactory';
 
@@ -49,12 +50,14 @@ const neverValid = [
 ];
 
 ruleTester.run(`${ruleName}:recommended`, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     ...alwaysValid,
     { code: '<nav role="navigation" />' },
-  ]
+  ))
     .map(parserOptionsMapper),
-  invalid: neverValid
+  invalid: parsers.all([].concat(
+    neverValid,
+  ))
     .map(parserOptionsMapper),
 });
 
@@ -62,28 +65,30 @@ const noNavExceptionsOptions = { nav: [] };
 const listException = { ul: ['list'], ol: ['list'] };
 
 ruleTester.run(`${ruleName}:recommended`, rule, {
-  valid: alwaysValid
-    .map(ruleOptionsMapperFactory(noNavExceptionsOptions))
+  valid: parsers.all([].concat(
+    alwaysValid
+      .map(ruleOptionsMapperFactory(noNavExceptionsOptions)),
+  ))
     .map(parserOptionsMapper),
-  invalid: [
+  invalid: parsers.all([].concat(
     ...neverValid,
     { code: '<nav role="navigation" />', errors: [expectedError('nav', 'navigation')] },
-  ]
+  ))
     .map(ruleOptionsMapperFactory(noNavExceptionsOptions))
     .map(parserOptionsMapper),
 });
 
 ruleTester.run(`${ruleName}:recommended (valid list role override)`, rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<ul role="list" />' },
     { code: '<ol role="list" />' },
     { code: '<dl role="list" />' },
-  ]
+  ))
     .map(ruleOptionsMapperFactory(listException))
     .map(parserOptionsMapper),
-  invalid: [
+  invalid: parsers.all([].concat(
     { code: '<ul role="list" />', errors: [expectedError('ul', 'list')] },
     { code: '<ol role="list" />', errors: [expectedError('ol', 'list')] },
-  ]
+  ))
     .map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/no-static-element-interactions-test.js b/__tests__/src/rules/no-static-element-interactions-test.js
index e9d581e4c..6b0c05974 100644
--- a/__tests__/src/rules/no-static-element-interactions-test.js
+++ b/__tests__/src/rules/no-static-element-interactions-test.js
@@ -10,6 +10,7 @@
 import { RuleTester } from 'eslint';
 import { configs } from '../../../src/index';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/no-static-element-interactions';
 import ruleOptionsMapperFactory from '../../__util__/ruleOptionsMapperFactory';
 
@@ -360,7 +361,7 @@ const neverValid = [
 
 const recommendedOptions = configs.recommended.rules[`jsx-a11y/${ruleName}`][1] || {};
 ruleTester.run(`${ruleName}:recommended`, rule, {
-  valid: [].concat(
+  valid: parsers.all([].concat(
     alwaysValid,
     // All the possible handlers
     { code: '<div onCopy={() => {}} />;' },
@@ -449,21 +450,21 @@ ruleTester.run(`${ruleName}:recommended`, rule, {
       options: [{ allowExpressionValues: true }],
       errors: [expectedError],
     },
-  )
+  ))
     .map(ruleOptionsMapperFactory(recommendedOptions))
     .map(parserOptionsMapper),
-  invalid: [].concat(
+  invalid: parsers.all([].concat(
     neverValid,
-  )
+  ))
     .map(ruleOptionsMapperFactory(recommendedOptions))
     .map(parserOptionsMapper),
 });
 
 ruleTester.run(`${ruleName}:strict`, rule, {
-  valid: [].concat(
+  valid: parsers.all([].concat(
     alwaysValid,
-  ).map(parserOptionsMapper),
-  invalid: [].concat(
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     neverValid,
     // All the possible handlers
     { code: '<div onContextMenu={() => {}} />;', errors: [expectedError] },
@@ -497,5 +498,5 @@ ruleTester.run(`${ruleName}:strict`, rule, {
       options: [{ allowExpressionValues: false }],
       errors: [expectedError],
     },
-  ).map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/prefer-tag-over-role-test.js b/__tests__/src/rules/prefer-tag-over-role-test.js
index a130c53e8..3dfafcab5 100644
--- a/__tests__/src/rules/prefer-tag-over-role-test.js
+++ b/__tests__/src/rules/prefer-tag-over-role-test.js
@@ -1,5 +1,6 @@
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/prefer-tag-over-role';
 
 const ruleTester = new RuleTester();
@@ -10,15 +11,15 @@ const expectedError = (role, tag) => ({
 });
 
 ruleTester.run('element-role', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<div />;' },
     { code: '<div role="unknown" />;' },
     { code: '<div role="also unknown" />;' },
     { code: '<other />' },
     { code: '<img role="img" />' },
     { code: '<input role="checkbox" />' },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     {
       code: '<div role="checkbox" />',
       errors: [expectedError('checkbox', '<input type="checkbox">')],
@@ -62,5 +63,5 @@ ruleTester.run('element-role', rule, {
       code: '<div role="banner" />',
       errors: [expectedError('banner', '<header>')],
     },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/role-has-required-aria-props-test.js b/__tests__/src/rules/role-has-required-aria-props-test.js
index 360b76e9e..5a06a3f62 100644
--- a/__tests__/src/rules/role-has-required-aria-props-test.js
+++ b/__tests__/src/rules/role-has-required-aria-props-test.js
@@ -11,6 +11,7 @@
 import { roles } from 'aria-query';
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/role-has-required-aria-props';
 
 // -----------------------------------------------------------------------------
@@ -50,7 +51,7 @@ const basicValidityTests = [...roles.keys()].map((role) => {
 });
 
 ruleTester.run('role-has-required-aria-props', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<Bar baz />' },
     { code: '<MyComponent role="combobox" />' },
     // Variables should pass, as we are only testing literals.
@@ -64,9 +65,9 @@ ruleTester.run('role-has-required-aria-props', rule, {
     { code: '<input role="checkbox" aria-checked="false" aria-labelledby="foo" tabindex="0" {...props} type="checkbox" />' },
     { code: '<input type="checkbox" role="switch" />' },
     { code: '<MyComponent role="checkbox" aria-checked="false" aria-labelledby="foo" tabindex="0" />', settings: componentsSettings },
-  ].concat(basicValidityTests).map(parserOptionsMapper),
+  )).concat(basicValidityTests).map(parserOptionsMapper),
 
-  invalid: [
+  invalid: parsers.all([].concat(
     // SLIDER
     { code: '<div role="slider" />', errors: [errorMessage('slider')] },
     {
@@ -126,5 +127,5 @@ ruleTester.run('role-has-required-aria-props', rule, {
     },
     // Custom element
     { code: '<MyComponent role="combobox" />', settings: componentsSettings, errors: [errorMessage('combobox')] },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/role-supports-aria-props-test.js b/__tests__/src/rules/role-supports-aria-props-test.js
index 5aa8019d8..888ff0732 100644
--- a/__tests__/src/rules/role-supports-aria-props-test.js
+++ b/__tests__/src/rules/role-supports-aria-props-test.js
@@ -15,6 +15,7 @@ import { RuleTester } from 'eslint';
 import { version as eslintVersion } from 'eslint/package.json';
 import semver from 'semver';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/role-supports-aria-props';
 
 // -----------------------------------------------------------------------------
@@ -74,7 +75,7 @@ const createTests = (rolesNames) => rolesNames.reduce((tests, role) => {
 const [validTests, invalidTests] = createTests(nonAbstractRoles);
 
 ruleTester.run('role-supports-aria-props', rule, {
-  valid: [].concat(
+  valid: parsers.all([].concat(
     { code: '<Foo bar />' },
     { code: '<div />' },
     { code: '<div id="main" />' },
@@ -415,9 +416,9 @@ ruleTester.run('role-supports-aria-props', rule, {
       `,
     } : [],
     validTests,
-  ).map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 
-  invalid: [
+  invalid: parsers.all([].concat(
     // implicit basic checks
     {
       code: '<a href="#" aria-checked />',
@@ -568,5 +569,5 @@ ruleTester.run('role-supports-aria-props', rule, {
       errors: [errorMessage('aria-checked', 'link', 'a', true)],
       settings: componentsSettings,
     },
-  ].concat(invalidTests).map(parserOptionsMapper),
+  )).concat(invalidTests).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/scope-test.js b/__tests__/src/rules/scope-test.js
index 421118dc2..33930fd99 100644
--- a/__tests__/src/rules/scope-test.js
+++ b/__tests__/src/rules/scope-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/scope';
 
 // -----------------------------------------------------------------------------
@@ -32,7 +33,7 @@ const componentsSettings = {
 };
 
 ruleTester.run('scope', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<div />;' },
     { code: '<div foo />;' },
     { code: '<th scope />' },
@@ -41,9 +42,9 @@ ruleTester.run('scope', rule, {
     { code: '<th scope={"col"} {...props} />' },
     { code: '<Foo scope="bar" {...props} />' },
     { code: '<TableHeader scope="row" />', settings: componentsSettings },
-  ].map(parserOptionsMapper),
-  invalid: [
+  )).map(parserOptionsMapper),
+  invalid: parsers.all([].concat(
     { code: '<div scope />', errors: [expectedError] },
     { code: '<Foo scope="bar" />', settings: componentsSettings, errors: [expectedError] },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/__tests__/src/rules/tabindex-no-positive-test.js b/__tests__/src/rules/tabindex-no-positive-test.js
index 13b1962bf..e654ca013 100644
--- a/__tests__/src/rules/tabindex-no-positive-test.js
+++ b/__tests__/src/rules/tabindex-no-positive-test.js
@@ -9,6 +9,7 @@
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/tabindex-no-positive';
 
 // -----------------------------------------------------------------------------
@@ -23,7 +24,7 @@ const expectedError = {
 };
 
 ruleTester.run('tabindex-no-positive', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<div />;' },
     { code: '<div {...props} />' },
     { code: '<div id="main" />' },
@@ -42,13 +43,13 @@ ruleTester.run('tabindex-no-positive', rule, {
     { code: '<div tabIndex="-5.5" />' },
     { code: '<div tabIndex={-5.5} />' },
     { code: '<div tabIndex={-5} />' },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 
-  invalid: [
+  invalid: parsers.all([].concat(
     { code: '<div tabIndex="1" />', errors: [expectedError] },
     { code: '<div tabIndex={1} />', errors: [expectedError] },
     { code: '<div tabIndex={"1"} />', errors: [expectedError] },
     { code: '<div tabIndex={`1`} />', errors: [expectedError] },
     { code: '<div tabIndex={1.589} />', errors: [expectedError] },
-  ].map(parserOptionsMapper),
+  )).map(parserOptionsMapper),
 });
diff --git a/scripts/boilerplate/test.js b/scripts/boilerplate/test.js
index 46f220d57..c2c9630e5 100644
--- a/scripts/boilerplate/test.js
+++ b/scripts/boilerplate/test.js
@@ -10,6 +10,7 @@ const testBoilerplate = (name, author, description) => `/* eslint-env jest */
 
 import { RuleTester } from 'eslint';
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
+import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/${name}';
 
 // -----------------------------------------------------------------------------
@@ -24,10 +25,12 @@ const expectedError = {
 };
 
 ruleTester.run('${name}', rule, {
-  valid: [
+  valid: parsers.all([].concat(
     { code: '<div />;' },
-  ].map(parserOptionsMapper),
-  invalid: [].map(parserOptionsMapper),
+  ].map(parserOptionsMapper))),
+  invalid: parsers.all([].concat(
+    
+  ).map(parserOptionsMapper)),
 });
 `;