tracker

22.6 KB

1. // MessagePack codec for hl:mpackdb — byte-compatible with npm msgpackr 1.11.5
2. // as mpackdb v1.0.7 uses it (decision D12).
3. //
4. // Measured msgpackr surface (probed against the real library, see
5. // testdata/gen_corpus.mjs):
6. // - NO record/shared-structure extensions: the standalone pack() export
7. // serializes plain objects as ordinary MessagePack maps.
8. // - Objects ALWAYS encode as map16 (0xde) — even empty — never fixmap/map32.
9. // Maps with > 65535 keys throw in msgpackr; we mirror with error.MapTooLarge.
10. // - Numbers: integer-valued f64 in [-2^31, 2^32) uses the smallest
11. // uint/int family (fixint, cc, cd, ce / negfixint, d0, d1, d2). Everything
12. // else (non-integers, |v| outside that range, NaN, ±Inf) is float64 (0xcb).
13. // msgpackr never emits float32 or int64/uint64 for JS numbers.
14. // - Strings: fixstr ≤31 bytes, str8 ≤255, str16 ≤65535, str32 beyond.
15. // - Arrays: fixarray ≤15, array16 ≤65535, array32 beyond.
16. // - Binary: bin8/16/32 by length.
17. // - undefined: fixext1 type 0x00 data 0x00 (d4 00 00) — kept as a distinct
18. // Value so re-encode is byte-exact; it surfaces as null in Hybriel.
19. // - Date: timestamp ext -1 (d6ff / d7ff / c70cff). Kept as a raw ext Value
20. // for byte-exact round-trips; timestampMs() interprets it.
21. //
22. // Decode accepts the FULL MessagePack spec (all int/str/bin/array/map families,
23. // float32, int64/uint64, all ext forms); encode emits only the canonical
24. // msgpackr subset above.
26. const std = @import("std");
28. pub const Error = error{
29. Truncated,
30. InvalidFormat, // 0xc1
31. MapTooLarge,
32. OutOfMemory,
33. };
35. pub const Ext = struct {
36. type: i8,
37. data: []const u8,
38. };
40. pub const Entry = struct {
41. key: Value,
42. value: Value,
43. };
45. pub const Value = union(enum) {
46. nil,
47. undef, // msgpackr `undefined` (fixext1 type 0)
48. boolean: bool,
49. number: f64,
50. str: []const u8,
51. bin: []const u8,
52. array: []Value,
53. map: []Entry,
54. ext: Ext,
56. /// Interpret a timestamp ext (-1) as milliseconds since epoch.
57. pub fn timestampMs(self: Value) ?f64 {
58. if (self != .ext or self.ext.type != -1) return null;
59. const d = self.ext.data;
60. switch (d.len) {
61. 4 => {
62. const sec = std.mem.readInt(u32, d[0..4], .big);
63. return @as(f64, @floatFromInt(sec)) * 1000.0;
64. },
65. 8 => {
66. const packed_v = std.mem.readInt(u64, d[0..8], .big);
67. const ns: f64 = @floatFromInt(packed_v >> 34);
68. const sec: f64 = @floatFromInt(packed_v & 0x3ffffffff);
69. return sec * 1000.0 + ns / 1_000_000.0;
70. },
71. 12 => {
72. const ns = std.mem.readInt(u32, d[0..4], .big);
73. const sec = std.mem.readInt(i64, d[4..12], .big);
74. return @as(f64, @floatFromInt(sec)) * 1000.0 + @as(f64, @floatFromInt(ns)) / 1_000_000.0;
75. },
76. else => return null,
77. }
78. }
80. /// Map field lookup by string key (returns null for missing / non-map).
81. pub fn get(self: Value, key: []const u8) ?Value {
82. if (self != .map) return null;
83. for (self.map) |e| {
84. if (e.key == .str and std.mem.eql(u8, e.key.str, key)) return e.value;
85. }
86. return null;
87. }
88. };
90. pub const Decoded = struct {
91. value: Value,
92. len: usize, // bytes consumed
93. };
95. /// Decode one MessagePack value from `bytes`. All slices in the returned Value
96. /// reference memory allocated from `alloc` (str/bin/ext data are duplicated,
97. /// so the Value outlives `bytes`). Use an arena and free it wholesale.
98. pub fn decode(alloc: std.mem.Allocator, bytes: []const u8) Error!Decoded {
99. var d = Decoder{ .alloc = alloc, .bytes = bytes, .pos = 0 };
100. const v = try d.readValue();
101. return .{ .value = v, .len = d.pos };
102. }
104. const Decoder = struct {
105. alloc: std.mem.Allocator,
106. bytes: []const u8,
107. pos: usize,
109. fn need(self: *Decoder, n: usize) Error!void {
110. if (self.pos + n > self.bytes.len) return Error.Truncated;
111. }
113. fn take(self: *Decoder, n: usize) Error![]const u8 {
114. try self.need(n);
115. const s = self.bytes[self.pos .. self.pos + n];
116. self.pos += n;
117. return s;
118. }
120. fn readBigInt(self: *Decoder, comptime T: type) Error!T {
121. const n = @divExact(@typeInfo(T).int.bits, 8);
122. const s = try self.take(n);
123. return std.mem.readInt(T, s[0..n], .big);
124. }
126. fn dupSlice(self: *Decoder, n: usize) Error![]const u8 {
127. const s = try self.take(n);
128. return self.alloc.dupe(u8, s) catch return Error.OutOfMemory;
129. }
131. fn readArray(self: *Decoder, n: usize) Error!Value {
132. const items = self.alloc.alloc(Value, n) catch return Error.OutOfMemory;
133. for (items) |*it| it.* = try self.readValue();
134. return .{ .array = items };
135. }
137. fn readMap(self: *Decoder, n: usize) Error!Value {
138. const entries = self.alloc.alloc(Entry, n) catch return Error.OutOfMemory;
139. for (entries) |*e| {
140. e.key = try self.readValue();
141. e.value = try self.readValue();
142. }
143. return .{ .map = entries };
144. }
146. fn readExt(self: *Decoder, n: usize) Error!Value {
147. try self.need(1 + n);
148. const t: i8 = @bitCast(self.bytes[self.pos]);
149. self.pos += 1;
150. const data = try self.dupSlice(n);
151. // msgpackr undefined: fixext1 type 0, data byte 0
152. if (t == 0 and n == 1 and data[0] == 0) return .undef;
153. return .{ .ext = .{ .type = t, .data = data } };
154. }
156. fn readValue(self: *Decoder) Error!Value {
157. try self.need(1);
158. const b = self.bytes[self.pos];
159. self.pos += 1;
160. switch (b) {
161. 0x00...0x7f => return .{ .number = @floatFromInt(b) },
162. 0x80...0x8f => return self.readMap(b & 0x0f),
163. 0x90...0x9f => return self.readArray(b & 0x0f),
164. 0xa0...0xbf => return .{ .str = try self.dupSlice(b & 0x1f) },
165. 0xc0 => return .nil,
166. 0xc1 => return Error.InvalidFormat,
167. 0xc2 => return .{ .boolean = false },
168. 0xc3 => return .{ .boolean = true },
169. 0xc4 => return .{ .bin = try self.dupSlice(try self.readBigInt(u8)) },
170. 0xc5 => return .{ .bin = try self.dupSlice(try self.readBigInt(u16)) },
171. 0xc6 => return .{ .bin = try self.dupSlice(try self.readBigInt(u32)) },
172. 0xc7 => return self.readExt(try self.readBigInt(u8)),
173. 0xc8 => return self.readExt(try self.readBigInt(u16)),
174. 0xc9 => return self.readExt(try self.readBigInt(u32)),
175. 0xca => {
176. const bits = try self.readBigInt(u32);
177. return .{ .number = @as(f32, @bitCast(bits)) };
178. },
179. 0xcb => {
180. const bits = try self.readBigInt(u64);
181. return .{ .number = @bitCast(bits) };
182. },
183. 0xcc => return .{ .number = @floatFromInt(try self.readBigInt(u8)) },
184. 0xcd => return .{ .number = @floatFromInt(try self.readBigInt(u16)) },
185. 0xce => return .{ .number = @floatFromInt(try self.readBigInt(u32)) },
186. 0xcf => return .{ .number = @floatFromInt(try self.readBigInt(u64)) },
187. 0xd0 => return .{ .number = @floatFromInt(@as(i8, @bitCast(try self.readBigInt(u8)))) },
188. 0xd1 => return .{ .number = @floatFromInt(@as(i16, @bitCast(try self.readBigInt(u16)))) },
189. 0xd2 => return .{ .number = @floatFromInt(@as(i32, @bitCast(try self.readBigInt(u32)))) },
190. 0xd3 => return .{ .number = @floatFromInt(@as(i64, @bitCast(try self.readBigInt(u64)))) },
191. 0xd4 => return self.readExt(1),
192. 0xd5 => return self.readExt(2),
193. 0xd6 => return self.readExt(4),
194. 0xd7 => return self.readExt(8),
195. 0xd8 => return self.readExt(16),
196. 0xd9 => return .{ .str = try self.dupSlice(try self.readBigInt(u8)) },
197. 0xda => return .{ .str = try self.dupSlice(try self.readBigInt(u16)) },
198. 0xdb => return .{ .str = try self.dupSlice(try self.readBigInt(u32)) },
199. 0xdc => return self.readArray(try self.readBigInt(u16)),
200. 0xdd => return self.readArray(try self.readBigInt(u32)),
201. 0xde => return self.readMap(try self.readBigInt(u16)),
202. 0xdf => return self.readMap(try self.readBigInt(u32)),
203. 0xe0...0xff => return .{ .number = @floatFromInt(@as(i8, @bitCast(b))) },
204. }
205. }
206. };
208. /// Encode a Value in the canonical msgpackr form (see header comment).
209. pub fn encode(alloc: std.mem.Allocator, value: Value) Error![]u8 {
210. var buf: std.ArrayList(u8) = .empty;
211. errdefer buf.deinit(alloc);
212. try encodeInto(alloc, &buf, value);
213. return buf.toOwnedSlice(alloc) catch Error.OutOfMemory;
214. }
216. pub fn encodeInto(alloc: std.mem.Allocator, buf: *std.ArrayList(u8), value: Value) Error!void {
217. const w = Writer{ .alloc = alloc, .buf = buf };
218. try w.writeValue(value);
219. }
221. const Writer = struct {
222. alloc: std.mem.Allocator,
223. buf: *std.ArrayList(u8),
225. fn byte(self: Writer, b: u8) Error!void {
226. self.buf.append(self.alloc, b) catch return Error.OutOfMemory;
227. }
229. fn raw(self: Writer, s: []const u8) Error!void {
230. self.buf.appendSlice(self.alloc, s) catch return Error.OutOfMemory;
231. }
233. fn big(self: Writer, comptime T: type, v: T) Error!void {
234. var tmp: [@divExact(@typeInfo(T).int.bits, 8)]u8 = undefined;
235. std.mem.writeInt(T, &tmp, v, .big);
236. try self.raw(&tmp);
237. }
239. fn writeNumber(self: Writer, v: f64) Error!void {
240. // msgpackr rule (measured): integer-valued and within [-2^31, 2^32) →
241. // smallest int family; else float64. -0 encodes as fixint 0.
242. if (v == @floor(v) and v >= -2147483648.0 and v <= 4294967295.0) {
243. if (v >= 0) {
244. const u: u32 = @intFromFloat(v);
245. if (u < 0x80) return self.byte(@intCast(u));
246. if (u <= 0xff) {
247. try self.byte(0xcc);
248. return self.byte(@intCast(u));
249. }
250. if (u <= 0xffff) {
251. try self.byte(0xcd);
252. return self.big(u16, @intCast(u));
253. }
254. try self.byte(0xce);
255. return self.big(u32, u);
256. } else {
257. const i: i32 = @intFromFloat(v);
258. if (i >= -32) return self.byte(@bitCast(@as(i8, @intCast(i))));
259. if (i >= -128) {
260. try self.byte(0xd0);
261. return self.byte(@bitCast(@as(i8, @intCast(i))));
262. }
263. if (i >= -32768) {
264. try self.byte(0xd1);
265. return self.big(u16, @bitCast(@as(i16, @intCast(i))));
266. }
267. try self.byte(0xd2);
268. return self.big(u32, @bitCast(i));
269. }
270. }
271. try self.byte(0xcb);
272. return self.big(u64, @bitCast(v));
273. }
275. fn writeStr(self: Writer, s: []const u8) Error!void {
276. if (s.len <= 31) {
277. try self.byte(0xa0 | @as(u8, @intCast(s.len)));
278. } else if (s.len <= 0xff) {
279. try self.byte(0xd9);
280. try self.byte(@intCast(s.len));
281. } else if (s.len <= 0xffff) {
282. try self.byte(0xda);
283. try self.big(u16, @intCast(s.len));
284. } else {
285. try self.byte(0xdb);
286. try self.big(u32, @intCast(s.len));
287. }
288. return self.raw(s);
289. }
291. fn writeValue(self: Writer, value: Value) Error!void {
292. switch (value) {
293. .nil => try self.byte(0xc0),
294. .undef => try self.raw(&[_]u8{ 0xd4, 0x00, 0x00 }),
295. .boolean => |b| try self.byte(if (b) 0xc3 else 0xc2),
296. .number => |n| try self.writeNumber(n),
297. .str => |s| try self.writeStr(s),
298. .bin => |s| {
299. if (s.len <= 0xff) {
300. try self.byte(0xc4);
301. try self.byte(@intCast(s.len));
302. } else if (s.len <= 0xffff) {
303. try self.byte(0xc5);
304. try self.big(u16, @intCast(s.len));
305. } else {
306. try self.byte(0xc6);
307. try self.big(u32, @intCast(s.len));
308. }
309. try self.raw(s);
310. },
311. .array => |items| {
312. if (items.len <= 15) {
313. try self.byte(0x90 | @as(u8, @intCast(items.len)));
314. } else if (items.len <= 0xffff) {
315. try self.byte(0xdc);
316. try self.big(u16, @intCast(items.len));
317. } else {
318. try self.byte(0xdd);
319. try self.big(u32, @intCast(items.len));
320. }
321. for (items) |it| try self.writeValue(it);
322. },
323. .map => |entries| {
324. // msgpackr: objects are ALWAYS map16, >65535 keys throws.
325. if (entries.len > 0xffff) return Error.MapTooLarge;
326. try self.byte(0xde);
327. try self.big(u16, @intCast(entries.len));
328. for (entries) |e| {
329. try self.writeValue(e.key);
330. try self.writeValue(e.value);
331. }
332. },
333. .ext => |e| {
334. switch (e.data.len) {
335. 1 => try self.byte(0xd4),
336. 2 => try self.byte(0xd5),
337. 4 => try self.byte(0xd6),
338. 8 => try self.byte(0xd7),
339. 16 => try self.byte(0xd8),
340. else => {
341. if (e.data.len <= 0xff) {
342. try self.byte(0xc7);
343. try self.byte(@intCast(e.data.len));
344. } else if (e.data.len <= 0xffff) {
345. try self.byte(0xc8);
346. try self.big(u16, @intCast(e.data.len));
347. } else {
348. try self.byte(0xc9);
349. try self.big(u32, @intCast(e.data.len));
350. }
351. },
352. }
353. try self.byte(@bitCast(e.type));
354. try self.raw(e.data);
355. },
356. }
357. }
358. };
360. // =========================================================================
361. // mpackdb record framing: [4-byte LE total size incl. prefix][msgpack]
362. // =========================================================================
364. /// Serialize a value with mpackdb's 4-byte little-endian length prefix.
365. pub fn serialize(alloc: std.mem.Allocator, value: Value) Error![]u8 {
366. var buf: std.ArrayList(u8) = .empty;
367. errdefer buf.deinit(alloc);
368. buf.appendSlice(alloc, &[_]u8{ 0, 0, 0, 0 }) catch return Error.OutOfMemory;
369. try encodeInto(alloc, &buf, value);
370. const total: u32 = @intCast(buf.items.len);
371. std.mem.writeInt(u32, buf.items[0..4], total, .little);
372. return buf.toOwnedSlice(alloc) catch Error.OutOfMemory;
373. }
375. /// Read the length prefix of a framed record (total size incl. the 4 bytes).
376. pub fn readSize(bytes: []const u8) Error!u32 {
377. if (bytes.len < 4) return Error.Truncated;
378. return std.mem.readInt(u32, bytes[0..4], .little);
379. }
381. /// Deserialize a framed record ([4-byte LE size][msgpack]).
382. pub fn deserializeFramed(alloc: std.mem.Allocator, bytes: []const u8) Error!Value {
383. const total = try readSize(bytes);
384. if (total < 5 or total > bytes.len) return Error.Truncated;
385. const d = try decode(alloc, bytes[4..total]);
386. return d.value;
387. }
389. // =========================================================================
390. // Tests
391. // =========================================================================
393. const testing = std.testing;
395. /// Linux-syscall file read (plugins avoid std.Io plumbing; same pattern as
396. /// plugins/fs/fs.zig). Returns null when the file cannot be opened.
397. fn readFileLinux(alloc: std.mem.Allocator, path: []const u8) ?[]u8 {
398. const linux = std.os.linux;
399. const path_z = alloc.dupeZ(u8, path) catch return null;
400. defer alloc.free(path_z);
401. const rc = linux.open(path_z, .{}, 0);
402. const fd: i32 = @bitCast(@as(u32, @truncate(rc)));
403. if (fd < 0) return null;
404. defer _ = linux.close(fd);
405. var content: std.ArrayList(u8) = .empty;
406. var buf: [65536]u8 = undefined;
407. while (true) {
408. const n = linux.read(fd, &buf, buf.len);
409. if (@as(isize, @bitCast(n)) <= 0) break;
410. content.appendSlice(alloc, buf[0..n]) catch return null;
411. }
412. return content.toOwnedSlice(alloc) catch null;
413. }
415. test "corpus: decode + canonical re-encode is byte-identical (msgpackr 1.11.5)" {
416. var arena = std.heap.ArenaAllocator.init(testing.allocator);
417. defer arena.deinit();
418. const alloc = arena.allocator();
420. // Corpus lives next to this file; zig build test runs with cwd native/.
421. const candidates = [_][]const u8{
422. "../plugins/mpackdb/testdata/corpus.json",
423. "plugins/mpackdb/testdata/corpus.json",
424. };
425. var content: ?[]u8 = null;
426. for (candidates) |p| {
427. content = readFileLinux(alloc, p) orelse continue;
428. break;
429. }
430. const json = content orelse return error.CorpusNotFound;
432. const parsed = try std.json.parseFromSlice(std.json.Value, alloc, json, .{});
433. const arr = parsed.value.array;
434. try testing.expect(arr.items.len >= 70);
436. var checked: usize = 0;
437. for (arr.items) |item| {
438. const obj = item.object;
439. const hex = obj.get("hex").?.string;
440. const framed = if (obj.get("framed")) |f| f.bool else false;
441. const bytes = try alloc.alloc(u8, hex.len / 2);
442. _ = try std.fmt.hexToBytes(bytes, hex);
444. if (framed) {
445. // Frame round-trip: parse prefix, decode, re-serialize, compare all.
446. const total = try readSize(bytes);
447. try testing.expectEqual(bytes.len, @as(usize, total));
448. const v = try deserializeFramed(alloc, bytes);
449. const re = try serialize(alloc, v);
450. try testing.expectEqualSlices(u8, bytes, re);
451. } else {
452. const d = try decode(alloc, bytes);
453. try testing.expectEqual(bytes.len, d.len);
454. const re = try encode(alloc, d.value);
455. try testing.expectEqualSlices(u8, bytes, re);
456. }
457. checked += 1;
458. }
459. try testing.expect(checked == arr.items.len);
460. }
462. test "decode spot checks" {
463. var arena = std.heap.ArenaAllocator.init(testing.allocator);
464. defer arena.deinit();
465. const alloc = arena.allocator();
467. // {name:'Alice', age:30} as msgpackr encodes it (map16)
468. var bytes: [19]u8 = undefined;
469. _ = try std.fmt.hexToBytes(&bytes, "de0002a46e616d65a5416c696365a36167651e");
470. const d = try decode(alloc, &bytes);
471. const name = d.value.get("name").?;
472. try testing.expectEqualStrings("Alice", name.str);
473. try testing.expectEqual(@as(f64, 30), d.value.get("age").?.number);
474. }
476. test "decode non-canonical families (full spec)" {
477. var arena = std.heap.ArenaAllocator.init(testing.allocator);
478. defer arena.deinit();
479. const alloc = arena.allocator();
481. // fixmap {a:1}
482. var b1: [4]u8 = undefined;
483. _ = try std.fmt.hexToBytes(&b1, "81a16101");
484. const v1 = try decode(alloc, &b1);
485. try testing.expectEqual(@as(f64, 1), v1.value.get("a").?.number);
487. // map32 {a:1}
488. var b2: [8]u8 = undefined;
489. _ = try std.fmt.hexToBytes(&b2, "df00000001a16101");
490. const v2 = try decode(alloc, &b2);
491. try testing.expectEqual(@as(f64, 1), v2.value.get("a").?.number);
493. // int64 -1 (d3 ffffffffffffffff)
494. var b3: [9]u8 = undefined;
495. _ = try std.fmt.hexToBytes(&b3, "d3ffffffffffffffff");
496. const v3 = try decode(alloc, &b3);
497. try testing.expectEqual(@as(f64, -1), v3.value.number);
499. // uint64 2^32 (cf 0000000100000000)
500. var b4: [9]u8 = undefined;
501. _ = try std.fmt.hexToBytes(&b4, "cf0000000100000000");
502. const v4 = try decode(alloc, &b4);
503. try testing.expectEqual(@as(f64, 4294967296), v4.value.number);
505. // float32 0.5 (ca 3f000000)
506. var b5: [5]u8 = undefined;
507. _ = try std.fmt.hexToBytes(&b5, "ca3f000000");
508. const v5 = try decode(alloc, &b5);
509. try testing.expectEqual(@as(f64, 0.5), v5.value.number);
511. // 0xc1 is invalid
512. const bad = [_]u8{0xc1};
513. try testing.expectError(Error.InvalidFormat, decode(alloc, &bad));
514. }
516. test "undefined is distinct and byte-exact" {
517. var arena = std.heap.ArenaAllocator.init(testing.allocator);
518. defer arena.deinit();
519. const alloc = arena.allocator();
520. const bytes = [_]u8{ 0xd4, 0x00, 0x00 };
521. const d = try decode(alloc, &bytes);
522. try testing.expect(d.value == .undef);
523. const re = try encode(alloc, d.value);
524. try testing.expectEqualSlices(u8, &bytes, re);
525. }
527. test "timestamp ext interpretation" {
528. var arena = std.heap.ArenaAllocator.init(testing.allocator);
529. defer arena.deinit();
530. const alloc = arena.allocator();
532. // date whole sec: d6 ff 66a39486 → 1721996422000 ms
533. var b: [6]u8 = undefined;
534. _ = try std.fmt.hexToBytes(&b, "d6ff66a39486");
535. const d = try decode(alloc, &b);
536. try testing.expectEqual(@as(f64, 1721996422000), d.value.timestampMs().?);
538. // date ms: d7 ff 1d53530066a39486 → 1721996422123 ms
539. var b2: [10]u8 = undefined;
540. _ = try std.fmt.hexToBytes(&b2, "d7ff1d53530066a39486");
541. const d2 = try decode(alloc, &b2);
542. try testing.expectApproxEqAbs(@as(f64, 1721996422123), d2.value.timestampMs().?, 0.001);
543. }
545. test "framing" {
546. var arena = std.heap.ArenaAllocator.init(testing.allocator);
547. defer arena.deinit();
548. const alloc = arena.allocator();
550. var entries = [_]Entry{
551. .{ .key = .{ .str = "id" }, .value = .{ .number = 1 } },
552. };
553. const v = Value{ .map = &entries };
554. const framed = try serialize(alloc, v);
555. try testing.expectEqual(@as(u32, @intCast(framed.len)), try readSize(framed));
556. const back = try deserializeFramed(alloc, framed);
557. try testing.expectEqual(@as(f64, 1), back.get("id").?.number);
558. }
560. test "encode number boundaries match msgpackr" {
561. var arena = std.heap.ArenaAllocator.init(testing.allocator);
562. defer arena.deinit();
563. const alloc = arena.allocator();
564. const cases = [_]struct { v: f64, hex: []const u8 }{
565. .{ .v = 0, .hex = "00" },
566. .{ .v = 127, .hex = "7f" },
567. .{ .v = 128, .hex = "cc80" },
568. .{ .v = 256, .hex = "cd0100" },
569. .{ .v = 65536, .hex = "ce00010000" },
570. .{ .v = 2147483648, .hex = "ce80000000" },
571. .{ .v = 4294967296, .hex = "cb41f0000000000000" },
572. .{ .v = -1, .hex = "ff" },
573. .{ .v = -32, .hex = "e0" },
574. .{ .v = -33, .hex = "d0df" },
575. .{ .v = -129, .hex = "d1ff7f" },
576. .{ .v = -32769, .hex = "d2ffff7fff" },
577. .{ .v = -2147483648, .hex = "d280000000" },
578. .{ .v = -2147483649, .hex = "cbc1e0000000200000" },
579. .{ .v = 0.5, .hex = "cb3fe0000000000000" },
580. };
581. for (cases) |c| {
582. const enc = try encode(alloc, Value{ .number = c.v });
583. const expect_bytes = try alloc.alloc(u8, c.hex.len / 2);
584. _ = try std.fmt.hexToBytes(expect_bytes, c.hex);
585. try testing.expectEqualSlices(u8, expect_bytes, enc);
586. }
587. }