@2702rebels/wpidata 1.0.0

package/src/formats/struct.test.ts

@@ -0,0 +1,814 @@
+import { describe, expect, it } from "vitest";
+
+import { pack, StructRepository, unpack } from "./struct";
+
+import type { StructDescriptor } from "./struct";
+
+const encoder = new TextEncoder();
+const encode = (s: string) => encoder.encode(s);
+
+describe("schema parser", () => {
+  const repository = new StructRepository();
+
+  it("parses empty schema", () => {
+    expect(repository.add("", encode(""))).toHaveProperty("fields", []);
+  });
+
+  it("parses trivial schema", () => {
+    expect(repository.add("", encode(";"))).toHaveProperty("fields", []);
+  });
+
+  it("parses simple declaration", () => {
+    expect(repository.add("", encode("int32 a"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 4,
+      fields: [
+        {
+          identifier: "a",
+          type: "int32",
+          offset: 0,
+          size: 4,
+        },
+      ],
+    });
+  });
+
+  it("parses array declaration", () => {
+    expect(repository.add("", encode("int32 a[2]"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 8,
+      fields: [
+        {
+          identifier: "a",
+          type: "int32",
+          offset: 0,
+          size: 4,
+          arraySize: 2,
+        },
+      ],
+    });
+  });
+
+  it("parses bit-field declaration", () => {
+    expect(repository.add("", encode("int32 a:2"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 4,
+      fields: [
+        {
+          identifier: "a",
+          type: "int32",
+          offset: 0,
+          size: 4,
+          bitWidth: 2,
+          bitShift: 0,
+        },
+      ],
+    });
+  });
+
+  it("parses bit-field declarations with compatible types", () => {
+    expect(repository.add("", encode("int32 a:2;uint32 b:30"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 4,
+      fields: [
+        {
+          identifier: "a",
+          type: "int32",
+          offset: 0,
+          size: 4,
+          bitWidth: 2,
+          bitShift: 0,
+        },
+        {
+          identifier: "b",
+          type: "uint32",
+          offset: 0,
+          size: 4,
+          bitWidth: 30,
+          bitShift: 2,
+        },
+      ],
+    });
+  });
+
+  it("parses bit-field declarations with incompatible types", () => {
+    expect(repository.add("", encode("int32 a:2;int16 b:2"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 6,
+      fields: [
+        {
+          identifier: "a",
+          type: "int32",
+          offset: 0,
+          size: 4,
+          bitWidth: 2,
+          bitShift: 0,
+        },
+        {
+          identifier: "b",
+          type: "int16",
+          offset: 4,
+          size: 2,
+          bitWidth: 2,
+          bitShift: 0,
+        },
+      ],
+    });
+  });
+
+  it("parses bit-field declarations with overflow", () => {
+    expect(repository.add("", encode("int8 a:4;int8 b:5"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 2,
+      fields: [
+        {
+          identifier: "a",
+          type: "int8",
+          offset: 0,
+          size: 1,
+          bitWidth: 4,
+          bitShift: 0,
+        },
+        {
+          identifier: "b",
+          type: "int8",
+          offset: 1,
+          size: 1,
+          bitWidth: 5,
+          bitShift: 0,
+        },
+      ],
+    });
+  });
+
+  it("parses bit-field declarations with boolean and 16-bit", () => {
+    expect(repository.add("", encode("bool a:1;int16 b:5"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 3,
+      fields: [
+        {
+          identifier: "a",
+          type: "bool",
+          offset: 0,
+          size: 1,
+          bitWidth: 1,
+          bitShift: 0,
+        },
+        {
+          identifier: "b",
+          type: "int16",
+          offset: 1,
+          size: 2,
+          bitWidth: 5,
+          bitShift: 0,
+        },
+      ],
+    });
+  });
+
+  it("parses bit-field declarations with two booleans and 16-bit", () => {
+    expect(repository.add("", encode("bool a:1;bool b:1;int16 c:5"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 3,
+      fields: [
+        {
+          identifier: "a",
+          type: "bool",
+          offset: 0,
+          size: 1,
+          bitWidth: 1,
+          bitShift: 0,
+        },
+        {
+          identifier: "b",
+          type: "bool",
+          offset: 0,
+          size: 1,
+          bitWidth: 1,
+          bitShift: 1,
+        },
+        {
+          identifier: "c",
+          type: "int16",
+          offset: 1,
+          size: 2,
+          bitWidth: 5,
+          bitShift: 0,
+        },
+      ],
+    });
+  });
+
+  it("parses bit-field declarations with 16-bit and boolean", () => {
+    expect(repository.add("", encode("int16 a:15;bool b:1"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 2,
+      fields: [
+        {
+          identifier: "a",
+          type: "int16",
+          offset: 0,
+          size: 2,
+          bitWidth: 15,
+          bitShift: 0,
+        },
+        {
+          identifier: "b",
+          type: "bool",
+          offset: 0,
+          size: 2,
+          bitWidth: 1,
+          bitShift: 15,
+        },
+      ],
+    });
+  });
+
+  it("parses bit-field declarations with 16-bit and boolean with overflow", () => {
+    expect(repository.add("", encode("int16 a:16;bool b:1"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 3,
+      fields: [
+        {
+          identifier: "a",
+          type: "int16",
+          offset: 0,
+          size: 2,
+          bitWidth: 16,
+          bitShift: 0,
+        },
+        {
+          identifier: "b",
+          type: "bool",
+          offset: 2,
+          size: 1,
+          bitWidth: 1,
+          bitShift: 0,
+        },
+      ],
+    });
+  });
+
+  it("parses bit-field declarations with 16-bit, booleans and 16-bit", () => {
+    expect(repository.add("", encode("int16 a:2;bool b:1; bool c:1; uint16 d:5"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 2,
+      fields: [
+        {
+          identifier: "a",
+          type: "int16",
+          offset: 0,
+          size: 2,
+          bitWidth: 2,
+          bitShift: 0,
+        },
+        {
+          identifier: "b",
+          type: "bool",
+          offset: 0,
+          size: 2,
+          bitWidth: 1,
+          bitShift: 2,
+        },
+        {
+          identifier: "c",
+          type: "bool",
+          offset: 0,
+          size: 2,
+          bitWidth: 1,
+          bitShift: 3,
+        },
+        {
+          identifier: "d",
+          type: "uint16",
+          offset: 0,
+          size: 2,
+          bitWidth: 5,
+          bitShift: 4,
+        },
+      ],
+    });
+  });
+
+  it("parses bit-field declarations with 64-bit", () => {
+    expect(repository.add("", encode("int64 a:16;int64 b:32;int64 c:48"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 16,
+      fields: [
+        {
+          identifier: "a",
+          type: "int64",
+          offset: 0,
+          size: 8,
+          bitWidth: 16,
+          bitShift: 0,
+        },
+        {
+          identifier: "b",
+          type: "int64",
+          offset: 0,
+          size: 8,
+          bitWidth: 32,
+          bitShift: 16,
+        },
+        {
+          identifier: "c",
+          type: "int64",
+          offset: 8,
+          size: 8,
+          bitWidth: 48,
+          bitShift: 0,
+        },
+      ],
+    });
+  });
+
+  it("parses bit-field declarations with 64-bit and booleans", () => {
+    expect(repository.add("", encode("int64 a:31;int64 b:32;bool x:1;bool y:1;int64 c:48"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 17,
+      fields: [
+        {
+          identifier: "a",
+          type: "int64",
+          offset: 0,
+          size: 8,
+          bitWidth: 31,
+          bitShift: 0,
+        },
+        {
+          identifier: "b",
+          type: "int64",
+          offset: 0,
+          size: 8,
+          bitWidth: 32,
+          bitShift: 31,
+        },
+        {
+          identifier: "x",
+          type: "bool",
+          offset: 0,
+          size: 8,
+          bitWidth: 1,
+          bitShift: 63,
+        },
+        {
+          identifier: "y",
+          type: "bool",
+          offset: 8,
+          size: 1,
+          bitWidth: 1,
+          bitShift: 0,
+        },
+        {
+          identifier: "c",
+          type: "int64",
+          offset: 9,
+          size: 8,
+          bitWidth: 48,
+          bitShift: 0,
+        },
+      ],
+    });
+  });
+
+  it("parses bit-field declarations with 64-bit and booleans fit tightly", () => {
+    expect(repository.add("", encode("int64 a:31;int64 b:31;bool x:1;bool y:1;int64 c:48"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 16,
+      fields: [
+        {
+          identifier: "a",
+          type: "int64",
+          offset: 0,
+          size: 8,
+          bitWidth: 31,
+          bitShift: 0,
+        },
+        {
+          identifier: "b",
+          type: "int64",
+          offset: 0,
+          size: 8,
+          bitWidth: 31,
+          bitShift: 31,
+        },
+        {
+          identifier: "x",
+          type: "bool",
+          offset: 0,
+          size: 8,
+          bitWidth: 1,
+          bitShift: 62,
+        },
+        {
+          identifier: "y",
+          type: "bool",
+          offset: 0,
+          size: 8,
+          bitWidth: 1,
+          bitShift: 63,
+        },
+        {
+          identifier: "c",
+          type: "int64",
+          offset: 8,
+          size: 8,
+          bitWidth: 48,
+          bitShift: 0,
+        },
+      ],
+    });
+  });
+
+  it("parses enum declaration", () => {
+    expect(repository.add("", encode("enum {x=1} int32 a;"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 4,
+      fields: [
+        {
+          identifier: "a",
+          type: "int32",
+          offset: 0,
+          size: 4,
+          enum: new Map<number, string>([[1, "x"]]),
+        },
+      ],
+    });
+  });
+
+  it("parses enum declaration without keyword", () => {
+    expect(repository.add("", encode("{x=1} int32 a;"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 4,
+      fields: [
+        {
+          identifier: "a",
+          type: "int32",
+          offset: 0,
+          size: 4,
+          enum: new Map<number, string>([[1, "x"]]),
+        },
+      ],
+    });
+  });
+
+  it("parses enum declaration with no values", () => {
+    expect(repository.add("", encode("{} int32 a;"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 4,
+      fields: [
+        {
+          identifier: "a",
+          type: "int32",
+          offset: 0,
+          size: 4,
+        },
+      ],
+    });
+  });
+
+  it("parses enum declaration with multiple values", () => {
+    expect(repository.add("", encode("{x=1,y=-2} int32 a;"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 4,
+      fields: [
+        {
+          identifier: "a",
+          type: "int32",
+          offset: 0,
+          size: 4,
+          enum: new Map<number, string>([
+            [1, "x"],
+            [-2, "y"],
+          ]),
+        },
+      ],
+    });
+  });
+
+  it("parses enum declaration with trailing comma", () => {
+    expect(repository.add("", encode("{x=1,y=2,} int32 a;"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 4,
+      fields: [
+        {
+          identifier: "a",
+          type: "int32",
+          offset: 0,
+          size: 4,
+          enum: new Map<number, string>([
+            [1, "x"],
+            [2, "y"],
+          ]),
+        },
+      ],
+    });
+  });
+
+  it("parses multiple declarations", () => {
+    expect(repository.add("", encode("int32 a; int16 b"))).toEqual<StructDescriptor>({
+      name: "",
+      size: 6,
+      fields: [
+        {
+          identifier: "a",
+          type: "int32",
+          offset: 0,
+          size: 4,
+        },
+        {
+          identifier: "b",
+          type: "int16",
+          offset: 4,
+          size: 2,
+        },
+      ],
+    });
+  });
+
+  it("parses nested type with unresolved dependency", () => {
+    expect(repository.add("typeA", encode("typeB b"))).toEqual<StructDescriptor>({
+      name: "typeA",
+      size: 0,
+      fields: [
+        {
+          identifier: "b",
+          type: "ref",
+          typeRef: "typeB",
+          offset: -1,
+          size: 0,
+        },
+      ],
+      unresolved: new Set(["typeB"]),
+    });
+  });
+
+  it("parses nested type and resolves dependency", () => {
+    expect(() => {
+      repository.add("typeA", encode("typeB b"));
+      repository.add("typeB", encode("int32 a"));
+      return repository.descriptors.get("typeA");
+    }).not.toHaveProperty("unresolved");
+  });
+
+  it("throws on duplicate field name", () => {
+    expect(() => repository.add("", encode("int16 a; int8 a"))).toThrow(
+      `Failed to parse schema: duplicate 'a' field declaration`
+    );
+  });
+
+  it("throws on mixed array and bit-field declaration", () => {
+    expect(() => repository.add("", encode("int32 a[1]:2"))).toThrow(
+      `Failed to parse schema: invalid declaration 'int32 a[1]:2'`
+    );
+  });
+
+  it("throws on array declaration without size", () => {
+    expect(() => repository.add("", encode("int32 a[]"))).toThrow(
+      `Failed to parse schema: invalid declaration 'int32 a[]'`
+    );
+  });
+
+  it("throws on array declaration with zero size", () => {
+    expect(() => repository.add("", encode("int32 a[0]"))).toThrow(
+      `Failed to parse schema: invalid array size in 'a' field declaration`
+    );
+  });
+
+  it("throws on array declaration without name", () => {
+    expect(() => repository.add("", encode("int32 [2]"))).toThrow(
+      `Failed to parse schema: invalid declaration 'int32 [2]'`
+    );
+  });
+
+  it("throws on bit-field declaration without name", () => {
+    expect(() => repository.add("", encode("int32 :2"))).toThrow(
+      `Failed to parse schema: invalid declaration 'int32 :2'`
+    );
+  });
+
+  it("throws on bit-field declaration with negative width", () => {
+    expect(() => repository.add("", encode("int32 a:-1"))).toThrow(
+      `Failed to parse schema: invalid declaration 'int32 a:-1'`
+    );
+  });
+
+  it("throws on bit-field declaration with zero width", () => {
+    expect(() => repository.add("", encode("int32 a:0"))).toThrow(
+      `Failed to parse schema: invalid declaration 'int32 a:0'`
+    );
+  });
+
+  it("throws on bit-field declaration with excessive width", () => {
+    expect(() => repository.add("", encode("int16 a:17"))).toThrow(
+      `Failed to parse schema: invalid integer bit-field width 'a' field declaration`
+    );
+  });
+
+  it("throws on bit-field declaration with unsupported type", () => {
+    expect(() => repository.add("", encode("float a:1"))).toThrow(
+      `Failed to parse schema: bit-field in non-integer/boolean 'a' field declaration`
+    );
+  });
+
+  it("throws on bit-field declaration with unknown type", () => {
+    expect(() => repository.add("", encode("foo a:1"))).toThrow(
+      `Failed to parse schema: bit-field in non-integer/boolean 'a' field declaration`
+    );
+  });
+
+  it("throws on bit-field declaration with invalid boolean size", () => {
+    expect(() => repository.add("", encode("bool a:2"))).toThrow(
+      `Failed to parse schema: invalid boolean bit-field width 'a' field declaration`
+    );
+  });
+
+  it("throws on enum declaration with unsupported type", () => {
+    expect(() => repository.add("", encode("enum {x=1} float a"))).toThrow(
+      `Failed to parse schema: enum declaration in non-integer 'a' field declaration`
+    );
+  });
+
+  it("throws on enum declaration with non-integer value", () => {
+    expect(() => repository.add("", encode("enum {x=y} int32 a"))).toThrow(
+      `Failed to parse schema: invalid declaration 'enum {x=y} int32 a'`
+    );
+  });
+
+  it("throws on circular dependency", () => {
+    expect(() => {
+      repository.add("typeA", encode("typeB b"));
+      repository.add("typeB", encode("typeA a"));
+    }).toThrow(`Failed to parse schema: circular dependency detected between 'typeB' and 'typeA'`);
+  });
+
+  it("throws on nested circular dependency", () => {
+    expect(() => {
+      repository.add("typeA", encode("typeB b"));
+      repository.add("typeB", encode("typeC c"));
+      repository.add("typeC", encode("typeA a"));
+    }).toThrow(`Failed to parse schema: circular dependency detected between 'typeC' and 'typeA'`);
+  });
+});
+
+describe("unpack: string", () => {
+  const repository = new StructRepository();
+  repository.add("test", encode("char a[32]"));
+  repository.add("test2", encode("char a[2]"));
+  repository.add("test3", encode("char a[3]"));
+  repository.add("test4", encode("char a[4]"));
+  repository.add("test5", encode("char a[5]"));
+
+  const encodeString = (v: string, length: number) => {
+    const array = new Uint8Array(length);
+    new TextEncoder().encodeInto(v, array);
+    return array;
+  };
+
+  it("with all zeros", () => {
+    expect(unpack("test", encodeString("", 32), repository)["a"]).toEqual("");
+  });
+
+  it("with partial value", () => {
+    expect(unpack("test", encodeString("abc", 32), repository)["a"]).toEqual("abc");
+  });
+
+  it("with embedded null", () => {
+    expect(unpack("test", encodeString("ab\0c", 32), repository)["a"]).toEqual("ab\0c");
+  });
+
+  it("with overflow", () => {
+    expect(unpack("test2", encodeString("abc", 2), repository)["a"]).toEqual("ab");
+  });
+
+  it("with partial 2 bytes", () => {
+    expect(unpack("test2", encodeString("a\u0234", 2), repository)["a"]).toEqual("a");
+  });
+
+  it("with complete 2 bytes", () => {
+    expect(unpack("test3", encodeString("a\u0234", 3), repository)["a"]).toEqual("a\u0234");
+  });
+
+  it("with partial 3 bytes (two short)", () => {
+    expect(unpack("test2", encodeString("a\u1234", 2), repository)["a"]).toEqual("a");
+  });
+
+  it("with partial 3 bytes (one short)", () => {
+    expect(unpack("test3", encodeString("a\u1234", 3), repository)["a"]).toEqual("a");
+  });
+
+  it("with complete 3 bytes", () => {
+    expect(unpack("test4", encodeString("a\u1234", 4), repository)["a"]).toEqual("a\u1234");
+  });
+
+  it("with partial 4 bytes (three short)", () => {
+    expect(unpack("test2", encodeString("a\ud83d\udc00", 2), repository)["a"]).toEqual("a");
+  });
+
+  it("with partial 4 bytes (two short)", () => {
+    expect(unpack("test3", encodeString("a\ud83d\udc00", 3), repository)["a"]).toEqual("a");
+  });
+
+  it("with partial 4 bytes (one short)", () => {
+    expect(unpack("test4", encodeString("a\ud83d\udc00", 4), repository)["a"]).toEqual("a");
+  });
+
+  it("with complete 4 bytes", () => {
+    expect(unpack("test5", encodeString("a\ud83d\udc00", 5), repository)["a"]).toEqual("a\ud83d\udc00");
+  });
+});
+
+describe("roundtrip", () => {
+  const repository = new StructRepository();
+
+  repository.add("test_bool", encode("bool a"));
+  repository.add("test_int8", encode("int8 a"));
+  repository.add("test_int16", encode("int16 a"));
+  repository.add("test_int32", encode("int32 a"));
+  repository.add("test_int64", encode("int64 a"));
+  repository.add("test_uint8", encode("uint8 a"));
+  repository.add("test_uint16", encode("uint16 a"));
+  repository.add("test_uint32", encode("uint32 a"));
+  repository.add("test_uint64", encode("uint64 a"));
+  repository.add("test_float", encode("float a"));
+  repository.add("test_double", encode("double a"));
+  repository.add("test_char", encode("char a"));
+  repository.add("test_char10", encode("char a[10]"));
+  repository.add("test_enum", encode("enum {x=1,y=2,z=3} int32 a"));
+  repository.add("test_bitfield8", encode("int8 a:2;int8 b:4;int8 c:6"));
+  repository.add("test_bitfield16", encode("int16 a:4;int16 b:8;int16 c:12"));
+  repository.add("test_bitfield32", encode("int32 a:8;int32 b:16;int32 c:24"));
+  repository.add("test_bitfield64", encode("int64 a:16;int64 b:32;int64 c:48"));
+  repository.add("test_bitfield8u", encode("uint8 a:2;uint8 b:4;uint8 c:6"));
+  repository.add("test_bitfield16u", encode("uint16 a:4;uint16 b:8;uint16 c:12"));
+  repository.add("test_bitfield32u", encode("uint32 a:8;uint32 b:16;uint32 c:24"));
+  repository.add("test_bitfield64u", encode("uint64 a:16;uint64 b:32;uint64 c:48"));
+  repository.add("test_nested", encode("int32 a;test_char10 b;test_enum c"));
+  repository.add("test_sample1", encode("uint8 a;uint8 b;uint16 c;uint16 d;uint16 e;int8 f;bool g;"));
+  repository.add("test_sample2", encode("uint32 a;char b[10];"));
+
+  const roundtrip = (name: string, value: Record<string, unknown>) =>
+    unpack(name, pack(name, value, repository), repository, { useEnum: true });
+
+  const expectEqualRoundtrip = (name: string, value: Record<string, unknown>) =>
+    expect(roundtrip(name, value)).toEqual(value);
+
+  it("bool", () => expectEqualRoundtrip("test_bool", { a: true }));
+  it("int8", () => expectEqualRoundtrip("test_int8", { a: -42 }));
+  it("int16", () => expectEqualRoundtrip("test_int16", { a: -42 }));
+  it("int32", () => expectEqualRoundtrip("test_int32", { a: -42 }));
+  it("int64", () => expectEqualRoundtrip("test_int64", { a: -42 }));
+  it("uint8", () => expectEqualRoundtrip("test_uint8", { a: 42 }));
+  it("uint16", () => expectEqualRoundtrip("test_uint16", { a: 42 }));
+  it("uint32", () => expectEqualRoundtrip("test_uint32", { a: 42 }));
+  it("uint64", () => expectEqualRoundtrip("test_uint64", { a: 42 }));
+  it("float", () => expectEqualRoundtrip("test_float", { a: 1.5 }));
+  it("double", () => expectEqualRoundtrip("test_double", { a: 3.14 }));
+  it("char", () => expectEqualRoundtrip("test_char", { a: "a" }));
+  it("char10", () => expectEqualRoundtrip("test_char10", { a: "0123456789" }));
+  it("enum", () => expectEqualRoundtrip("test_enum", { a: "y" }));
+  it("bitfield8", () => expectEqualRoundtrip("test_bitfield8", { a: 1, b: 2, c: 3 }));
+  it("bitfield16", () => expectEqualRoundtrip("test_bitfield16", { a: 1, b: 2, c: 3 }));
+  it("bitfield32", () => expectEqualRoundtrip("test_bitfield32", { a: 1, b: 2, c: 3 }));
+  it("bitfield64", () => expectEqualRoundtrip("test_bitfield64", { a: 1, b: 2, c: 3 }));
+  it("bitfield8u", () => expectEqualRoundtrip("test_bitfield8u", { a: 1, b: 2, c: 3 }));
+  it("bitfield16u", () => expectEqualRoundtrip("test_bitfield16u", { a: 1, b: 2, c: 3 }));
+  it("bitfield32u", () => expectEqualRoundtrip("test_bitfield32u", { a: 1, b: 2, c: 3 }));
+  it("bitfield64u", () => expectEqualRoundtrip("test_bitfield64u", { a: 1, b: 2, c: 3 }));
+  it("negative bitfield8", () => expectEqualRoundtrip("test_bitfield8", { a: -1, b: -2, c: -3 }));
+  it("negative bitfield16", () => expectEqualRoundtrip("test_bitfield16", { a: -1, b: -2, c: -3 }));
+  it("negative bitfield32", () => expectEqualRoundtrip("test_bitfield32", { a: -1, b: -2, c: -3 }));
+
+  // negative 64-bit values that are wider than 32-bit are expected to be treated as unsigned
+  // due to Javascript bitwise operations limitations
+  it("negative bitfield64", () =>
+    expect(roundtrip("test_bitfield64", { a: -1, b: -2, c: -3 })).toEqual({
+      a: -1,
+      b: -2,
+      c: 281474976710653,
+    }));
+
+  it("nested", () => expectEqualRoundtrip("test_nested", { a: 42, b: { a: "abc" }, c: { a: "z" } }));
+
+  it("char10 overflow", () =>
+    expect(roundtrip("test_char10", { a: "01234567890abcdef" })).toEqual({ a: "0123456789" }));
+
+  it("char10 utf-16", () => expectEqualRoundtrip("test_char10", { a: " тест " }));
+
+  it("sample1", () => expectEqualRoundtrip("test_sample1", { a: 63, b: 0, c: 0, d: 0, e: 0, f: -1, g: false }));
+  it("sample2", () => expectEqualRoundtrip("test_sample2", { a: 123456789, b: "123456789" }));
+
+  it("incomplete values 1", () =>
+    expect(roundtrip("test_sample1", { a: 63, c: 1, f: -1 })).toEqual({
+      a: 63,
+      b: 0,
+      c: 1,
+      d: 0,
+      e: 0,
+      f: -1,
+      g: false,
+    }));
+
+  it("incomplete values 2", () => expect(roundtrip("test_sample2", {})).toEqual({ a: 0, b: "" }));
+});