From 1a82d77d4275f3252a0dea16f15b5eaaf10357d9 Mon Sep 17 00:00:00 2001
From: Jean-Yves Moyen <jym@siteimprove.com>
Date: Tue, 14 Apr 2020 09:20:37 +0200
Subject: [PATCH 1/7] Try to write some test

---
 packages/alfa-rules/src/sia-r56/rule.ts       | 98 +++++++++++++++++++
 .../alfa-rules/test/sia-r56/rule.spec.tsx     | 43 ++++++++
 packages/alfa-rules/tsconfig.json             |  2 +
 3 files changed, 143 insertions(+)
 create mode 100644 packages/alfa-rules/src/sia-r56/rule.ts
 create mode 100644 packages/alfa-rules/test/sia-r56/rule.spec.tsx

diff --git a/packages/alfa-rules/src/sia-r56/rule.ts b/packages/alfa-rules/src/sia-r56/rule.ts
new file mode 100644
index 0000000000..8aaa99a702
--- /dev/null
+++ b/packages/alfa-rules/src/sia-r56/rule.ts
@@ -0,0 +1,98 @@
+import { Rule } from "@siteimprove/alfa-act";
+import { Node, Role } from "@siteimprove/alfa-aria";
+import { Branched } from "@siteimprove/alfa-branched";
+import { Device } from "@siteimprove/alfa-device";
+import { Element, Namespace } from "@siteimprove/alfa-dom";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Err, Ok } from "@siteimprove/alfa-result";
+import { Page } from "@siteimprove/alfa-web";
+import { expectation } from "../common/expectation";
+
+import { hasName } from "../common/predicate/has-name";
+import { hasNamespace } from "../common/predicate/has-namespace";
+import { hasRole } from "../common/predicate/has-role";
+import { isPerceivable } from "../common/predicate/is-perceivable";
+
+const { and, equals } = Predicate;
+
+export default Rule.Atomic.of<Page, Iterable<Element>>({
+  uri: "https://siteimprove.github.io/sanshikan/rules/sia-r56.html",
+  evaluate({ device, document }) {
+    return {
+      applicability() {
+        const elements = document
+          .descendants({ flattened: true, nested: true })
+          .filter(
+            and(
+              and(Element.isElement, hasNamespace(equals(Namespace.HTML))),
+              and(isPerceivable(device), hasLandmarkRole(device))
+            )
+          );
+
+        console.dir(elements.map((elt) => elt.id.get()).toJSON());
+
+        const groups = elements
+          .groupBy((landmark) => Role.from(landmark))
+          ;
+
+        console.dir(groups.map(seq => seq.map(elt => elt.id.get())).toJSON(), {depth:4});
+
+        console.dir([...groups.values()].map(seq => seq.map(elt => elt.id.get()).toJSON()));
+
+        return groups.values();
+      },
+
+      expectations(target) {
+        const names = arrayBranchedToBranchedArray(
+          [...target].map((landmark) =>
+            Node.from(landmark, device).map((accNode) =>
+              accNode.name().map((str) => str.toLocaleLowerCase())
+            )
+          )
+        );
+
+        return {
+          "1": expectation(
+            names.every((namesArray) =>
+              namesArray.every(
+                (opt, idx) => namesArray.findIndex(equals(opt)) === idx
+              )
+            ),
+            () => Outcomes.differentNames,
+            () => Outcomes.sameNames
+          ),
+        };
+      },
+    };
+  },
+});
+
+export namespace Outcomes {
+  export const differentNames = Ok.of(
+    "No two same landmarks have the same name."
+  );
+
+  export const sameNames = Err.of(
+    "Some identical landmarks have the same name."
+  );
+}
+
+function hasLandmarkRole(device: Device): Predicate<Element> {
+  return hasRole((role) => role.inheritsFrom(hasName(equals("landmark"))));
+}
+
+function addToBranchedArray<T, B>(
+  belt: Branched<T, B>,
+  barr: Branched<Array<T>, B>
+): Branched<Array<T>, B> {
+  return barr.flatMap((arr) => belt.map((elt) => arr.concat(elt)));
+}
+
+function arrayBranchedToBranchedArray<T, B>(
+  arr: Array<Branched<T, B>>
+): Branched<Array<T>, B> {
+  return arr.reduce<Branched<Array<T>, B>>(
+    (acc, cur) => addToBranchedArray(cur, acc),
+    Branched.of([])
+  );
+}
diff --git a/packages/alfa-rules/test/sia-r56/rule.spec.tsx b/packages/alfa-rules/test/sia-r56/rule.spec.tsx
new file mode 100644
index 0000000000..8bb15d2fa7
--- /dev/null
+++ b/packages/alfa-rules/test/sia-r56/rule.spec.tsx
@@ -0,0 +1,43 @@
+import { Device } from "@siteimprove/alfa-device";
+import { Document, Element } from "@siteimprove/alfa-dom";
+import { jsx } from "@siteimprove/alfa-dom/jsx";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { test } from "@siteimprove/alfa-test";
+import { hasName } from "../../src/common/predicate/has-name";
+
+import R56, { Outcomes } from "../../src/sia-r56/rule";
+
+import { evaluate } from "../common/evaluate";
+import { passed, failed, inapplicable } from "../common/outcome";
+
+const { and, equals } = Predicate;
+
+const device = Device.standard();
+
+test("Passes when same landmarks have different names", async (t) => {
+  const document = Document.of((self) => [
+    Element.fromElement(
+      <html>
+        <aside aria-label="About the author" id="author"/>
+        <aside aria-label="About the book" id="book"/>
+      </html>
+    ),
+  ]);
+  const target = document
+    .descendants()
+    .filter(and(Element.isElement, hasName(equals("aside"))))
+    .groupBy(() => 0)
+    .values();
+
+  const actual = await evaluate(R56, { device, document });
+  const expected = passed(R56, Iterable.first(target).get(), [
+    ["1", Outcomes.differentNames],
+  ]);
+
+  // console.dir(actual.map(outcome => ({...outcome, target: [...outcome.target!].map(elt => elt.attribute("id").get().value)})));
+  // console.dir(expected);
+
+  // t.deepEqual(actual, [expected]);
+  t(true);
+});
diff --git a/packages/alfa-rules/tsconfig.json b/packages/alfa-rules/tsconfig.json
index 44d05630e3..ff72264f39 100644
--- a/packages/alfa-rules/tsconfig.json
+++ b/packages/alfa-rules/tsconfig.json
@@ -84,6 +84,7 @@
     "src/sia-r49/rule.ts",
     "src/sia-r5/rule.ts",
     "src/sia-r50/rule.ts",
