59f0aa7716
allocators/fs/process/socket/log/trace/test move under modules/std/ (allocators.sx becomes std/mem.sx; the Allocator protocol moves into the std.sx prelude, impls stay in mem.sx). New std/xml.sx holds xml_escape as xml.escape. std.sx gains the carried namespace tail — flat-importing std.sx now also provides mem./xml./log. — with the remaining modules (fs/process/socket/json/cli/hash/test) deferred from the tail until the global last-wins maps are fully own-wins (pulling them into every closure collides bare names corpus-wide; they stay direct imports: modules/std/fs.sx etc.). log.sx's internal emit renamed log_emit (it clobbered consumer fns named emit program-wide). bundle.sx uses xml.escape via the carried alias. Consumer import paths swept mechanically; .ir snapshots recaptured for the larger std closure. m3te + game build unchanged.
108 lines
4.6 KiB
Plaintext
108 lines
4.6 KiB
Plaintext
// JSON value model + writer from `modules/std/json.sx`.
|
||
//
|
||
// Builds a representative value — a nested object holding a string with
|
||
// every escape kind (quote, newline, tab, backslash, a raw control byte),
|
||
// integers spanning zero / a small negative / a small positive / s64 MIN
|
||
// (-9223372036854775808) / s64 MAX (9223372036854775807), a bool, null, an
|
||
// array, and a nested object — then serializes it two ways and asserts the
|
||
// EXACT bytes:
|
||
//
|
||
// 1. into a caller-owned `[]u8` buffer (returns bytes written),
|
||
// 2. streaming straight to a file through an 8-byte staging buffer
|
||
// (small on purpose, so the writer flushes many times and no
|
||
// whole-document string is ever held).
|
||
//
|
||
// Both must yield byte-for-byte the same pinned document, with keys in
|
||
// INSERTION ORDER. A too-small buffer must raise `error.Overflow` rather
|
||
// than truncate. The model is built through an explicit Arena allocator
|
||
// and freed in one `deinit`; the writer path allocates nothing.
|
||
|
||
#import "modules/std.sx";
|
||
#import "modules/std/mem.sx"; // `Allocator` is non-transitive: name it, import it.
|
||
#import "modules/std/json.sx";
|
||
#import "modules/std/fs.sx";
|
||
|
||
// The exact document the writer must produce (insertion order, escaping).
|
||
EXPECT :: "{\"name\":\"a\\\"b\\n\",\"tab\":\"x\\ty\",\"bs\":\"c\\\\d\",\"ctrl\":\"\\u0001\",\"n\":-7,\"zero\":0,\"pos\":7,\"min\":-9223372036854775808,\"max\":9223372036854775807,\"ok\":true,\"nil\":null,\"xs\":[1,-2,3],\"nested\":{\"k\":\"v\"}}";
|
||
|
||
report :: (label: string, ok: bool) {
|
||
if ok { print("{}: ok\n", label); } else { print("{}: FAIL\n", label); }
|
||
}
|
||
|
||
build :: (alloc: Allocator) -> Value {
|
||
// A raw control byte (0x01) viewed as a 1-byte string — exercises the
|
||
// `\u00XX` path that has no named shorthand. String values are VIEWS,
|
||
// so the bytes must outlive the writes: back them with `alloc` (the
|
||
// arena), not a local that dies when `build` returns.
|
||
cbytes : [*]u8 = xx alloc.alloc(1);
|
||
cbytes[0] = 1;
|
||
ctrl := string.{ ptr = cbytes, len = 1 };
|
||
|
||
nested : Object = .{};
|
||
nested.put("k", .str("v"), alloc);
|
||
|
||
xs : Array = .{};
|
||
xs.add(.int_(1), alloc);
|
||
xs.add(.int_(0 - 2), alloc);
|
||
xs.add(.int_(3), alloc);
|
||
|
||
obj : Object = .{};
|
||
obj.put("name", .str("a\"b\n"), alloc); // quote + newline
|
||
obj.put("tab", .str("x\ty"), alloc); // tab
|
||
obj.put("bs", .str("c\\d"), alloc); // backslash
|
||
obj.put("ctrl", .str(ctrl), alloc); // raw control byte ->
|
||
obj.put("n", .int_(0 - 7), alloc); // small negative int
|
||
obj.put("zero", .int_(0), alloc); // zero
|
||
obj.put("pos", .int_(7), alloc); // small positive int
|
||
// s64 MIN: its magnitude (9223372036854775808) is not a representable
|
||
// positive s64 literal, so build it from MAX-positive minus one.
|
||
obj.put("min", .int_(0 - 9223372036854775807 - 1), alloc);
|
||
obj.put("max", .int_(9223372036854775807), alloc); // s64 MAX
|
||
obj.put("ok", .bool_(true), alloc);
|
||
obj.put("nil", .null_, alloc);
|
||
obj.put("xs", .array(xs), alloc);
|
||
obj.put("nested", .object(nested), alloc);
|
||
|
||
return .object(obj);
|
||
}
|
||
|
||
main :: () -> ! {
|
||
gpa := GPA.init();
|
||
arena := Arena.init(xx gpa, 4096);
|
||
defer arena.deinit();
|
||
|
||
root := build(xx arena);
|
||
|
||
// 1. Write into a caller buffer; assert exact bytes + byte count.
|
||
buf : [512]u8 = ---;
|
||
n := try write_to_buffer(root, string.{ ptr = @buf[0], len = 512 });
|
||
view := string.{ ptr = @buf[0], len = n };
|
||
print("doc: {}\n", view);
|
||
report("buffer-exact", view == EXPECT);
|
||
report("buffer-len", n == EXPECT.len);
|
||
|
||
// 2. A buffer that is one byte too small must raise Overflow.
|
||
tight : []u8 = string.{ ptr = @buf[256], len = EXPECT.len - 1 };
|
||
_, oerr := write_to_buffer(root, tight);
|
||
report("overflow-raised", oerr == error.Overflow);
|
||
|
||
// 3. Stream to a file through a tiny staging buffer (forces flushes);
|
||
// read it back and assert it equals the same document. Write into the
|
||
// repo-local, gitignored scratch dir and unlink afterwards so nothing
|
||
// leaks and concurrent runs don't fight over a shared /tmp name.
|
||
if !create_dir_all(".sx-tmp") { print("mkdir: FAIL\n"); return; }
|
||
path := ".sx-tmp/sx_0713_json.json";
|
||
fh := open_file(path, .write);
|
||
if fh == null { print("open: FAIL\n"); return; }
|
||
f := fh!;
|
||
stage : [8]u8 = ---;
|
||
try write_to_file(root, @f, string.{ ptr = @stage[0], len = 8 });
|
||
f.close();
|
||
|
||
back := read_file(path);
|
||
delete_file(path);
|
||
if back == null { print("file-read: FAIL\n"); return; }
|
||
report("file-exact", back! == EXPECT);
|
||
return;
|
||
}
|