test: full test-suite refactor sweep (#61)

* chore(test): start test-suite refactor sweep * test(ltl): pin exact multi-obligation residual AST * test(ltl): table-test finalize Kleene connective combinations * test(ltl): pin reduce over pending inner for bound, Or, Not * test(ltl): marshal bounded Always steps/duration/deadline * test(verifier): cover LTL combinator verdict transitions and within unit panic * test(verifier): table-test DecodeAction kinds and lastAction field exposure * test(verifier): assert WithPlatform(ios) reaches the picker host and key pool * test(verifier): widen weighted-selection assertion to a 5x skew margin * test(verifier): un-skip ax-find round trip with a committed tree fixture * test(runner): pin isWDADrop to sidecar reconnect-failed message origin * test(runner): assert PressKey/Wait trace encoding records kind-specific fields * test(runner): cover RenderSummary unsupported-verbs surfacing branch * test(trace): set Hierarchy in round-trip and lock lossy Tree contract Also add a -race concurrent WriteStep test that asserts N well-formed JSONL lines, catching torn lines if the writer mutex is dropped. * test(trace): round-trip witnesses/changes/metrics/exceptions, pin step-0 witness * test(trace): document ViolationsAreGreppable grep contract and lock-free WriteScreenshot * test(hierarchy): cover invalid-JSON and malformed-bounds parser paths * test(trace): guard writer mutex via WriteStep/Close race on w.file * test(replay): drop unfailable assets and devproxy assertions * test(replay): cache reuses on equal mtime, reparses after append * test(replay): violation marker falls back to detection step when attributed missing * test(replay): corrupt meta/trace dirs return 500 with error body * test(replay): SSE client receives runs.changed after a broadcast * test(replay): Run coalesces creates, ignores write/chmod, closes subs on cancel * fix(sidecar): synchronize health fixture writes and exercise healthError * test(sidecar): cover swipe/longpress/doubletap/erase/presskey/metrics/logs translations * test(sidecar): cover DoubleTapSelector composition and mid-gesture cancel * test(sidecar): assert gRPC error status surfaces from action RPC * fix(chrome): route action methods through runCtx so caller cancellation aborts CDP * fix(chrome): route hierarchy/screenshot/waitidle/metrics through runCtx * refactor(ios): extract pure simctl JSON parsers * refactor(ios): add command-runner seams for EnsureSimulator * test(ios): table-test simctl parsers and EnsureSimulator seams * test(sidecarassets): cover placeholder build path * test(sidecarassets): assert reuse via sentinel bytes not mtime * test(bundler): cover properties-only spec registration * refactor(testrun): extract prepareBundleInputs from Execute * test(testrun): cover prepareBundleInputs aliases and missing-runtime error * test(testrun): table-test resolveRuntimeSibling search edges * test(testrun): exact-output tests for progressHandler line format * fix(cmd): point bundle-check aliases at pkg/spec/src * test(cmd): smoke-test bundle-check resolves spec aliases * test(cmd): table-test hier-check parse and FindAll on fixture * test(cmd): unit-test buildBrowseURL deep-link vs root * test(cmd): drop flaky TestRun_Doctor that launched real Chromium * test(cmd): pin pipeline error to bundle resolution on web platform * test(replay-ui): add bun test script * ci(replay-ui): run bun test via make web-test target * ci(replay-ui): point bun cache key at replay-ui/bun.lock * test(replay-ui): exercise real URL encoding and non-ok throw in getJson * refactor(replay-ui): extract snapshot flatten/getAtPath into lib module * test(replay-ui): pin snapshot flatten/getAtPath path round-trip * refactor(replay-ui): extract action selector/format into lib module * test(replay-ui): pin action selector parse and row formatting * refactor(replay-ui): share one statusFor between panels * refactor(replay-ui): extract run-history derivation into lib module * test(replay-ui): pin shared statusFor precedence and ordering * test(replay-ui): pin run-history derivation alignment * refactor(replay-ui): export clampIndex for testing * refactor(replay-ui): extract keyboard-nav dispatch into pure module * refactor(replay-ui): extract metrics formatters into lib module * test(replay-ui): pin clampIndex step boundaries * test(replay-ui): pin keyboard-nav ownership and key routing * test(replay-ui): pin metrics formatters and path gap handling * refactor(sidecar): expose device-output parsers as internal for testing * test(sidecar): table-test device-output parsers against malformed input * test(sidecar): cover logcat parsing year inference and line skipping * test(sidecar): pin pressKey keycode mapping and unknown-key rejection * test(sidecar): metrics bundleId falls back to launched app and honors override * test(sidecar): loosen deadline upper bound to tolerate slow CI scheduling * test(web-runtime): export selector builders for unit tests * test(web-runtime): guard sanitize cycle, function, and depth limits * test(web-runtime): table-test selector builder quoting and escaping * test(sidecar): collapse scalar-forwarding RPC tests into a table * test(replay-ui): dedup step/summary fixtures into shared module * test(ios): collapse pickSimulator point-tests into a table
2026-10-04 20:17:09 +00:00 · 2026-06-06 13:59:08 +05:30
1 parent 410602d2e1
commit 94d9511312
@@ -0,0 +1,74 @@
+import { describe, it, expect } from "bun:test";
+import {
+  formatActionRow,
+  formatElapsed,
+  parseSelector,
+  tagFromSelector,
+} from "../lib/action-format";
+import { summary } from "./fixtures";
+
+// Bug class: selector parsing mislabels every action row — splitting on the
+// wrong colon, treating a value-with-colon as the kind, or dropping the prefix
+// ellipsis would render the wrong target tag for every step.
+describe("parseSelector", () => {
+  const cases: { input: string; out: ReturnType<typeof parseSelector> }[] = [
+    { input: "id:login", out: { kind: "id", value: "login" } },
+    { input: "text:Sign In", out: { kind: "text", value: "Sign In" } },
+    { input: "textPrefix:Hello", out: { kind: "textPrefix", value: "Hello" } },
+    { input: "id:com.app:id/btn", out: { kind: "id", value: "com.app:id/btn" } },
+    { input: "bogus:x", out: null },
+    { input: ":leading", out: null },
+    { input: "no-colon", out: null },
+  ];
+  for (const { input, out } of cases) {
+    it(`parses ${input}`, () => {
+      expect(parseSelector(input)).toEqual(out);
+    });
+  }
+});
+
+describe("tagFromSelector", () => {
+  it("appends ellipsis only for prefix selectors", () => {
+    expect(tagFromSelector("textPrefix:Hel")).toBe("Hel...");
+    expect(tagFromSelector("text:Hello")).toBe("Hello");
+    expect(tagFromSelector("plain")).toBe("plain");
+  });
+});
+
+describe("formatActionRow", () => {
+  it("observes when no action kind, with and without screen", () => {
+    expect(formatActionRow(summary({}))).toEqual({
+      verb: "Observe",
+      target: "",
+      targetIsTag: false,
+    });
+    expect(formatActionRow(summary({ screen: "Home" }))).toEqual({
+      verb: "Observe",
+      target: "@ Home",
+      targetIsTag: false,
+    });
+  });
+
+  it("treats a selector label as a tag and a coordinate label as literal", () => {
+    expect(
+      formatActionRow(summary({ action_kind: "Tap", action_label: "id:btn" })),
+    ).toEqual({ verb: "Click", target: "btn", targetIsTag: true });
+    expect(
+      formatActionRow(summary({ action_kind: "Tap", action_label: "(10, 20)" })),
+    ).toEqual({ verb: "Click", target: "(10, 20)", targetIsTag: false });
+  });
+
+  it("maps known verbs and falls back to the raw kind", () => {
+    expect(formatActionRow(summary({ action_kind: "InputText", action_label: "hi" })).verb).toBe("Type");
+    expect(formatActionRow(summary({ action_kind: "Swipe" })).verb).toBe("Swipe");
+    expect(formatActionRow(summary({ action_kind: "Custom" })).verb).toBe("Custom");
+  });
+});
+
+describe("formatElapsed", () => {
+  it("formats mm:ss.mmm and clamps negatives to zero", () => {
+    expect(formatElapsed(0)).toBe("00:00.000");
+    expect(formatElapsed(65_432)).toBe("01:05.432");
+    expect(formatElapsed(-50)).toBe("00:00.000");
+  });
+});
@@ -1,10 +1,37 @@
 import { describe, it, expect } from "bun:test";
-import { screenshotUrl } from "../api";
+import { getJson, screenshotUrl } from "../api";

 describe("screenshotUrl", () => {
-  it("encodes runId and name", () => {
-    expect(screenshotUrl("run-1", "step-00001.png")).toBe(
-      "/api/runs/run-1/screenshots/step-00001.png",
+  it("percent-encodes runId and name with reserved characters", () => {
+    expect(screenshotUrl("run #1/a", "step 00001.png")).toBe(
+      "/api/runs/run%20%231%2Fa/screenshots/step%2000001.png",
    );
  });
 });
+
+describe("getJson", () => {
+  it("returns the decoded body on a 200 response", async () => {
+    const server = Bun.serve({
+      port: 0,
+      fetch: () => Response.json({ ok: true }),
+    });
+    try {
+      const body = await getJson<{ ok: boolean }>(server.url.href);
+      expect(body).toEqual({ ok: true });
+    } finally {
+      server.stop(true);
+    }
+  });
+
+  it("throws on a non-ok response instead of returning the error body", async () => {
+    const server = Bun.serve({
+      port: 0,
+      fetch: () => new Response("boom", { status: 500 }),
+    });
+    try {
+      await expect(getJson(server.url.href)).rejects.toThrow("500");
+    } finally {
+      server.stop(true);
+    }
+  });
+});
@@ -0,0 +1,15 @@
+import type { Step, StepSummary } from "../types";
+
+export function step(over: Partial<Step>): Step {
+  return { step: 0, timestamp: "1970-01-01T00:00:00.000Z", ...over };
+}
+
+export function summary(over: Partial<StepSummary>): StepSummary {
+  return {
+    index: 0,
+    timestamp: "1970-01-01T00:00:00.000Z",
+    has_violations: false,
+    has_exceptions: false,
+    ...over,
+  };
+}
@@ -0,0 +1,103 @@
+import { describe, it, expect } from "bun:test";
+import {
+  dispatchKey,
+  targetOwnsArrowKeys,
+  type KeyboardNavOptions,
+} from "../lib/keyboard-nav";
+
+function el(
+  over: Partial<{
+    tagName: string;
+    isContentEditable: boolean;
+    role: string | null;
+    parent: HTMLElement | null;
+  }> = {},
+): HTMLElement {
+  const role = over.role ?? null;
+  return {
+    tagName: over.tagName ?? "DIV",
+    isContentEditable: over.isContentEditable ?? false,
+    getAttribute: (name: string) => (name === "role" ? role : null),
+    parentElement: over.parent ?? null,
+  } as unknown as HTMLElement;
+}
+
+function spyOptions() {
+  const calls: string[] = [];
+  const make = (name: keyof KeyboardNavOptions) => () => {
+    calls.push(name);
+  };
+  const options: KeyboardNavOptions = {
+    onPrev: make("onPrev"),
+    onNext: make("onNext"),
+    onJumpStart: make("onJumpStart"),
+    onJumpEnd: make("onJumpEnd"),
+    onJumpPrev10: make("onJumpPrev10"),
+    onJumpNext10: make("onJumpNext10"),
+    onJumpNextViolation: make("onJumpNextViolation"),
+  };
+  return { calls, options };
+}
+
+describe("targetOwnsArrowKeys", () => {
+  it("walks ancestors and matches arrow-owning roles", () => {
+    expect(targetOwnsArrowKeys(el({ role: "option" }))).toBe(true);
+    const child = el({ role: null, parent: el({ role: "listbox" }) });
+    expect(targetOwnsArrowKeys(child)).toBe(true);
+    expect(targetOwnsArrowKeys(el({ role: "banner" }))).toBe(false);
+    expect(targetOwnsArrowKeys(null)).toBe(false);
+  });
+});
+
+// Bug class: navigation keys firing while the user types in a form field would
+// scrub the timeline out from under them; and arrow keys must yield to a
+// listbox/tab that owns them so its own roving focus still works.
+describe("dispatchKey ownership", () => {
+  it("ignores keys originating in editable targets", () => {
+    const { calls, options } = spyOptions();
+    expect(dispatchKey({ key: "j", target: el({ tagName: "INPUT" }) }, options)).toBe(false);
+    expect(dispatchKey({ key: "g", target: el({ isContentEditable: true }) }, options)).toBe(false);
+    expect(calls).toEqual([]);
+  });
+
+  it("yields arrow keys to an owning ancestor but still handles letters", () => {
+    const { calls, options } = spyOptions();
+    const inListbox = el({ parent: el({ role: "listbox" }) });
+    expect(dispatchKey({ key: "ArrowRight", target: inListbox }, options)).toBe(false);
+    expect(dispatchKey({ key: "j", target: inListbox }, options)).toBe(true);
+    expect(calls).toEqual(["onNext"]);
+  });
+
+  it("ignores keys combined with a modifier", () => {
+    const { calls, options } = spyOptions();
+    expect(dispatchKey({ key: "j", metaKey: true }, options)).toBe(false);
+    expect(dispatchKey({ key: "j", ctrlKey: true }, options)).toBe(false);
+    expect(calls).toEqual([]);
+  });
+});
+
+describe("dispatchKey routing", () => {
+  const cases: [string, boolean, keyof KeyboardNavOptions][] = [
+    ["ArrowLeft", false, "onPrev"],
+    ["k", false, "onPrev"],
+    ["ArrowLeft", true, "onJumpPrev10"],
+    ["ArrowRight", false, "onNext"],
+    ["j", true, "onJumpNext10"],
+    ["g", false, "onJumpStart"],
+    ["G", false, "onJumpEnd"],
+    [".", false, "onJumpNextViolation"],
+  ];
+  for (const [key, shiftKey, expected] of cases) {
+    it(`${shiftKey ? "shift+" : ""}${key} -> ${expected}`, () => {
+      const { calls, options } = spyOptions();
+      expect(dispatchKey({ key, shiftKey }, options)).toBe(true);
+      expect(calls).toEqual([expected]);
+    });
+  }
+
+  it("leaves unmapped keys untouched", () => {
+    const { calls, options } = spyOptions();
+    expect(dispatchKey({ key: "x" }, options)).toBe(false);
+    expect(calls).toEqual([]);
+  });
+});
@@ -0,0 +1,63 @@
+import { describe, it, expect } from "bun:test";
+import {
+  buildPath,
+  formatHeap,
+  formatTime,
+  fractionFor,
+} from "../lib/metrics-format";
+
+describe("formatHeap", () => {
+  const cases: [number, string][] = [
+    [0, "0B"],
+    [-1, "0B"],
+    [2048, "2K"],
+    [1024 * 1024, "1M"],
+    [5 * 1024 * 1024, "5M"],
+    [2 * 1024 * 1024 * 1024, "2.0G"],
+  ];
+  for (const [bytes, expected] of cases) {
+    it(`${bytes} -> ${expected}`, () => {
+      expect(formatHeap(bytes)).toBe(expected);
+    });
+  }
+});
+
+describe("formatTime", () => {
+  it("formats mm:ss and clamps negatives", () => {
+    expect(formatTime(0)).toBe("00:00");
+    expect(formatTime(65_000)).toBe("01:05");
+    expect(formatTime(-10)).toBe("00:00");
+  });
+});
+
+describe("fractionFor", () => {
+  it("centers a lone point and spreads the rest across 0..1", () => {
+    expect(fractionFor(0, 1)).toBe(0.5);
+    expect(fractionFor(0, 5)).toBe(0);
+    expect(fractionFor(4, 5)).toBe(1);
+    expect(fractionFor(2, 5)).toBe(0.5);
+  });
+});
+
+// Bug class: a missing sample must lift the pen (M) so the chart does not draw
+// a straight line bridging the gap, which would imply data that was never
+// measured.
+describe("buildPath gap handling", () => {
+  it("starts a new subpath after each undefined value", () => {
+    const samples = [{ v: 0 }, { v: 100 }, { v: undefined }, { v: 50 }];
+    const path = buildPath(samples, (s) => s.v, 100);
+    const commands = path.match(/[ML]/g);
+    expect(commands).toEqual(["M", "L", "M"]);
+    expect(path.startsWith("M0.0000,1.0000")).toBe(true);
+  });
+
+  it("emits empty string when every sample is missing", () => {
+    const samples = [{ v: undefined }, { v: undefined }];
+    expect(buildPath(samples, (s) => s.v, 100)).toBe("");
+  });
+
+  it("clamps values above the ceiling to the top of the lane", () => {
+    const path = buildPath([{ v: 200 }], (s) => s.v, 100);
+    expect(path).toBe("M0.5000,0.0000");
+  });
+});
@@ -0,0 +1,42 @@
+import { describe, it, expect } from "bun:test";
+import {
+  STATUS_ORDER,
+  statusFor,
+  statusForStep,
+} from "../lib/property-status";
+import { step } from "./fixtures";
+
+// Bug class: RunDetail and ViolationsPanel once carried two copies of this
+// status logic; if they drift, the same property shows a different verdict in
+// the timeline vs the violations list. Both panels now share statusFor, so its
+// precedence and the violated-first ordering must stay pinned.
+describe("statusFor", () => {
+  it("ranks violated over holds and defaults missing residuals to pending", () => {
+    const violations = new Set(["v"]);
+    expect(statusFor("v", violations, { v: { op: "true" } })).toBe("violated");
+    expect(statusFor("h", violations, { h: { op: "true" } })).toBe("holds");
+    expect(statusFor("p", violations, { p: { op: "false" } })).toBe("pending");
+    expect(statusFor("x", violations, undefined)).toBe("pending");
+  });
+});
+
+describe("statusForStep", () => {
+  it("matches statusFor for the same step and is pending for a null step", () => {
+    const s = step({
+      violations: ["v"],
+      residuals: { v: { op: "true" }, h: { op: "true" } },
+    });
+    expect(statusForStep("v", s)).toBe("violated");
+    expect(statusForStep("h", s)).toBe("holds");
+    expect(statusForStep("v", null)).toBe("pending");
+  });
+});
+
+describe("STATUS_ORDER", () => {
+  it("sorts violated before pending before holds", () => {
+    const sorted = ["holds", "violated", "pending"].sort(
+      (a, b) => STATUS_ORDER[a as never] - STATUS_ORDER[b as never],
+    );
+    expect(sorted).toEqual(["violated", "pending", "holds"]);
+  });
+});
@@ -0,0 +1,81 @@
+import { describe, it, expect } from "bun:test";
+import {
+  buildRunHistory,
+  collectPropertyNames,
+  sortLanes,
+  statusForProperty,
+} from "../lib/run-history";
+import type { PropertyLane } from "../panels/Timeline";
+import type { Run } from "../types";
+import { step, summary } from "./fixtures";
+
+function lane(name: string, statuses: PropertyLane["statuses"]): PropertyLane {
+  return { name, statuses };
+}
+
+describe("collectPropertyNames", () => {
+  it("dedups and sorts names across steps, skipping null and residual-less steps", () => {
+    const names = collectPropertyNames([
+      null,
+      step({ residuals: { b: { op: "true" }, a: { op: "false" } } }),
+      step({}),
+      step({ residuals: { a: { op: "true" }, c: { op: "true" } } }),
+    ]);
+    expect(names).toEqual(["a", "b", "c"]);
+  });
+});
+
+// Bug class: getting status precedence wrong (e.g. checking residual before
+// the violation set, or not defaulting null/absent to pending) would paint a
+// violated property lane green.
+describe("statusForProperty", () => {
+  it("ranks violated over a holding residual and defaults to pending", () => {
+    const s = step({ violations: ["p"], residuals: { p: { op: "true" } } });
+    expect(statusForProperty("p", s)).toBe("violated");
+    expect(statusForProperty("q", step({ residuals: { q: { op: "true" } } }))).toBe("holds");
+    expect(statusForProperty("q", step({ residuals: { q: { op: "false" } } }))).toBe("pending");
+    expect(statusForProperty("p", null)).toBe("pending");
+  });
+});
+
+// Bug class: a lane that ever violated must sort first; trailing-pending lanes
+// rank ahead of fully-holding ones, else the timeline buries active failures.
+describe("sortLanes", () => {
+  it("orders violated, then trailing-pending, then holds, ties by name", () => {
+    const ordered = sortLanes([
+      lane("holds-b", ["holds", "holds"]),
+      lane("pending-a", ["holds", "pending"]),
+      lane("violated-z", ["holds", "violated", "holds"]),
+      lane("holds-a", ["holds", "holds"]),
+    ]).map((l) => l.name);
+    expect(ordered).toEqual(["violated-z", "pending-a", "holds-a", "holds-b"]);
+  });
+});
+
+describe("buildRunHistory", () => {
+  it("aligns lane statuses, metrics samples, and first-violation index by position", () => {
+    const run = {
+      id: "run-1",
+      steps: [
+        summary({ index: 0 }),
+        summary({ index: 1, has_violations: true }),
+        summary({ index: 2, has_exceptions: true }),
+      ],
+    } as unknown as Run;
+    const responses = [
+      step({ step: 0, residuals: { p: { op: "true" } } }),
+      step({ step: 1, violations: ["p"], residuals: { p: { op: "true" } } }),
+      null,
+    ];
+
+    const history = buildRunHistory(run, responses);
+
+    expect(history.names).toEqual(["p"]);
+    expect(history.lanes[0].statuses).toEqual(["holds", "violated", "pending"]);
+    expect(history.firstViolationStep).toBe(1);
+    expect(history.firstExceptionStep).toBe(2);
+    expect(history.violationStepIndices).toEqual([1]);
+    expect(history.exceptionStepIndices).toEqual([2]);
+    expect(history.metricsSamples.map((m) => m.stepIndex)).toEqual([0, 1, 2]);
+  });
+});
@@ -0,0 +1,67 @@
+import { describe, it, expect } from "bun:test";
+import {
+  canonicalize,
+  flatten,
+  getAtPath,
+  stableStringify,
+} from "../lib/snapshot-diff";
+
+// Bug class: a path off-by-one in the getAtPath regex parse resolves the wrong
+// node, so every diff between two snapshots is mis-reported. flatten emits the
+// paths the diff later feeds back through getAtPath, so every emitted path must
+// resolve to the same value flatten recorded.
+describe("flatten/getAtPath round-trip", () => {
+  const cases: { name: string; input: Record<string, unknown> }[] = [
+    { name: "nested objects", input: { a: { b: { c: 1 } } } },
+    {
+      name: "array longer than inline limit indexes each element",
+      input: { items: [10, 20, 30, 40] },
+    },
+    {
+      name: "objects inside an expanded array",
+      input: { rows: [{ id: 1 }, { id: 2 }, { id: 3 }] },
+    },
+    {
+      name: "keys with dots are matched verbatim before regex split",
+      input: { "a.b": 7 },
+    },
+    {
+      name: "mixed nesting",
+      input: { ui: { tabs: ["x", "y", "z", "w"], open: true }, n: 0 },
+    },
+  ];
+
+  for (const { name, input } of cases) {
+    it(name, () => {
+      for (const row of flatten(input)) {
+        expect(stableStringify(getAtPath(input, row.path))).toBe(
+          stableStringify(row.value),
+        );
+      }
+    });
+  }
+
+  it("indexes array elements by their real position, not off by one", () => {
+    const input = { items: ["a", "b", "c", "d"] };
+    const rows = flatten(input);
+    expect(getAtPath(input, "items[0]")).toBe("a");
+    expect(getAtPath(input, "items[3]")).toBe("d");
+    expect(rows.map((r) => r.path)).toEqual([
+      "items[0]",
+      "items[1]",
+      "items[2]",
+      "items[3]",
+    ]);
+  });
+});
+
+describe("canonicalize", () => {
+  it("orders object keys so reordered snapshots compare equal", () => {
+    expect(stableStringify({ b: 1, a: 2 })).toBe(stableStringify({ a: 2, b: 1 }));
+    expect(canonicalize({ b: 1, a: 2 })).toEqual({ a: 2, b: 1 });
+  });
+
+  it("preserves array order", () => {
+    expect(stableStringify([3, 1, 2])).not.toBe(stableStringify([1, 2, 3]));
+  });
+});
@@ -0,0 +1,24 @@
+import { describe, it, expect } from "bun:test";
+import { clampIndex } from "../hooks/useStep";
+
+// Bug class: a wrong boundary lets the URL address step 0 or a step past the
+// end, so the viewer requests a non-existent step and renders nothing. Steps
+// are 1-based and capped at maxIndex.
+describe("clampIndex", () => {
+  const cases: [number, number | undefined, number][] = [
+    [0, 5, 1],
+    [-3, 5, 1],
+    [1, 5, 1],
+    [3, 5, 3],
+    [5, 5, 5],
+    [6, 5, 5],
+    [100, 5, 5],
+    [3, undefined, 3],
+    [0, undefined, 1],
+  ];
+  for (const [index, max, expected] of cases) {
+    it(`clamps (${index}, ${max}) -> ${expected}`, () => {
+      expect(clampIndex(index, max)).toBe(expected);
+    });
+  }
+});