+    "src/sia-r56/rule.ts",
     "src/sia-r57/rule.ts",
     "src/sia-r59/rule.ts",
     "src/sia-r6/rule.ts",
@@ -101,6 +102,7 @@
     "test/sia-r2/rule.spec.tsx",
     "test/sia-r24/rule.spec.tsx",
     "test/sia-r38/rule.spec.tsx",
+    "test/sia-r56/rule.spec.tsx",
     "test/sia-r57/rule.spec.tsx",
     "test/sia-r64/rule.spec.tsx",
     "test/sia-r68/rule.spec.tsx"

From 60442eb1e5227ee8b3030dd524978116418aab61 Mon Sep 17 00:00:00 2001
From: Jean-Yves Moyen <jym@siteimprove.com>
Date: Tue, 30 Jun 2020 10:48:03 +0200
Subject: [PATCH 2/7] Modernize code a bit

---
 packages/alfa-rules/src/sia-r56/rule.ts       | 62 ++++++++++++++-----
 .../alfa-rules/test/sia-r56/rule.spec.tsx     | 18 +++---
 2 files changed, 56 insertions(+), 24 deletions(-)

diff --git a/packages/alfa-rules/src/sia-r56/rule.ts b/packages/alfa-rules/src/sia-r56/rule.ts
index 8aaa99a702..221a7bfb0f 100644
--- a/packages/alfa-rules/src/sia-r56/rule.ts
+++ b/packages/alfa-rules/src/sia-r56/rule.ts
@@ -1,4 +1,4 @@
-import { Rule } from "@siteimprove/alfa-act";
+import { Diagnostic, Rule } from "@siteimprove/alfa-act";
 import { Node, Role } from "@siteimprove/alfa-aria";
 import { Branched } from "@siteimprove/alfa-branched";
 import { Device } from "@siteimprove/alfa-device";
@@ -8,12 +8,11 @@ import { Err, Ok } from "@siteimprove/alfa-result";
 import { Page } from "@siteimprove/alfa-web";
 import { expectation } from "../common/expectation";
 
-import { hasName } from "../common/predicate/has-name";
-import { hasNamespace } from "../common/predicate/has-namespace";
 import { hasRole } from "../common/predicate/has-role";
-import { isPerceivable } from "../common/predicate/is-perceivable";
+import { isIgnored } from "../common/predicate/is-ignored";
 
