diff --git a/.changeset/brave-lists-gather.md b/.changeset/brave-lists-gather.md
new file mode 100644
index 0000000000..dcdfe1bcf6
--- /dev/null
+++ b/.changeset/brave-lists-gather.md
@@ -0,0 +1,29 @@
+---
+"@siteimprove/alfa-rules": minor
+---
+
+**Added:** A new experimental rule SIA-R121 is available. It checks that `<ul>`, `<ol>` and `<dl>` elements only contain the children allowed by the HTML content model.
+
+The rule follows the content model as the HTML specification states it, rather than a relaxed reading of it:
+
+- A `<dl>` either wraps every name-value group in a `<div>` or wraps none of them. The two forms cannot be mixed in one list.
+- A `<div>` inside a `<dl>` holds exactly one group. Its content model is one or more `<dt>` elements followed by one or more `<dd>` elements, so packing a second group into the same wrapper is reported and each group needs its own.
+- Every group must be well formed, not only the first, so a trailing `<dt>` with no `<dd>` of its own is reported.
+- Children are matched by element name rather than by role, so a `<div role="listitem">` does not satisfy a content model asking for an `<li>`. See the [`listitem` role best practices](https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Reference/Roles/listitem_role#best_practices). Pasting the following into <https://validator.w3.org/nu> reports `Element "div" not allowed as child of element "ul" in this context`:
+
+  ```html
+  <!DOCTYPE html>
+  <html lang="en">
+    <head>
+      <meta charset="utf-8" />
+      <title>List content model check</title>
+    </head>
+    <body>
+      <ul>
+        <div role="listitem">List item 1</div>
+        <div role="listitem">List item 2</div>
+      </ul>
+    </body>
+  </html>
+  ```
+  
diff --git a/.changeset/lucky-keys-listen.md b/.changeset/lucky-keys-listen.md
new file mode 100644
index 0000000000..74d6f0ccbd
--- /dev/null
+++ b/.changeset/lucky-keys-listen.md
@@ -0,0 +1,11 @@
+---
+"@siteimprove/alfa-rules": minor
+---
+
+**Added:** A new experimental rule SIA-R122 is available. It checks that the access keys an element declares are usable.
+
+It makes three checks. No other element may declare the same key, since two elements competing for one key means at most one of them can be reached and which one wins is left to the user agent. Each key must be a single character, since anything longer is not a key a user can press. And an element may not declare the same key twice.
+
+Case is folded throughout, so `A` and `a` are the same key. Two elements declaring them compete, and `accesskey="a A"` on one element declares that key twice and is reported for the repeat. That is stricter than the W3C checker, which compares the tokens of a single value literally and accepts it.
+
+The attribute holds a set of space-separated tokens, so `accesskey="a b"` declares two keys and each is checked separately.
diff --git a/docs/review/api/alfa-rules.api.md b/docs/review/api/alfa-rules.api.md
index fd61503c0f..f4a989046e 100644
--- a/docs/review/api/alfa-rules.api.md
+++ b/docs/review/api/alfa-rules.api.md
@@ -71,20 +71,26 @@ const _default: Rule.Atomic<Page, Element_2<string>, {}, Element_2<string>>;
 // @public
 const _default_10: Rule.Atomic<Page, Element_2<string>, Question.Metadata, Element_2<string>>;
 
-// @public @deprecated (undocumented)
+// @public
 const _default_11: Rule.Atomic<Page, Element_2<string>, {}, Element_2<string>>;
 
-// @public @deprecated (undocumented)
+// @public
 const _default_12: Rule.Atomic<Page, Element_2<string>, {}, Element_2<string>>;
 
 // @public @deprecated (undocumented)
-const _default_13: Rule.Atomic<Page, Element_2<string>, Question.Metadata, Element_2<string>>;
+const _default_13: Rule.Atomic<Page, Element_2<string>, {}, Element_2<string>>;
+
+// @public @deprecated (undocumented)
+const _default_14: Rule.Atomic<Page, Element_2<string>, {}, Element_2<string>>;
+
+// @public @deprecated (undocumented)
+const _default_15: Rule.Atomic<Page, Element_2<string>, Question.Metadata, Element_2<string>>;
 
 // @public @deprecated (undocumented)
-const _default_14: Rule.Atomic<Page, Element_2<string>, Question.Metadata, Element_2<string>>;
+const _default_16: Rule.Atomic<Page, Element_2<string>, Question.Metadata, Element_2<string>>;
 
 // @public @deprecated (undocumented)
-const _default_15: Rule.Atomic<Page, Text_2, {}, Text_2>;
+const _default_17: Rule.Atomic<Page, Text_2, {}, Text_2>;
 
 // @public
 const _default_2: Rule.Atomic<Page, Document_2, Question.Metadata, Element_2<string>>;
@@ -112,11 +118,11 @@ const _default_9: Rule.Atomic<Page, Element_2<string>, Question.Metadata, Elemen
 
 declare namespace deprecatedRules {
     export {
-        _default_11 as DR3,
-        _default_12 as DR6,
-        _default_13 as DR34,
-        _default_14 as DR36,
-        _default_15 as DR83
+        _default_13 as DR3,
+        _default_14 as DR6,
+        _default_15 as DR34,
+        _default_16 as DR36,
+        _default_17 as DR83
     }
 }
 export { deprecatedRules }
@@ -156,7 +162,9 @@ declare namespace experimentalRules {
         _default_7 as R114,
         _default_8 as R115,
         _default_9 as R117,
-        _default_10 as R118
+        _default_10 as R118,
+        _default_11 as R121,
+        _default_12 as R122
     }
 }
 export { experimentalRules }
