test: tighten byte count and file identity coverage

src/infra/file-identity.test.ts

@@ -6,28 +6,64 @@ function stat(dev: number | bigint, ino: number | bigint): FileIdentityStat {
 }
 
 describe("sameFileIdentity", () => {
-  it("accepts exact dev+ino match", () => {
+  it.each([
-    expect(sameFileIdentity(stat(7, 11), stat(7, 11), "linux")).toBe(true);
+    {
-  });
+      name: "accepts exact dev+ino match",
-
+      left: stat(7, 11),
-  it("rejects inode mismatch", () => {
+      right: stat(7, 11),
-    expect(sameFileIdentity(stat(7, 11), stat(7, 12), "linux")).toBe(false);
+      platform: "linux" as const,
-  });
+      expected: true,
-
+    },
-  it("rejects dev mismatch on non-windows", () => {
+    {
-    expect(sameFileIdentity(stat(7, 11), stat(8, 11), "linux")).toBe(false);
+      name: "rejects inode mismatch",
-  });
+      left: stat(7, 11),
-
+      right: stat(7, 12),
-  it("accepts win32 dev mismatch when either side is 0", () => {
+      platform: "linux" as const,
-    expect(sameFileIdentity(stat(0, 11), stat(8, 11), "win32")).toBe(true);
+      expected: false,
-    expect(sameFileIdentity(stat(7, 11), stat(0, 11), "win32")).toBe(true);
+    },
-  });
+    {
-
+      name: "rejects dev mismatch on non-windows",
-  it("keeps dev strictness on win32 when both dev values are non-zero", () => {
+      left: stat(7, 11),
-    expect(sameFileIdentity(stat(7, 11), stat(8, 11), "win32")).toBe(false);
+      right: stat(8, 11),
-  });
+      platform: "linux" as const,
-
+      expected: false,
-  it("handles bigint stats", () => {
+    },
-    expect(sameFileIdentity(stat(0n, 11n), stat(8n, 11n), "win32")).toBe(true);
+    {
+      name: "keeps dev strictness on linux when one side is zero",
+      left: stat(0, 11),
+      right: stat(8, 11),
+      platform: "linux" as const,
+      expected: false,
+    },
+    {
+      name: "accepts win32 dev mismatch when either side is 0",
+      left: stat(0, 11),
+      right: stat(8, 11),
+      platform: "win32" as const,
+      expected: true,
+    },
+    {
+      name: "accepts win32 dev mismatch when right side is 0",
+      left: stat(7, 11),
+      right: stat(0, 11),
+      platform: "win32" as const,
+      expected: true,
+    },
+    {
+      name: "keeps dev strictness on win32 when both dev values are non-zero",
+      left: stat(7, 11),
+      right: stat(8, 11),
+      platform: "win32" as const,
+      expected: false,
+    },
+    {
+      name: "handles bigint stats",
+      left: stat(0n, 11n),
+      right: stat(8n, 11n),
+      platform: "win32" as const,
+      expected: true,
+    },
+  ])("$name", ({ left, right, platform, expected }) => {
+    expect(sameFileIdentity(left, right, platform)).toBe(expected);
   });
 });

src/infra/json-utf8-bytes.test.ts

@@ -2,10 +2,24 @@ import { describe, expect, it } from "vitest";
 import { jsonUtf8Bytes } from "./json-utf8-bytes.js";
 
 describe("jsonUtf8Bytes", () => {
-  it("returns utf8 byte length for serializable values", () => {
+  it.each([
-    expect(jsonUtf8Bytes({ a: "x", b: [1, 2, 3] })).toBe(
+    {
-      Buffer.byteLength(JSON.stringify({ a: "x", b: [1, 2, 3] }), "utf8"),
+      name: "object payloads",
-    );
+      value: { a: "x", b: [1, 2, 3] },
+      expected: Buffer.byteLength(JSON.stringify({ a: "x", b: [1, 2, 3] }), "utf8"),
+    },
+    {
+      name: "strings",
+      value: "hello",
+      expected: Buffer.byteLength(JSON.stringify("hello"), "utf8"),
+    },
+    {
+      name: "undefined via string fallback",
+      value: undefined,
+      expected: Buffer.byteLength("undefined", "utf8"),
+    },
+  ])("returns utf8 byte length for $name", ({ value, expected }) => {
+    expect(jsonUtf8Bytes(value)).toBe(expected);
   });
 
   it("falls back to string conversion when JSON serialization throws", () => {
@@ -13,4 +27,8 @@ describe("jsonUtf8Bytes", () => {
     circular.self = circular;
     expect(jsonUtf8Bytes(circular)).toBe(Buffer.byteLength("[object Object]", "utf8"));
   });
+
+  it("uses string conversion for BigInt serialization failures", () => {
+    expect(jsonUtf8Bytes(12n)).toBe(Buffer.byteLength("12", "utf8"));
+  });
 });