-const { and, equals } = Predicate;
+const { and, equals, not } = Predicate;
+const { hasNamespace } = Element;
 
 export default Rule.Atomic.of<Page, Iterable<Element>>({
   uri: "https://siteimprove.github.io/sanshikan/rules/sia-r56.html",
@@ -24,22 +23,53 @@ export default Rule.Atomic.of<Page, Iterable<Element>>({
           .descendants({ flattened: true, nested: true })
           .filter(
             and(
-              and(Element.isElement, hasNamespace(equals(Namespace.HTML))),
-              and(isPerceivable(device), hasLandmarkRole(device))
+              Element.isElement,
+              and(
+                hasNamespace(equals(Namespace.HTML)),
+                not(isIgnored(device)),
+                hasLandmarkRole(device)
+              )
             )
           );
 
         console.dir(elements.map((elt) => elt.id.get()).toJSON());
 
-        const groups = elements
-          .groupBy((landmark) => Role.from(landmark))
-          ;
+        const foo = [...elements].map((elt) => elt.id.get());
+        console.log(foo);
+
+        const groups = elements.groupBy((landmark) => {
+          const role = Role.from(landmark);
+
+          console.log(
+            `landmark ${landmark.id.get()} has role ${role
+              .toArray()
+              .map(([r, _]) => r.map((r) => r.name).getOr("no role"))}`
+          );
+
+          return role;
+        });
 
-        console.dir(groups.map(seq => seq.map(elt => elt.id.get())).toJSON(), {depth:4});
+        console.log(
+          groups
+            .toArray()
+            .map(
+              ([branchedRole, group]) =>
+                `role: ${branchedRole
+                  .toArray()
+                  .map(([r, _]) =>
+                    r.map((role) => role.name).getOr("no role")
+                  )}, groups: ${group
+                  .map((element) => element.id.get())
+                  .toJSON()}.`
+            )
+        );
 
-        console.dir([...groups.values()].map(seq => seq.map(elt => elt.id.get()).toJSON()));
+        const result = groups.values();
+        console.dir(
+          [...result].map((seq) => seq.map((elt) => elt.id.get()).toJSON())
+        );
 
-        return groups.values();
+        return result;
       },
 
       expectations(target) {
@@ -69,16 +99,16 @@ export default Rule.Atomic.of<Page, Iterable<Element>>({
 
 export namespace Outcomes {
   export const differentNames = Ok.of(
-    "No two same landmarks have the same name."
+    Diagnostic.of("No two same landmarks have the same name.")
   );
 
   export const sameNames = Err.of(
-    "Some identical landmarks have the same name."
+    Diagnostic.of("Some identical landmarks have the same name.")
   );
 }
 
 function hasLandmarkRole(device: Device): Predicate<Element> {
-  return hasRole((role) => role.inheritsFrom(hasName(equals("landmark"))));
+  return hasRole((role) => role.inheritsFrom(Role.hasName(equals("landmark"))));
 }
 
 function addToBranchedArray<T, B>(
diff --git a/packages/alfa-rules/test/sia-r56/rule.spec.tsx b/packages/alfa-rules/test/sia-r56/rule.spec.tsx
index 8bb15d2fa7..335068787b 100644
--- a/packages/alfa-rules/test/sia-r56/rule.spec.tsx
+++ b/packages/alfa-rules/test/sia-r56/rule.spec.tsx
@@ -4,7 +4,6 @@ import { jsx } from "@siteimprove/alfa-dom/jsx";
 import { Iterable } from "@siteimprove/alfa-iterable";
 import { Predicate } from "@siteimprove/alfa-predicate";
 import { test } from "@siteimprove/alfa-test";
-import { hasName } from "../../src/common/predicate/has-name";
 
 import R56, { Outcomes } from "../../src/sia-r56/rule";
 
@@ -12,6 +11,7 @@ import { evaluate } from "../common/evaluate";
 import { passed, failed, inapplicable } from "../common/outcome";
 
 const { and, equals } = Predicate;
+const { hasName } = Element;
 
 const device = Device.standard();
 
@@ -19,8 +19,8 @@ test("Passes when same landmarks have different names", async (t) => {
   const document = Document.of((self) => [
     Element.fromElement(
       <html>
-        <aside aria-label="About the author" id="author"/>
-        <aside aria-label="About the book" id="book"/>
+        <aside aria-label="About the author" id="author" />
+        <aside aria-label="About the book" id="book" />
       </html>
     ),
   ]);
@@ -30,14 +30,16 @@ test("Passes when same landmarks have different names", async (t) => {
     .groupBy(() => 0)
     .values();
 
-  const actual = await evaluate(R56, { device, document });
-  const expected = passed(R56, Iterable.first(target).get(), [
-    ["1", Outcomes.differentNames],
-  ]);
+  // const actual = await evaluate(R56, { device, document });
+  // const expected = passed(R56, Iterable.first(target).get(), [
+  //   { 1: Outcomes.differentNames },
+  // ]);
 
   // console.dir(actual.map(outcome => ({...outcome, target: [...outcome.target!].map(elt => elt.attribute("id").get().value)})));
   // console.dir(expected);
 
-  // t.deepEqual(actual, [expected]);
+  t.deepEqual(await evaluate(R56, { device, document }), [
+    passed(R56, Iterable.first(target).get(), { 1: Outcomes.differentNames }),
+  ]);
   t(true);
 });

From 0a007b8c5f3fcb5bef12b6ab6e58fe87fbb26be8 Mon Sep 17 00:00:00 2001
From: Jean-Yves Moyen <jym@siteimprove.com>
Date: Wed, 9 Jun 2021 12:18:03 +0200
Subject: [PATCH 3/7] Refactor normaalize

---
 packages/alfa-rules/src/common/normalize.ts |  3 +++
 packages/alfa-rules/src/sia-r14/rule.ts     | 20 ++++++++++----------
 packages/alfa-rules/src/sia-r15/rule.ts     |  7 ++-----
 packages/alfa-rules/src/sia-r41/rule.ts     | 17 ++++++++---------
 packages/alfa-rules/src/sia-r81/rule.ts     | 17 ++++++++---------
 packages/alfa-rules/tsconfig.json           |  1 +
 6 files changed, 32 insertions(+), 33 deletions(-)
 create mode 100644 packages/alfa-rules/src/common/normalize.ts

diff --git a/packages/alfa-rules/src/common/normalize.ts b/packages/alfa-rules/src/common/normalize.ts
new file mode 100644
index 0000000000..d6bf6a0e57
--- /dev/null
+++ b/packages/alfa-rules/src/common/normalize.ts
@@ -0,0 +1,3 @@
+export function normalize(input: string): string {
+  return input.trim().toLowerCase().replace(/\s+/g, " ");
+}
diff --git a/packages/alfa-rules/src/sia-r14/rule.ts b/packages/alfa-rules/src/sia-r14/rule.ts
index 2bbde1a330..a2a05cf620 100644
--- a/packages/alfa-rules/src/sia-r14/rule.ts
+++ b/packages/alfa-rules/src/sia-r14/rule.ts
@@ -8,12 +8,16 @@ import { Page } from "@siteimprove/alfa-web";
 
 import { expectation } from "../common/expectation";
 
-import { hasAccessibleName } from "../common/predicate/has-accessible-name";
-import { hasAttribute } from "../common/predicate/has-attribute";
-import { hasDescendant } from "../common/predicate/has-descendant";
-import { hasRole } from "../common/predicate/has-role";
-import { isFocusable } from "../common/predicate/is-focusable";
-import { isPerceivable } from "../common/predicate/is-perceivable";
+import { normalize } from "../common/normalize";
+
+import {
+  hasAccessibleName,
+  hasAttribute,
+  hasDescendant,
+  hasRole,
+  isFocusable,
+  isPerceivable,
+} from "../common/predicate";
 
 const { isElement, hasNamespace } = Element;
 const { isText } = Text;
@@ -72,10 +76,6 @@ export default Rule.Atomic.of<Page, Element>({
   },
 });
 
-function normalize(input: string): string {
-  return input.trim().toLowerCase().replace(/\s+/g, " ");
-}
-
 function getPerceivableTextContent(element: Element, device: Device): string {
   return normalize(
     element
diff --git a/packages/alfa-rules/src/sia-r15/rule.ts b/packages/alfa-rules/src/sia-r15/rule.ts
index c06ab574a5..311b9ff364 100644
--- a/packages/alfa-rules/src/sia-r15/rule.ts
+++ b/packages/alfa-rules/src/sia-r15/rule.ts
@@ -15,8 +15,9 @@ import { hasNonEmptyAccessibleName } from "../common/predicate/has-non-empty-acc
 import { isIgnored } from "../common/predicate/is-ignored";
 import { referenceSameResource } from "../common/predicate/reference-same-resource";
 
-import { Question } from "../common/question";
 import { Group } from "../common/group";
+import { normalize } from "../common/normalize";
+import { Question } from "../common/question";
 
 const { isElement, hasName, hasNamespace } = Element;
 const { and, not } = Predicate;
@@ -107,7 +108,3 @@ export namespace Outcomes {
     )
   );
 }
-
-function normalize(input: string): string {
-  return input.trim().toLowerCase().replace(/\s+/g, " ");
-}
diff --git a/packages/alfa-rules/src/sia-r41/rule.ts b/packages/alfa-rules/src/sia-r41/rule.ts
index 82c3ba8144..18f4069a00 100644
--- a/packages/alfa-rules/src/sia-r41/rule.ts
+++ b/packages/alfa-rules/src/sia-r41/rule.ts
@@ -12,13 +12,16 @@ import { Page } from "@siteimprove/alfa-web";
 
 import { expectation } from "../common/expectation";
 
-import { hasNonEmptyAccessibleName } from "../common/predicate/has-non-empty-accessible-name";
-import { hasRole } from "../common/predicate/has-role";
-import { isIgnored } from "../common/predicate/is-ignored";
+import {
+  hasNonEmptyAccessibleName,
+  hasRole,
+  isIgnored,
+  referenceSameResource,
+} from "../common/predicate";
 
-import { Question } from "../common/question";
 import { Group } from "../common/group";
-import { referenceSameResource } from "../common/predicate/reference-same-resource";
+import { normalize } from "../common/normalize";
+import { Question } from "../common/question";
 
 const { isElement, hasNamespace } = Element;
 const { flatten } = Iterable;
@@ -118,7 +121,3 @@ export namespace Outcomes {
     )
   );
 }
-
-function normalize(input: string): string {
-  return input.trim().toLowerCase().replace(/\s+/g, " ");
-}
diff --git a/packages/alfa-rules/src/sia-r81/rule.ts b/packages/alfa-rules/src/sia-r81/rule.ts
index 4147ab152c..e39315aef2 100644
--- a/packages/alfa-rules/src/sia-r81/rule.ts
+++ b/packages/alfa-rules/src/sia-r81/rule.ts
@@ -16,13 +16,16 @@ import * as dom from "@siteimprove/alfa-dom";
 
 import { expectation } from "../common/expectation";
 
-import { hasNonEmptyAccessibleName } from "../common/predicate/has-non-empty-accessible-name";
-import { hasRole } from "../common/predicate/has-role";
-import { isIgnored } from "../common/predicate/is-ignored";
+import {
+  hasNonEmptyAccessibleName,
+  hasRole,
+  isIgnored,
+  referenceSameResource,
+} from "../common/predicate";
 
-import { Question } from "../common/question";
 import { Group } from "../common/group";
-import { referenceSameResource } from "../common/predicate/reference-same-resource";
+import { normalize } from "../common/normalize";
+import { Question } from "../common/question";
 
 const { isElement, hasName, hasNamespace, hasId } = Element;
 const { flatten } = Iterable;
@@ -124,10 +127,6 @@ export namespace Outcomes {
   );
 }
 
-function normalize(input: string): string {
-  return input.trim().toLowerCase().replace(/\s+/g, " ");
-}
-
 /**
  * @todo For links in table cells, account for the text in the associated table
  *       header cell.
diff --git a/packages/alfa-rules/tsconfig.json b/packages/alfa-rules/tsconfig.json
index b1dd4f657f..61966476de 100644
--- a/packages/alfa-rules/tsconfig.json
+++ b/packages/alfa-rules/tsconfig.json
@@ -17,6 +17,7 @@
     "src/common/expectation/media-text-alternative.ts",
     "src/common/expectation/video-description-track-accurate.ts",
     "src/common/group.ts",
+    "src/common/normalize.ts",
     "src/common/outcome/contrast.ts",
     "src/common/outcome/text-spacing.ts",
     "src/common/outcome/refresh-delay.ts",

From 89f9763566e943ad9c2738ffb6d4f3550c486b0f Mon Sep 17 00:00:00 2001
From: Jean-Yves Moyen <jym@siteimprove.com>
Date: Wed, 9 Jun 2021 12:35:28 +0200
Subject: [PATCH 4/7] Mark members as readonly

---
 packages/alfa-rules/src/common/group.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/alfa-rules/src/common/group.ts b/packages/alfa-rules/src/common/group.ts
index 700ec9bd1a..42a9bf0508 100644
--- a/packages/alfa-rules/src/common/group.ts
+++ b/packages/alfa-rules/src/common/group.ts
@@ -18,9 +18,9 @@ export class Group<T>
     return new Group(Array.from(members));
   }
 
-  private readonly _members: Array<T>;
+  private readonly _members: ReadonlyArray<T>;
 
-  private constructor(members: Array<T>) {
+  private constructor(members: ReadonlyArray<T>) {
     this._members = members;
   }
 

From 0d5828a50330ac822a76ef6f7749cba8387bba35 Mon Sep 17 00:00:00 2001
From: Jean-Yves Moyen <jym@siteimprove.com>
Date: Wed, 9 Jun 2021 13:23:33 +0200
Subject: [PATCH 5/7] Write R56

---
 packages/alfa-rules/src/sia-r56/rule.ts       | 137 +++++++-----------
 .../alfa-rules/test/sia-r56/rule.spec.tsx     |  76 +++++-----
 2 files changed, 95 insertions(+), 118 deletions(-)

diff --git a/packages/alfa-rules/src/sia-r56/rule.ts b/packages/alfa-rules/src/sia-r56/rule.ts
index 221a7bfb0f..a9c7ee099f 100644
--- a/packages/alfa-rules/src/sia-r56/rule.ts
+++ b/packages/alfa-rules/src/sia-r56/rule.ts
@@ -1,93 +1,80 @@
+/// <reference lib="dom" />
+
 import { Diagnostic, Rule } from "@siteimprove/alfa-act";
 import { Node, Role } from "@siteimprove/alfa-aria";
-import { Branched } from "@siteimprove/alfa-branched";
-import { Device } from "@siteimprove/alfa-device";
 import { Element, Namespace } from "@siteimprove/alfa-dom";
+import { List } from "@siteimprove/alfa-list";
+import { Map } from "@siteimprove/alfa-map";
+import { Option } from "@siteimprove/alfa-option";
 import { Predicate } from "@siteimprove/alfa-predicate";
 import { Err, Ok } from "@siteimprove/alfa-result";
 import { Page } from "@siteimprove/alfa-web";
+
 import { expectation } from "../common/expectation";
+import { Group } from "../common/group";
+import { normalize } from "../common/normalize";
 
-import { hasRole } from "../common/predicate/has-role";
-import { isIgnored } from "../common/predicate/is-ignored";
+import { hasRole, isIgnored } from "../common/predicate";
 
 const { and, equals, not } = Predicate;
 const { hasNamespace } = Element;
 
-export default Rule.Atomic.of<Page, Iterable<Element>>({
+export default Rule.Atomic.of<Page, Group<Element>>({
   uri: "https://siteimprove.github.io/sanshikan/rules/sia-r56.html",
   evaluate({ device, document }) {
     return {
       applicability() {
-        const elements = document
+        return document
           .descendants({ flattened: true, nested: true })
+          .filter(Element.isElement)
           .filter(
             and(
-              Element.isElement,
-              and(
-                hasNamespace(equals(Namespace.HTML)),
-                not(isIgnored(device)),
-                hasLandmarkRole(device)
-              )
+              hasNamespace(equals(Namespace.HTML)),
+              not(isIgnored(device)),
+              hasRole(device, (role) => role.is("landmark"))
             )
-          );
-
-        console.dir(elements.map((elt) => elt.id.get()).toJSON());
-
-        const foo = [...elements].map((elt) => elt.id.get());
-        console.log(foo);
-
-        const groups = elements.groupBy((landmark) => {
-          const role = Role.from(landmark);
-
-          console.log(
-            `landmark ${landmark.id.get()} has role ${role
-              .toArray()
-              .map(([r, _]) => r.map((r) => r.name).getOr("no role"))}`
-          );
-
-          return role;
-        });
-
-        console.log(
-          groups
-            .toArray()
-            .map(
-              ([branchedRole, group]) =>
-                `role: ${branchedRole
-                  .toArray()
-                  .map(([r, _]) =>
-                    r.map((role) => role.name).getOr("no role")
-                  )}, groups: ${group
-                  .map((element) => element.id.get())
-                  .toJSON()}.`
-            )
-        );
-
-        const result = groups.values();
-        console.dir(
-          [...result].map((seq) => seq.map((elt) => elt.id.get()).toJSON())
-        );
-
-        return result;
+          )
+          .reduce((groups, landmark) => {
+            // since we already have filtered by hasLandmarkRole, we can
+            // safely get the role.
+            const role = Node.from(landmark, device).role.get()!;
+
+            groups = groups.set(
+              role,
+              groups
+                .get(role)
+                .getOrElse(() => List.empty<Element>())
+                .append(landmark)
+            );
+
+            return groups;
+          }, Map.empty<Role, List<Element>>())
+          .filter((elements) => elements.size > 1)
+          .map(Group.of)
+          .values();
       },
 
       expectations(target) {
-        const names = arrayBranchedToBranchedArray(
-          [...target].map((landmark) =>
-            Node.from(landmark, device).map((accNode) =>
-              accNode.name().map((str) => str.toLocaleLowerCase())
-            )
-          )
-        );
+        const byNames = [...target]
+          .reduce((groups, landmark) => {
+            const name = Node.from(landmark, device).name.map((name) =>
+              normalize(name.value)
+            );
+            groups = groups.set(
+              name,
+              groups
+                .get(name)
+                .getOrElse(() => List.empty<Element>())
+                .append(landmark)
+            );
+
+            return groups;
+          }, Map.empty<Option<string>, List<Element>>())
+          .filter((landmarks) => landmarks.size > 1);
 
         return {
-          "1": expectation(
-            names.every((namesArray) =>
-              namesArray.every(
-                (opt, idx) => namesArray.findIndex(equals(opt)) === idx
-              )
-            ),
+          1: expectation(
+            byNames.size === 0,
             () => Outcomes.differentNames,
             () => Outcomes.sameNames
           ),
@@ -106,23 +93,3 @@ export namespace Outcomes {
     Diagnostic.of("Some identical landmarks have the same name.")
   );
 }
-
-function hasLandmarkRole(device: Device): Predicate<Element> {
-  return hasRole((role) => role.inheritsFrom(Role.hasName(equals("landmark"))));
-}
-
-function addToBranchedArray<T, B>(
-  belt: Branched<T, B>,
-  barr: Branched<Array<T>, B>
-): Branched<Array<T>, B> {
-  return barr.flatMap((arr) => belt.map((elt) => arr.concat(elt)));
-}
-
-function arrayBranchedToBranchedArray<T, B>(
-  arr: Array<Branched<T, B>>
-): Branched<Array<T>, B> {
-  return arr.reduce<Branched<Array<T>, B>>(
-    (acc, cur) => addToBranchedArray(cur, acc),
-    Branched.of([])
-  );
-}
diff --git a/packages/alfa-rules/test/sia-r56/rule.spec.tsx b/packages/alfa-rules/test/sia-r56/rule.spec.tsx
index 335068787b..91f7675540 100644
--- a/packages/alfa-rules/test/sia-r56/rule.spec.tsx
+++ b/packages/alfa-rules/test/sia-r56/rule.spec.tsx
@@ -1,45 +1,55 @@
-import { Device } from "@siteimprove/alfa-device";
-import { Document, Element } from "@siteimprove/alfa-dom";
-import { jsx } from "@siteimprove/alfa-dom/jsx";
-import { Iterable } from "@siteimprove/alfa-iterable";
-import { Predicate } from "@siteimprove/alfa-predicate";
 import { test } from "@siteimprove/alfa-test";
 
+import { Document } from "@siteimprove/alfa-dom";
+
 import R56, { Outcomes } from "../../src/sia-r56/rule";
 
 import { evaluate } from "../common/evaluate";
 import { passed, failed, inapplicable } from "../common/outcome";
 
-const { and, equals } = Predicate;
-const { hasName } = Element;
+import { Group } from "../../src/common/group";
+
+test("evaluate() passes when same landmarks have different names", async (t) => {
+  const author = <aside aria-label="About the author" id="author" />;
+  const book = <aside aria-label="About the book" id="book" />;
 
-const device = Device.standard();
+  const document = Document.of([author, book]);
+  const target = Group.of([author, book]);
 
-test("Passes when same landmarks have different names", async (t) => {
-  const document = Document.of((self) => [
-    Element.fromElement(
-      <html>
-        <aside aria-label="About the author" id="author" />
-        <aside aria-label="About the book" id="book" />
-      </html>
-    ),
+  t.deepEqual(await evaluate(R56, { document }), [
+    passed(R56, target, { 1: Outcomes.differentNames }),
   ]);
-  const target = document
-    .descendants()
-    .filter(and(Element.isElement, hasName(equals("aside"))))
-    .groupBy(() => 0)
-    .values();
-
-  // const actual = await evaluate(R56, { device, document });
-  // const expected = passed(R56, Iterable.first(target).get(), [
-  //   { 1: Outcomes.differentNames },
-  // ]);
-
-  // console.dir(actual.map(outcome => ({...outcome, target: [...outcome.target!].map(elt => elt.attribute("id").get().value)})));
-  // console.dir(expected);
-
-  t.deepEqual(await evaluate(R56, { device, document }), [
-    passed(R56, Iterable.first(target).get(), { 1: Outcomes.differentNames }),
+});
+
+test("evaluate() fails when same landmarks have same names", async (t) => {
+  const aside1 = <aside aria-label="More information" id="author" />;
+  const aside2 = <aside aria-label="More information" id="book" />;
+
+  const document = Document.of([aside1, aside2]);
+  const target = Group.of([aside1, aside2]);
+
+  t.deepEqual(await evaluate(R56, { document }), [
+    failed(R56, target, { 1: Outcomes.sameNames }),
   ]);
-  t(true);
+});
+
+test("evaluate() fails when same landmarks have no names", async (t) => {
+  const aside1 = <aside id="author" />;
+  const aside2 = <aside id="book" />;
+
+  const document = Document.of([aside1, aside2]);
+  const target = Group.of([aside1, aside2]);
+
+  t.deepEqual(await evaluate(R56, { document }), [
+    failed(R56, target, { 1: Outcomes.sameNames }),
+  ]);
+});
+
+test("evaluate() is inapplicable when only different landmarks exist", async (t) => {
+  const aside = <aside />;
+  const nav = <nav />;
+
+  const document = Document.of([aside, nav]);
+
+  t.deepEqual(await evaluate(R56, { document }), [inapplicable(R56)]);
 });

From abf94774065fb2d1bd065806e1fec637baa4e35e Mon Sep 17 00:00:00 2001
From: Jean-Yves Moyen <jym@siteimprove.com>
Date: Wed, 9 Jun 2021 13:47:22 +0200
Subject: [PATCH 6/7] Add basic extended diagnostic

---
 packages/alfa-rules/src/sia-r56/rule.ts       | 58 +++++++++++++++++--
 .../alfa-rules/test/sia-r56/rule.spec.tsx     |  4 +-
 2 files changed, 54 insertions(+), 8 deletions(-)

diff --git a/packages/alfa-rules/src/sia-r56/rule.ts b/packages/alfa-rules/src/sia-r56/rule.ts
index a9c7ee099f..9d4676dcab 100644
--- a/packages/alfa-rules/src/sia-r56/rule.ts
+++ b/packages/alfa-rules/src/sia-r56/rule.ts
@@ -1,7 +1,6 @@
-/// <reference lib="dom" />
-
 import { Diagnostic, Rule } from "@siteimprove/alfa-act";
 import { Node, Role } from "@siteimprove/alfa-aria";
+import { Array } from "@siteimprove/alfa-array";
 import { Element, Namespace } from "@siteimprove/alfa-dom";
 import { List } from "@siteimprove/alfa-list";
 import { Map } from "@siteimprove/alfa-map";
@@ -76,7 +75,7 @@ export default Rule.Atomic.of<Page, Group<Element>>({
           1: expectation(
             byNames.size === 0,
             () => Outcomes.differentNames,
-            () => Outcomes.sameNames
+            () => Outcomes.sameNames(byNames.values())
           ),
         };
       },
@@ -89,7 +88,54 @@ export namespace Outcomes {
     Diagnostic.of("No two same landmarks have the same name.")
   );
 
-  export const sameNames = Err.of(
-    Diagnostic.of("Some identical landmarks have the same name.")
-  );
+  export const sameNames = (errors: Iterable<Iterable<Element>>) =>
+    Err.of(
+      SameNames.of("Some identical landmarks have the same name.", errors)
+    );
+}
+
+class SameNames extends Diagnostic implements Iterable<List<Element>> {
+  public static of(
+    message: string,
+    errors: Iterable<Iterable<Element>> = []
+  ): SameNames {
+    return new SameNames(message, Array.from(errors).map(List.from));
+  }
+
+  private readonly _errors: ReadonlyArray<List<Element>>;
+
+  private constructor(message: string, errors: ReadonlyArray<List<Element>>) {
+    super(message);
+    this._errors = errors;
+  }
+
+  public *[Symbol.iterator](): Iterator<List<Element>> {
+    yield* this._errors;
+  }
+
+  public equals(value: SameNames): boolean;
+
+  public equals(value: unknown): value is this;
+
+  public equals(value: unknown): boolean {
+    return (
+      value instanceof SameNames &&
+      value._message === this._message &&
+      value._errors.every((list, idx) => list.equals(this._errors[idx]))
+    );
+  }
+
+  public toJSON(): SameNames.JSON {
+    return { ...super.toJSON(), errors: Array.toJSON(this._errors) };
+  }
+}
+
+namespace SameNames {
+  export interface JSON extends Diagnostic.JSON {
+    errors: Array<List.JSON<Element>>;
+  }
+
+  export function isSameNames(value: unknown): value is SameNames {
+    return value instanceof SameNames;
+  }
 }
diff --git a/packages/alfa-rules/test/sia-r56/rule.spec.tsx b/packages/alfa-rules/test/sia-r56/rule.spec.tsx
index 91f7675540..570dc3b4c7 100644
--- a/packages/alfa-rules/test/sia-r56/rule.spec.tsx
+++ b/packages/alfa-rules/test/sia-r56/rule.spec.tsx
@@ -29,7 +29,7 @@ test("evaluate() fails when same landmarks have same names", async (t) => {
   const target = Group.of([aside1, aside2]);
 
   t.deepEqual(await evaluate(R56, { document }), [
-    failed(R56, target, { 1: Outcomes.sameNames }),
+    failed(R56, target, { 1: Outcomes.sameNames([target]) }),
   ]);
 });
 
@@ -41,7 +41,7 @@ test("evaluate() fails when same landmarks have no names", async (t) => {
   const target = Group.of([aside1, aside2]);
 
   t.deepEqual(await evaluate(R56, { document }), [
-    failed(R56, target, { 1: Outcomes.sameNames }),
+    failed(R56, target, { 1: Outcomes.sameNames([target]) }),
   ]);
 });
 

From 9b93be435dd850029a545c1babb18cf57982ef09 Mon Sep 17 00:00:00 2001
From: Jean-Yves Moyen <jym@siteimprove.com>
Date: Wed, 9 Jun 2021 14:12:00 +0200
Subject: [PATCH 7/7] Clean up

---
 packages/alfa-rules/src/sia-r56/rule.ts       | 53 ++++++++++++++-----
 .../alfa-rules/test/sia-r56/rule.spec.tsx     |  6 +--
 2 files changed, 42 insertions(+), 17 deletions(-)

diff --git a/packages/alfa-rules/src/sia-r56/rule.ts b/packages/alfa-rules/src/sia-r56/rule.ts
index 9d4676dcab..415e732125 100644
--- a/packages/alfa-rules/src/sia-r56/rule.ts
+++ b/packages/alfa-rules/src/sia-r56/rule.ts
@@ -2,6 +2,7 @@ import { Diagnostic, Rule } from "@siteimprove/alfa-act";
 import { Node, Role } from "@siteimprove/alfa-aria";
 import { Array } from "@siteimprove/alfa-array";
 import { Element, Namespace } from "@siteimprove/alfa-dom";
+import { Iterable } from "@siteimprove/alfa-iterable";
 import { List } from "@siteimprove/alfa-list";
 import { Map } from "@siteimprove/alfa-map";
 import { Option } from "@siteimprove/alfa-option";
@@ -34,7 +35,7 @@ export default Rule.Atomic.of<Page, Group<Element>>({
             )
           )
           .reduce((groups, landmark) => {
-            // since we already have filtered by hasLandmarkRole, we can
+            // since we already have filtered by having a landmark role, we can
             // safely get the role.
             const role = Node.from(landmark, device).role.get()!;
 
@@ -54,6 +55,13 @@ export default Rule.Atomic.of<Page, Group<Element>>({
       },
 
       expectations(target) {
+        // empty groups have been filtered out already, so we can safely get the
+        // first element
+        const role = Node.from(
+          Iterable.first(target).get()!,
+          device
+        ).role.get()!.name;
+
         const byNames = [...target]
           .reduce((groups, landmark) => {
             const name = Node.from(landmark, device).name.map((name) =>
@@ -74,8 +82,8 @@ export default Rule.Atomic.of<Page, Group<Element>>({
         return {
           1: expectation(
             byNames.size === 0,
-            () => Outcomes.differentNames,
-            () => Outcomes.sameNames(byNames.values())
+            () => Outcomes.differentNames(role),
+            () => Outcomes.sameNames(role, byNames.values())
           ),
         };
       },
@@ -84,31 +92,42 @@ export default Rule.Atomic.of<Page, Group<Element>>({
 });
 
 export namespace Outcomes {
-  export const differentNames = Ok.of(
-    Diagnostic.of("No two same landmarks have the same name.")
-  );
-
-  export const sameNames = (errors: Iterable<Iterable<Element>>) =>
-    Err.of(
-      SameNames.of("Some identical landmarks have the same name.", errors)
-    );
+  export const differentNames = (role: Role.Name) =>
+    Ok.of(Diagnostic.of(`No two \`${role}\` have the same name.`));
+
+  export const sameNames = (
+    role: Role.Name,
+    errors: Iterable<Iterable<Element>>
+  ) =>
+    Err.of(SameNames.of(`Some \`${role}\` have the same name.`, role, errors));
 }
 
 class SameNames extends Diagnostic implements Iterable<List<Element>> {
   public static of(
     message: string,
+    role: Role.Name = "none",
     errors: Iterable<Iterable<Element>> = []
   ): SameNames {
-    return new SameNames(message, Array.from(errors).map(List.from));
+    return new SameNames(message, role, Array.from(errors).map(List.from));
   }
 
+  private readonly _role: Role.Name;
   private readonly _errors: ReadonlyArray<List<Element>>;
 
-  private constructor(message: string, errors: ReadonlyArray<List<Element>>) {
+  private constructor(
+    message: string,
+    role: Role.Name,
+    errors: ReadonlyArray<List<Element>>
+  ) {
     super(message);
+    this._role = role;
     this._errors = errors;
   }
 
+  public get role(): Role.Name {
+    return this._role;
+  }
+
   public *[Symbol.iterator](): Iterator<List<Element>> {
     yield* this._errors;
   }
@@ -121,17 +140,23 @@ class SameNames extends Diagnostic implements Iterable<List<Element>> {
     return (
       value instanceof SameNames &&
       value._message === this._message &&
+      value._role === this._role &&
       value._errors.every((list, idx) => list.equals(this._errors[idx]))
     );
   }
 
   public toJSON(): SameNames.JSON {
-    return { ...super.toJSON(), errors: Array.toJSON(this._errors) };
+    return {
+      ...super.toJSON(),
+      role: this._role,
+      errors: Array.toJSON(this._errors),
+    };
   }
 }
 
 namespace SameNames {
   export interface JSON extends Diagnostic.JSON {
+    role: string;
     errors: Array<List.JSON<Element>>;
   }
 
diff --git a/packages/alfa-rules/test/sia-r56/rule.spec.tsx b/packages/alfa-rules/test/sia-r56/rule.spec.tsx
index 570dc3b4c7..6c5442bc9a 100644
--- a/packages/alfa-rules/test/sia-r56/rule.spec.tsx
+++ b/packages/alfa-rules/test/sia-r56/rule.spec.tsx
@@ -17,7 +17,7 @@ test("evaluate() passes when same landmarks have different names", async (t) =>
   const target = Group.of([author, book]);
 
   t.deepEqual(await evaluate(R56, { document }), [
-    passed(R56, target, { 1: Outcomes.differentNames }),
+    passed(R56, target, { 1: Outcomes.differentNames("complementary") }),
   ]);
 });
 
@@ -29,7 +29,7 @@ test("evaluate() fails when same landmarks have same names", async (t) => {
   const target = Group.of([aside1, aside2]);
 
   t.deepEqual(await evaluate(R56, { document }), [
-    failed(R56, target, { 1: Outcomes.sameNames([target]) }),
+    failed(R56, target, { 1: Outcomes.sameNames("complementary", [target]) }),
   ]);
 });
 
@@ -41,7 +41,7 @@ test("evaluate() fails when same landmarks have no names", async (t) => {
   const target = Group.of([aside1, aside2]);
 
   t.deepEqual(await evaluate(R56, { document }), [
-    failed(R56, target, { 1: Outcomes.sameNames([target]) }),
+    failed(R56, target, { 1: Outcomes.sameNames("complementary", [target]) }),
   ]);
 });