diff --git a/packages/alfa-rules/src/experimental.ts b/packages/alfa-rules/src/experimental.ts
index f1b4062fcf..d1e3fd427f 100755
--- a/packages/alfa-rules/src/experimental.ts
+++ b/packages/alfa-rules/src/experimental.ts
@@ -9,5 +9,20 @@ import R114 from "./sia-r114/rule.ts";
 import R115 from "./sia-r115/rule.ts";
 import R117 from "./sia-r117/rule.ts";
 import R118 from "./sia-r118/rule.ts";
+import R121 from "./sia-r121/rule.ts";
+import R122 from "./sia-r122/rule.ts";
 
-export { ER8, ER87, R82, R98, R101, R109, R114, R115, R117, R118 };
\ No newline at end of file
+export {
+  ER8,
+  ER87,
+  R82,
+  R98,
+  R101,
+  R109,
+  R114,
+  R115,
+  R117,
+  R118,
+  R121,
+  R122,
+};
diff --git a/packages/alfa-rules/src/sia-r121/rule.ts b/packages/alfa-rules/src/sia-r121/rule.ts
new file mode 100644
index 0000000000..70df51f90c
--- /dev/null
+++ b/packages/alfa-rules/src/sia-r121/rule.ts
@@ -0,0 +1,230 @@
+import { Diagnostic, Rule } from "@siteimprove/alfa-act";
+import {
+  Element,
+  Namespace,
+  Node,
+  Query,
+  Shadow,
+  Text,
+} from "@siteimprove/alfa-dom";
+import { EAA } from "@siteimprove/alfa-eaa";
+import { Refinement } from "@siteimprove/alfa-refinement";
+import type { Result } from "@siteimprove/alfa-result";
+import { Err, Ok } from "@siteimprove/alfa-result";
+import type { Sequence } from "@siteimprove/alfa-sequence";
+import { String } from "@siteimprove/alfa-string";
+import { Style } from "@siteimprove/alfa-style";
+import { Criterion, Technique } from "@siteimprove/alfa-wcag";
+import type { Page } from "@siteimprove/alfa-web";
+
+import { expectation } from "../common/act/index.ts";
+import { WithBadElements } from "../common/diagnostic/with-bad-elements.ts";
+
+import { Scope, Stability } from "../tags/index.ts";
+
+const { hasName, hasNamespace, isElement, isSlot } = Element;
+const { and } = Refinement;
+const { isRendered } = Style;
+const { isText } = Text;
+const { getElementDescendants } = Query;
+
+/**
+ * This rule checks that `<ul>`, `<ol>` and `<dl>` elements only contain the
+ * children the HTML content model allows.
+ *
+ * Four readings of that content model are deliberate, and each one makes the
+ * rule stricter than a relaxed reading would:
+ *
+ * - A `<dl>` wraps every name-value group in a `<div>` or wraps none of them.
+ * - A `<div>` inside a `<dl>` holds exactly one group, so a second group packed
+ *   into the same wrapper is reported.
+ * - Every group must be well formed, not only the first, so a trailing `<dt>`
+ *   with no `<dd>` is reported.
+ * - Children are matched by element name, so a `<div role="listitem">` does not
+ *   satisfy a content model asking for an `<li>`.
+ *
+ * {@link https://html.spec.whatwg.org/multipage/grouping-content.html#the-dl-element}
+ */
+export default Rule.Atomic.of<Page, Element>({
+  uri: "https://alfa.siteimprove.com/rules/sia-r121",
+  requirements: [
+    Criterion.of("1.3.1"),
+    EAA.of("9.1.3.1"),
+    Technique.of("H40"),
+    Technique.of("H48"),
+  ],
+  tags: [Scope.Component, Stability.Experimental],
+  evaluate({ device, document }) {
+    return {
+      applicability() {
+        return getElementDescendants(document, Node.fullTree).filter(
+          and(
+            hasNamespace(Namespace.HTML),
+            and(hasName("ul", "ol", "dl"), isRendered(device)),
+          ),
+        );
+      },
+
+      expectations(target) {
+        return {
+          1: expectation(
+            hasTextContent(target),
+            () => Outcomes.HasDisallowedText,
+            () =>
+              expectation(
+                hasName("dl")(target),
+                () => descriptionListContent(target),
+                () => listContent(target),
+              ),
+          ),
+        };
+      },
+    };
+  },
+});
+
+function hasHtmlName<N extends string>(name: N, ...rest: Array<N>) {
+  return and(hasNamespace(Namespace.HTML), hasName(name, ...rest));
+}
+
+const isScriptSupporting = hasHtmlName("script", "template");
+
+// A <slot> only slots inside a shadow tree. Anywhere else no assignment
+// algorithm reaches it, so it is an inert element in a position the content
+// model forbids. The flat tree replaces it with nothing, which is why this is
+// the one check that has to read the node tree.
+function straySlots(element: Element): Sequence<Element> {
+  return element
+    .children()
+    .filter(isElement)
+    .filter(isSlot)
+    .reject((slot) => Shadow.isShadow(slot.root()));
+}
+
+function elementChildren(element: Element): Sequence<Element> {
+  return element
+    .children(Node.fullTree)
+    .filter(isElement)
+    .reject(isScriptSupporting);
+}
+
+function hasTextContent(element: Element): boolean {
+  return element
+    .children(Node.fullTree)
+    .filter(isText)
+    .some((text) => !String.isWhitespace(text.data));
+}
+
+function listContent(target: Element): Result<Diagnostic> {
+  const disallowed = elementChildren(target)
+    .reject(hasHtmlName("li"))
+    .concat(straySlots(target));
+
+  return disallowed.isEmpty()
+    ? Outcomes.HasValidContent
+    : Outcomes.HasDisallowedElements(disallowed);
+}
+
+function descriptionListContent(target: Element): Result<Diagnostic> {
+  const children = elementChildren(target);
+  const disallowed = children
+    .reject(hasHtmlName("div", "dt", "dd"))
+    .concat(straySlots(target));
+
+  if (!disallowed.isEmpty()) {
+    return Outcomes.HasDisallowedElements(disallowed);
+  }
+
+  const wrappers = children.filter(hasName("div"));
+  const items = children.filter(hasName("dt", "dd"));
+
+  if (!wrappers.isEmpty()) {
+    if (!items.isEmpty()) {
+      return Outcomes.HasMixedGroups(items);
+    }
+
+    const malformed = wrappers.reject(isWellFormedGroup);
+
+    return malformed.isEmpty()
+      ? Outcomes.HasValidContent
+      : Outcomes.HasMalformedGroups(malformed);
+  }
+
+  const ungrouped = ungroupedItems(items);
+
+  return ungrouped.isEmpty()
+    ? Outcomes.HasValidContent
+    : Outcomes.HasMalformedGroups(ungrouped);
+}
+
+function isWellFormedGroup(wrapper: Element): boolean {
+  if (hasTextContent(wrapper)) {
+    return false;
+  }
+
+  const children = elementChildren(wrapper);
+
+  if (
+    !children.reject(hasHtmlName("dt", "dd")).isEmpty() ||
+    !straySlots(wrapper).isEmpty()
+  ) {
+    return false;
+  }
+
+  const terms = children.takeWhile(hasName("dt"));
+  const descriptions = children.skip(terms.size);
+
+  return (
+    !terms.isEmpty() &&
+    !descriptions.isEmpty() &&
+    descriptions.every(hasName("dd"))
+  );
+}
+
+function ungroupedItems(items: Sequence<Element>): Sequence<Element> {
+  const leadingDescriptions: Sequence<Element> = items.takeWhile(hasName("dd"));
+  const trailingTerms = items.takeLastWhile(hasName("dt"));
+
+  return leadingDescriptions.concat(trailingTerms);
+}
+
+/**
+ * @public
+ */
+export namespace Outcomes {
+  export const HasValidContent = Ok.of(
+    Diagnostic.of(
+      `The element only contains the content allowed by its content model.`,
+    ),
+  );
+
+  export const HasDisallowedText = Err.of(
+    Diagnostic.of(
+      `The element contains text that its content model does not allow.`,
+    ),
+  );
+
+  export const HasDisallowedElements = (errors: Iterable<Element>) =>
+    Err.of(
+      WithBadElements.of(
+        `The element contains child elements that its content model does not allow.`,
+        errors,
+      ),
+    );
+
+  export const HasMixedGroups = (errors: Iterable<Element>) =>
+    Err.of(
+      WithBadElements.of(
+        `The <dl> element mixes name-value groups wrapped in a <div> with groups that are not wrapped.`,
+        errors,
+      ),
+    );
+
+  export const HasMalformedGroups = (errors: Iterable<Element>) =>
+    Err.of(
+      WithBadElements.of(
+        `The <dl> element contains a name-value group that is not one or more <dt> elements followed by one or more <dd> elements.`,
+        errors,
+      ),
+    );
+}
diff --git a/packages/alfa-rules/src/sia-r122/rule.ts b/packages/alfa-rules/src/sia-r122/rule.ts
new file mode 100644
index 0000000000..65b10aa09f
--- /dev/null
+++ b/packages/alfa-rules/src/sia-r122/rule.ts
@@ -0,0 +1,178 @@
+import { Diagnostic, Rule } from "@siteimprove/alfa-act";
+import { Element, Namespace, Node, Query } from "@siteimprove/alfa-dom";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Err, Ok } from "@siteimprove/alfa-result";
+import { Sequence } from "@siteimprove/alfa-sequence";
+import { Style } from "@siteimprove/alfa-style";
+import type { Page } from "@siteimprove/alfa-web";
+
+import { expectation } from "../common/act/index.ts";
+import { BestPractice } from "../requirements/index.ts";
+
+import { Scope, Stability } from "../tags/index.ts";
+
+const { hasNamespace } = Element;
+const { and } = Predicate;
+const { isRendered } = Style;
+const { getElementDescendants } = Query;
+
+/**
+ * This rule checks that the access keys an element declares are usable: that no
+ * other element declares the same key, that each key is a single character, and
+ * that the element does not declare the same key twice.
+ *
+ * Two elements competing for one key means at most one of them can be reached
+ * by it, and which one wins is left to the user agent.
+ *
+ * Case is folded throughout, since `A` and `a` reach the same physical key, so
+ * `accesskey="a A"` declares one key twice and is reported for the repeat. That
+ * is stricter than the specification, which asks only that the tokens not be
+ * "identical to another token", a literal comparison the W3C checker
+ * implements with a case-sensitive equality.
+ *
+ * Elements that are not rendered are left out, since their access keys cannot
+ * be activated, and a key declared only on such an element competes with
+ * nothing.
+ *
+ * {@link https://html.spec.whatwg.org/multipage/interaction.html#the-accesskey-attribute}
+ */
+export default Rule.Atomic.of<Page, Element>({
+  uri: "https://alfa.siteimprove.com/rules/sia-r122",
+  requirements: [BestPractice.of("accesskey-unique")],
+  tags: [Scope.Page, Stability.Experimental],
+  evaluate({ device, document }) {
+    const elements = getElementDescendants(document, Node.fullTree)
+      .filter(and(hasNamespace(Namespace.HTML), declaresAccesskey))
+      .filter(isRendered(device));
+
+    const accessKeyElementPairs = new Map<string, Array<Element>>();
+
+    for (const element of elements) {
+      for (const key of accesskeys(element)) {
+        const elementsForKey = accessKeyElementPairs.get(key) ?? [];
+
+        elementsForKey.push(element);
+        accessKeyElementPairs.set(key, elementsForKey);
+      }
+    }
+
+    return {
+      applicability() {
+        return elements;
+      },
+
+      expectations(target) {
+        const contested = accesskeys(target).filter(
+          (key) => (accessKeyElementPairs.get(key)?.length ?? 0) > 1,
+        );
+        const tooLong = tokens(target).reject((token) => token.length === 1);
+
+        const duplicated = repeatedTokens(target);
+
+        return {
+          1: expectation(
+            contested.isEmpty(),
+            () => Outcomes.HasUniqueAccesskeys,
+            () => Outcomes.HasNonUniqueAccesskeys(contested),
+          ),
+          2: expectation(
+            tooLong.isEmpty(),
+            () => Outcomes.HasSingleCharacterAccesskeys,
+            () => Outcomes.HasMultiCharacterAccesskeys(tooLong),
+          ),
+          3: expectation(
+            duplicated.isEmpty(),
+            () => Outcomes.HasDistinctAccesskeys,
+            () => Outcomes.HasRepeatedAccesskeys(duplicated),
+          ),
+        };
+      },
+    };
+  },
+});
+
+function tokens(element: Element): Sequence<string> {
+  return Sequence.from(element.attribute("accesskey")).flatMap((attribute) =>
+    attribute.tokens(),
+  );
+}
+
+function accesskeys(element: Element): Sequence<string> {
+  return tokens(element)
+    .map((token) => token.toLowerCase())
+    .distinct();
+}
+
+function repeatedTokens(element: Element): Sequence<string> {
+  const seen = new Set<string>();
+  const repeated = new Set<string>();
+
+  for (const token of tokens(element).map((token) => token.toLowerCase())) {
+    if (seen.has(token)) {
+      repeated.add(token);
+    } else {
+      seen.add(token);
+    }
+  }
+
+  return Sequence.from(repeated);
+}
+
+const declaresAccesskey: Predicate<Element> = (element) =>
+  !tokens(element).isEmpty();
+
+/**
+ * @public
+ */
+export namespace Outcomes {
+  export const HasUniqueAccesskeys = Ok.of(
+    Diagnostic.of(
+      `No access key of the element is declared by another element.`,
+    ),
+  );
+
+  export const HasNonUniqueAccesskeys = (keys: Iterable<string>) =>
+    Err.of(
+      Diagnostic.of(
+        many(keys)
+          ? `More than one element declares the access keys ${list(keys)}.`
+          : `More than one element declares the access key ${list(keys)}.`,
+      ),
+    );
+
+  export const HasSingleCharacterAccesskeys = Ok.of(
+    Diagnostic.of(`Every access key of the element is a single character.`),
+  );
+
+  export const HasMultiCharacterAccesskeys = (keys: Iterable<string>) =>
+    Err.of(
+      Diagnostic.of(
+        many(keys)
+          ? `The access keys ${list(keys)} are not single characters.`
+          : `The access key ${list(keys)} is not a single character.`,
+      ),
+    );
+
+  export const HasDistinctAccesskeys = Ok.of(
+    Diagnostic.of(`The element declares each of its access keys once.`),
+  );
+
+  export const HasRepeatedAccesskeys = (keys: Iterable<string>) =>
+    Err.of(
+      Diagnostic.of(
+        many(keys)
+          ? `The element declares the access keys ${list(keys)} more than once.`
+          : `The element declares the access key ${list(keys)} more than once.`,
+      ),
+    );
+}
+
+function list(keys: Iterable<string>): string {
+  return Sequence.from(keys)
+    .map((key) => `"${key}"`)
+    .join(", ");
+}
+
+function many(keys: Iterable<string>): boolean {
+  return Sequence.from(keys).size > 1;
+}
diff --git a/packages/alfa-rules/src/tsconfig.json b/packages/alfa-rules/src/tsconfig.json
index ba0cf4a786..4d6f8e10fb 100644
--- a/packages/alfa-rules/src/tsconfig.json
+++ b/packages/alfa-rules/src/tsconfig.json
@@ -165,6 +165,8 @@
     "./sia-r116/rule.ts",
     "./sia-r117/rule.ts",
     "./sia-r118/rule.ts",
+    "./sia-r121/rule.ts",
+    "./sia-r122/rule.ts",
     "./tags/index.ts",
     "./tags/stability.ts",
     "./tags/scope.ts",
diff --git a/packages/alfa-rules/test/sia-r121/rule.spec.tsx b/packages/alfa-rules/test/sia-r121/rule.spec.tsx
new file mode 100644
index 0000000000..e098c91e16
--- /dev/null
+++ b/packages/alfa-rules/test/sia-r121/rule.spec.tsx
@@ -0,0 +1,620 @@
+import { h, Namespace } from "@siteimprove/alfa-dom";
+import { test } from "@siteimprove/alfa-test";
+
+import R121, { Outcomes } from "../../src/sia-r121/rule.ts";
+
+import { evaluate } from "../common/evaluate.ts";
+import { failed, inapplicable, passed } from "../common/outcome.ts";
+
+/* <ul> and <ol> */
+
+test(`evaluate() passes a <ul> whose children are all <li>`, async (t) => {
+  const target = (
+    <ul>
+      <li>Foo</li>
+      <li>Bar</li>
+    </ul>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes an <ol> that intermixes script-supporting elements`, async (t) => {
+  const target = (
+    <ol>
+      <script>{"const foo = 1;"}</script>
+      <li>Foo</li>
+      <template></template>
+    </ol>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes an empty <ul>`, async (t) => {
+  const target = <ul></ul>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() fails a <ul> with a <div> child`, async (t) => {
+  const error = <div>Foo</div>;
+
+  const target = <ul>{error}</ul>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
+      1: Outcomes.HasDisallowedElements([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <ul> containing text outside of a list item`, async (t) => {
+  const target = (
+    <ul>
+      Foo
+      <li>Bar</li>
+    </ul>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, { 1: Outcomes.HasDisallowedText }),
+  ]);
+});
+
+test(`evaluate() fails a <ul> whose items carry the listitem role without being <li>`, async (t) => {
+  const error = <div role="listitem">Foo</div>;
+
+  const target = <ul role="list">{error}</ul>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
+      1: Outcomes.HasDisallowedElements([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <ul> with an SVG-namespaced <li> child`, async (t) => {
+  // Content models are written in terms of HTML elements, so sharing a local
+  // name is not enough. No HTML syntax produces this; it has to be built with
+  // createElementNS or moved out of an inline SVG.
+  const error = h.element("li", [], ["Foo"], [], Namespace.SVG);
+
+  const target = <ul>{error}</ul>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
+      1: Outcomes.HasDisallowedElements([error]),
+    }),
+  ]);
+});
+
+/*
+ * Children are read from the flat tree, so a slot is replaced by whatever is
+ * assigned to it. The first two cases below are the benefit: a list assembled by
+ * a web component passes, and text slotted into one is still reported as text
+ * outside a list item rather than being blamed on the slot.
+ *
+ * The third case is the one the flat tree cannot see on its own. A slot outside
+ * any shadow tree is never assigned anything, so flattening replaces it with
+ * nothing and the list looks empty. `straySlots` reads the node tree for exactly
+ * that case, which is why it is reported without the first two being affected.
+ */
+
+test(`evaluate() passes a list whose items are slotted in from light DOM`, async (t) => {
+  const target = (
+    <ul>
+      <slot></slot>
+    </ul>
+  );
+
+  const document = h.document([
+    h.element("my-list", [], [h.shadow([target]), <li>One</li>, <li>Two</li>]),
+  ]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() fails a list with a stray <slot> outside any shadow tree`, async (t) => {
+  const error = <slot></slot>;
+
+  const target = <ul>{error}</ul>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
+      1: Outcomes.HasDisallowedElements([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a list with a stray <slot> beside a valid item`, async (t) => {
+  const error = <slot></slot>;
+
+  const target = (
+    <ul>
+      {error}
+      <li>One</li>
+    </ul>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
+      1: Outcomes.HasDisallowedElements([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() passes an unassigned <slot> inside a shadow tree`, async (t) => {
+  const target = (
+    <ul>
+      <slot></slot>
+    </ul>
+  );
+
+  const document = h.document([h.element("my-list", [], [h.shadow([target])])]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() fails a list containing text slotted in from light DOM`, async (t) => {
+  const target = (
+    <ul>
+      <slot></slot>
+    </ul>
+  );
+
+  const document = h.document([
+    h.element("my-list", [], [h.shadow([target]), "Loose text", <li>One</li>]),
+  ]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, { 1: Outcomes.HasDisallowedText }),
+  ]);
+});
+
+/* <dl> with groups written out directly */
+
+test(`evaluate() passes a <dl> with a single name-value group`, async (t) => {
+  const target = (
+    <dl>
+      <dt>Foo</dt>
+      <dd>Bar</dd>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes a <dl> with several names and values per group`, async (t) => {
+  const target = (
+    <dl>
+      <dt>Foo</dt>
+      <dt>Bar</dt>
+      <dd>Baz</dd>
+      <dd>Qux</dd>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes a <dl> with consecutive name-value groups`, async (t) => {
+  const target = (
+    <dl>
+      <dt>Foo</dt>
+      <dd>Bar</dd>
+      <dt>Baz</dt>
+      <dd>Qux</dd>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes an empty <dl>`, async (t) => {
+  const target = <dl></dl>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes a <dl> that intermixes script-supporting elements`, async (t) => {
+  const target = (
+    <dl>
+      <script>{"const foo = 1;"}</script>
+      <dt>Foo</dt>
+      <script>{"const bar = 2;"}</script>
+      <dd>Bar</dd>
+      <template></template>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes a <dl> that contains only script-supporting elements`, async (t) => {
+  const target = (
+    <dl>
+      <script>{"const foo = 1;"}</script>
+      <template></template>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> with a description without a term`, async (t) => {
+  const error = <dd>Foo</dd>;
+
+  const target = (
+    <dl>
+      {error}
+      <dt>Bar</dt>
+      <dd>Baz</dd>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
+      1: Outcomes.HasMalformedGroups([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> with a trailing term that is given no description`, async (t) => {
+  const error = <dt>Baz</dt>;
+
+  const target = (
+    <dl>
+      <dt>Foo</dt>
+      <dd>Bar</dd>
+      {error}
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
+      1: Outcomes.HasMalformedGroups([error]),
+    }),
+  ]);
+});
+
+test(`every malformed group in a <dl> is evaluated, not only the first`, async (t) => {
+  const first = <dd>Foo</dd>;
+  const last = <dt>Qux</dt>;
+
+  const target = (
+    <dl>
+      {first}
+      <dt>Bar</dt>
+      <dd>Baz</dd>
+      {last}
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
+      1: Outcomes.HasMalformedGroups([first, last]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> with a stray <slot>`, async (t) => {
+  const error = <slot></slot>;
+
+  const target = (
+    <dl>
+      {error}
+      <dt>Foo</dt>
+      <dd>Bar</dd>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
+      1: Outcomes.HasDisallowedElements([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> with a child that is neither <dt>, <dd> nor <div>`, async (t) => {
+  const error = <p>Foo</p>;
+
+  const target = (
+    <dl>
+      {error}
+      <dt>Bar</dt>
+      <dd>Baz</dd>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
+      1: Outcomes.HasDisallowedElements([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> containing text outside of a name or value`, async (t) => {
+  const target = (
+    <dl>
+      Foo
+      <dt>Bar</dt>
+      <dd>Baz</dd>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, { 1: Outcomes.HasDisallowedText }),
+  ]);
+});
+
+/* <dl> with groups wrapped in <div> */
+
+test(`evaluate() passes a <dl> whose groups are each wrapped in a <div>`, async (t) => {
+  const target = (
+    <dl>
+      <div>
+        <dt>Foo</dt>
+        <dd>Bar</dd>
+      </div>
+      <div>
+        <dt>Baz</dt>
+        <dd>Qux</dd>
+      </div>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes a <dl> with a script-supporting element between wrappers`, async (t) => {
+  const target = (
+    <dl>
+      <div>
+        <dt>Foo</dt>
+        <dd>Bar</dd>
+      </div>
+      <script>{"const foo = 1;"}</script>
+      <div>
+        <dt>Baz</dt>
+        <dd>Qux</dd>
+      </div>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() passes a <dl> with a script-supporting element inside a wrapper`, async (t) => {
+  const target = (
+    <dl>
+      <div>
+        <dt>Foo</dt>
+        <script>{"const foo = 1;"}</script>
+        <dd>Bar</dd>
+      </div>
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    passed(R121, target, { 1: Outcomes.HasValidContent }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> that mixes wrapped and unwrapped groups`, async (t) => {
+  const name = <dt>Baz</dt>;
+  const value = <dd>Qux</dd>;
+
+  const target = (
+    <dl>
+      <div>
+        <dt>Foo</dt>
+        <dd>Bar</dd>
+      </div>
+      {name}
+      {value}
+    </dl>
+  );
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
+      1: Outcomes.HasMixedGroups([name, value]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> with a wrapper that holds a name and no value`, async (t) => {
+  const error = (
+    <div>
+      <dt>Foo</dt>
+    </div>
+  );
+
+  const target = <dl>{error}</dl>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
+      1: Outcomes.HasMalformedGroups([error]),
+    }),
+  ]);
+});
+
+test(`a <dl> with a wrapper with wrong order of elements`, async (t) => {
+  const error = (
+    <div>
+      <dd>Foo</dd>
+      <dt>Bar</dt>
+    </div>
+  );
+
+  const target = <dl>{error}</dl>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
+      1: Outcomes.HasMalformedGroups([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> with a wrapper that holds more than one group`, async (t) => {
+  const error = (
+    <div>
+      <dt>Foo</dt>
+      <dd>Bar</dd>
+      <dt>Baz</dt>
+      <dd>Qux</dd>
+    </div>
+  );
+
+  const target = <dl>{error}</dl>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
+      1: Outcomes.HasMalformedGroups([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> with a wrapper holding a stray <slot>`, async (t) => {
+  const error = (
+    <div>
+      <slot></slot>
+      <dt>Foo</dt>
+      <dd>Bar</dd>
+    </div>
+  );
+
+  const target = <dl>{error}</dl>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
+      1: Outcomes.HasMalformedGroups([error]),
+    }),
+  ]);
+});
+
+test(`evaluate() fails a <dl> with a wrapper that holds a disallowed element`, async (t) => {
+  const error = (
+    <div>
+      <dt>Foo</dt>
+      <dd>Bar</dd>
+      <p>Baz</p>
+    </div>
+  );
+
+  const target = <dl>{error}</dl>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R121, { document }), [
+    failed(R121, target, {
+      1: Outcomes.HasMalformedGroups([error]),
+    }),
+  ]);
+});
+
+/* Applicability */
+
+test(`evaluate() is inapplicable to a document with no list`, async (t) => {
+  const document = h.document([
+    <div>
+      <p>Foo</p>
+    </div>,
+  ]);
+
+  t.deepEqual(await evaluate(R121, { document }), [inapplicable(R121)]);
+});
+
+test(`evaluate() is inapplicable to a list that is not rendered`, async (t) => {
+  const document = h.document([
+    <ul style={{ display: "none" }}>
+      <div>Foo</div>
+    </ul>,
+  ]);
+
+  t.deepEqual(await evaluate(R121, { document }), [inapplicable(R121)]);
+});
diff --git a/packages/alfa-rules/test/sia-r122/rule.spec.tsx b/packages/alfa-rules/test/sia-r122/rule.spec.tsx
new file mode 100644
index 0000000000..4b8cc04545
--- /dev/null
+++ b/packages/alfa-rules/test/sia-r122/rule.spec.tsx
@@ -0,0 +1,448 @@
+import { h } from "@siteimprove/alfa-dom";
+import { test } from "@siteimprove/alfa-test";
+
+import R122, { Outcomes } from "../../src/sia-r122/rule.ts";
+
+import { evaluate } from "../common/evaluate.ts";
+import { failed, inapplicable, passed } from "../common/outcome.ts";
+
+test(`evaluate() passes elements with distinct access keys`, async (t) => {
+  const first = <button accesskey="a">Foo</button>;
+  const second = <button accesskey="b">Bar</button>;
+
+  const document = h.document([first, second]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    passed(R122, first, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    passed(R122, second, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() fails both elements sharing an access key`, async (t) => {
+  const first = <button accesskey="a">Foo</button>;
+  const second = <button accesskey="a">Bar</button>;
+
+  const document = h.document([first, second]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, first, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R122, second, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() compares access keys without regard to case`, async (t) => {
+  const first = <button accesskey="a">Foo</button>;
+  const second = <button accesskey="A">Bar</button>;
+
+  const document = h.document([first, second]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, first, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R122, second, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() compares access keys with surrounding whitespace removed`, async (t) => {
+  const first = <button accesskey="a">Foo</button>;
+  const second = <button accesskey=" a ">Bar</button>;
+
+  const document = h.document([first, second]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, first, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R122, second, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() names only the contested key of a multi-token access key`, async (t) => {
+  const both = <button accesskey="a b">Foo</button>;
+  const other = <button accesskey="b">Bar</button>;
+
+  const document = h.document([both, other]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, both, {
+      1: Outcomes.HasNonUniqueAccesskeys(["b"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R122, other, {
+      1: Outcomes.HasNonUniqueAccesskeys(["b"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() names every contested key of a multi-token access key`, async (t) => {
+  const both = <button accesskey="a b">Foo</button>;
+  const first = <button accesskey="a">Bar</button>;
+  const second = <button accesskey="b">Baz</button>;
+
+  const document = h.document([both, first, second]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, both, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a", "b"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R122, first, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R122, second, {
+      1: Outcomes.HasNonUniqueAccesskeys(["b"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() passes multi-token access keys that share no token`, async (t) => {
+  const first = <button accesskey="a b">Foo</button>;
+  const second = <button accesskey="c d">Bar</button>;
+
+  const document = h.document([first, second]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    passed(R122, first, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    passed(R122, second, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports a key the element declares twice`, async (t) => {
+  const target = <button accesskey="a a">Foo</button>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasRepeatedAccesskeys(["a"]),
+    }),
+  ]);
+});
+
+test(`evaluate() reports a key declared twice in different cases`, async (t) => {
+  // `A` and `a` reach the same physical key, so this element declares one key
+  // twice. Stricter than the W3C checker, which compares the tokens literally
+  // and accepts this value.
+  const target = <button accesskey="a A">Foo</button>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasRepeatedAccesskeys(["a"]),
+    }),
+  ]);
+});
+
+test(`evaluate() reports a multi-character key, which no user can press`, async (t) => {
+  const first = <button accesskey="aa">Foo</button>;
+  const second = <button accesskey="a">Bar</button>;
+
+  const document = h.document([first, second]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, first, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasMultiCharacterAccesskeys(["aa"]),
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    passed(R122, second, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports two elements sharing a multi-character key`, async (t) => {
+  const first = <button accesskey="aa">Foo</button>;
+  const second = <button accesskey="aa">Bar</button>;
+
+  const document = h.document([first, second]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, first, {
+      1: Outcomes.HasNonUniqueAccesskeys(["aa"]),
+      2: Outcomes.HasMultiCharacterAccesskeys(["aa"]),
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R122, second, {
+      1: Outcomes.HasNonUniqueAccesskeys(["aa"]),
+      2: Outcomes.HasMultiCharacterAccesskeys(["aa"]),
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() accepts a single Japanese character as a key`, async (t) => {
+  const target = <button accesskey="ぬ">Foo</button>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    passed(R122, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() accepts several Japanese characters as separate keys`, async (t) => {
+  const target = <button accesskey="ぬ め">Foo</button>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    passed(R122, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports two elements sharing a Japanese key`, async (t) => {
+  const first = <button accesskey="ぬ">Foo</button>;
+  const second = <button accesskey="ぬ">Bar</button>;
+
+  const document = h.document([first, second]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, first, {
+      1: Outcomes.HasNonUniqueAccesskeys(["ぬ"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R122, second, {
+      1: Outcomes.HasNonUniqueAccesskeys(["ぬ"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports a Japanese key an element declares twice`, async (t) => {
+  // Verbatim from the checker's duplicate-key-labels test case.
+  const target = <button accesskey="a b ぬ c ぬ">Foo</button>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasRepeatedAccesskeys(["ぬ"]),
+    }),
+  ]);
+});
+
+test(`evaluate() reports a multi-character Japanese key`, async (t) => {
+  // Adapted from the checker's multi-character-key-label test case, which uses
+  // `ほげ`. Both kana here sit directly on a JIS keyboard, ほ on the `-` key and
+  // す on the `R` key, so the value is plainly two keystrokes rather than one.
+  const target = <button accesskey="a b ほす">Foo</button>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasMultiCharacterAccesskeys(["ほす"]),
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports every multi-character key of one element`, async (t) => {
+  const target = <button accesskey="aa bb c">Foo</button>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasMultiCharacterAccesskeys(["aa", "bb"]),
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports every key an element declares twice`, async (t) => {
+  const target = <button accesskey="a a b b">Foo</button>;
+
+  const document = h.document([target]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasRepeatedAccesskeys(["a", "b"]),
+    }),
+  ]);
+});
+
+test(`evaluate() passes an access key shared only with an element that is not rendered`, async (t) => {
+  const target = <button accesskey="a">Foo</button>;
+
+  const document = h.document([
+    target,
+    <button accesskey="a" style={{ display: "none" }}>
+      Bar
+    </button>,
+  ]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    passed(R122, target, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports a key shared across a frame boundary`, async (t) => {
+  // Access keys are treated as unique across the whole page, frames included,
+  // rather than per document.
+  const outer = <button accesskey="a">Parent</button>;
+  const inner = <button accesskey="a">Framed</button>;
+
+  const document = h.document([outer, <iframe>{h.document([inner])}</iframe>]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, outer, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R122, inner, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() passes distinct keys either side of a frame boundary`, async (t) => {
+  const outer = <button accesskey="a">Parent</button>;
+  const inner = <button accesskey="b">Framed</button>;
+
+  const document = h.document([outer, <iframe>{h.document([inner])}</iframe>]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    passed(R122, outer, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    passed(R122, inner, {
+      1: Outcomes.HasUniqueAccesskeys,
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports a key shared between two frames`, async (t) => {
+  const first = <button accesskey="a">First</button>;
+  const second = <button accesskey="a">Second</button>;
+
+  const document = h.document([
+    <iframe>{h.document([first])}</iframe>,
+    <iframe>{h.document([second])}</iframe>,
+  ]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, first, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R122, second, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() reports a key shared across a shadow boundary in one document`, async (t) => {
+  const light = <button accesskey="a">Light</button>;
+  const shadowed = <button accesskey="a">Shadowed</button>;
+
+  const document = h.document([light, <div>{h.shadow([shadowed])}</div>]);
+
+  t.deepEqual(await evaluate(R122, { document }), [
+    failed(R122, light, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+    failed(R122, shadowed, {
+      1: Outcomes.HasNonUniqueAccesskeys(["a"]),
+      2: Outcomes.HasSingleCharacterAccesskeys,
+      3: Outcomes.HasDistinctAccesskeys,
+    }),
+  ]);
+});
+
+test(`evaluate() is inapplicable to a document with no access key`, async (t) => {
+  const document = h.document([<button>Foo</button>]);
+
+  t.deepEqual(await evaluate(R122, { document }), [inapplicable(R122)]);
+});
+
+test(`evaluate() is inapplicable to an access key that is only whitespace`, async (t) => {
+  const document = h.document([<button accesskey=" ">Foo</button>]);
+
+  t.deepEqual(await evaluate(R122, { document }), [inapplicable(R122)]);
+});
diff --git a/packages/alfa-rules/test/tsconfig.json b/packages/alfa-rules/test/tsconfig.json
index 35a68c388a..5fbc024dce 100644
--- a/packages/alfa-rules/test/tsconfig.json
+++ b/packages/alfa-rules/test/tsconfig.json
@@ -123,7 +123,9 @@
     "./sia-r115/rule.spec.tsx",
     "./sia-r116/rule.spec.tsx",
     "./sia-r117/rule.spec.tsx",
-    "./sia-r118/rule.spec.tsx"
+    "./sia-r118/rule.spec.tsx",
+    "./sia-r121/rule.spec.tsx",
+    "./sia-r122/rule.spec.tsx"
   ],
   "references": [
     { "path": "../src" },
