From 75185f9fa26b5fc49036008df16c8bb4f1a51a13 Mon Sep 17 00:00:00 2001
From: Taylan Kammer <taylan.kammer@gmail.com>
Date: Tue, 6 Jan 2026 07:45:07 +0100
Subject: Writergate, other 0.16 changes, and test fixes for new grammar.

---
 src/test/parse.zig | 61 +++++++++++++++++++++++++++---------------------------
 1 file changed, 30 insertions(+), 31 deletions(-)

(limited to 'src/test/parse.zig')

diff --git a/src/test/parse.zig b/src/test/parse.zig
index dd26098..8c44454 100644
--- a/src/test/parse.zig
+++ b/src/test/parse.zig
@@ -3,14 +3,16 @@ const std = @import("std");
 const testing = std.testing;
 const expect = testing.expect;
 
+const gstIo = std.Io.Threaded.global_single_threaded.io();
+
 pub const io = @import("../zisp/io.zig");
 pub const value = @import("../zisp/value.zig");
 
 pub const Value = value.Value;
 
 fn parse(str: []const u8) Value {
-    var fbs = std.io.fixedBufferStream(str);
-    return io.parser.parse(fbs.reader().any());
+    var fbs = std.Io.Reader.fixed(str);
+    return io.parser.parse(&fbs);
 }
 
 test "parse empty" {
@@ -42,7 +44,7 @@ test "parse short bare string" {
     try expect(parse("|x()|").eq(str("x()")));
     try expect(parse("|{\\|}|").eq(str("{|}")));
     try expect(parse("foobar").eq(str("foobar")));
-    try expect(parse("!$%&*+").eq(str("!$%&*+")));
+    try expect(parse("!$%.*+").eq(str("!$%.*+")));
     try expect(parse("-/<=>?").eq(str("-/<=>?")));
     try expect(parse("@^_~00").eq(str("@^_~00")));
 }
@@ -54,7 +56,7 @@ test "parse long bare string" {
     try expect(parse("+foo.bar.baz").eq(str("+foo.bar.baz")));
     try expect(parse("-foo.bar.baz").eq(str("-foo.bar.baz")));
     try expect(parse("0foo.bar.baz").eq(str("0foo.bar.baz")));
-    try expect(parse("!$%&*+-/<=>?@^_~").eq(str("!$%&*+-/<=>?@^_~")));
+    try expect(parse("!$%*+-./<=>?@^_~").eq(str("!$%*+-./<=>?@^_~")));
     try expect(parse("|foo\\x20;bar\\x0a;baz|").eq(str("foo bar\nbaz")));
 }
 
@@ -104,7 +106,7 @@ test "parse3" {
 }
 
 test "parse4" {
-    const val = parse("(foo . ;~x bar ;~y)");
+    const val = parse("(foo & ;~x bar ;~y)");
 
     const s = value.sstr.unpack(value.pair.car(val));
     try testing.expectEqualStrings("foo", s.slice());
@@ -114,33 +116,33 @@ test "parse4" {
 }
 
 test "unparse" {
-    var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
-    var out: std.ArrayList(u8) = .init(gpa.allocator());
-
-    const w = out.writer();
+    var buf: [32]u8 = undefined;
+    var w = std.Io.Writer.fixed(&buf);
     const v = parse("#foo");
-    try io.unparser.unparse(w, v);
-    try testing.expectEqualStrings("#foo", try out.toOwnedSlice());
+    try io.unparser.unparse(&w, v);
+    try testing.expectEqualStrings("#foo", buf[0..w.end]);
 }
 
 test "unparse2" {
-    var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
-    var out: std.ArrayList(u8) = .init(gpa.allocator());
-
-    const w = out.writer();
+    var buf: [128]u8 = undefined;
+    var w = std.Io.Writer.fixed(&buf);
     const v = parse("#{foo bar['x]}");
-    try io.unparser.unparse(w, v);
+    try io.unparser.unparse(&w, v);
     try testing.expectEqualStrings(
-        "(#HASH #BRACE foo (#JOIN bar #SQUARE (#QUOTE . x)))",
-        try out.toOwnedSlice(),
+        "(#HASH #BRACE foo (#JOIN bar #SQUARE (#QUOTE & x)))",
+        buf[0..w.end],
     );
 }
 
 fn writeParseResult(str: []const u8) !void {
-    const w = std.io.getStdErr().writer();
+    var buf: [64]u8 = undefined;
+    var fw = std.Io.File.stderr().writer(gstIo, &buf);
+    const w = &fw.interface;
+
     const v = parse(str);
     try io.unparser.unparse(w, v);
     try w.writeByte('\n');
+    try w.flush();
 }
 
 test "unparse3" {
@@ -152,7 +154,7 @@ test "unparse4" {
 }
 
 test "unparse5" {
-    try writeParseResult("(;~foo foo ;~bar . ;~bar bar ;~bar)");
+    try writeParseResult("(;~foo foo ;~bar & ;~bar bar ;~bar)");
 }
 
 test "unparse6" {
@@ -160,12 +162,12 @@ test "unparse6" {
 }
 
 test "unparse7" {
-    try writeParseResult("#`(#,(->keyword (syntax->datum #'sym)) . in)");
+    try writeParseResult("#`(#,(->keyword (syntax->datum #'sym)) & in)");
 }
 
 fn parseBench(path: []const u8, iters: usize) !void {
-    const file = try std.fs.cwd().openFile(path, .{});
-    defer file.close();
+    const file = try std.Io.Dir.cwd().openFile(gstIo, path, .{});
+    defer file.close(gstIo);
 
     var sfa = io.parser.DefaultSfa.init(std.heap.smp_allocator);
     var parser = try io.parser.initSfa(&sfa);
@@ -174,24 +176,21 @@ fn parseBench(path: []const u8, iters: usize) !void {
     var timer = try std.time.Timer.start();
     for (0..iters) |i| {
         _ = i;
-        var br = std.io.bufferedReader(file.reader());
-        const reader = br.reader().any();
-        // const reader = file.reader().any();
+        var buf: [4096]u8 = undefined;
+        var reader = file.reader(gstIo, &buf);
         var v: Value = undefined;
         while (true) {
-            // std.debug.print("hihi {s}\n", .{path});
-            v = parser.run(reader) catch |e| {
+            v = parser.run(&reader.interface) catch |e| {
                 std.debug.print("\nfile pos: {}\n", .{
-                    try file.getPos(),
+                    reader.logicalPos(),
                 });
                 return e;
             };
-            // try io.unparser.unparse(std.io.getStdOut().writer().any(), v);
             if (value.eof.eq(v)) {
                 break;
             }
         }
-        try file.seekTo(0);
+        try reader.seekTo(0);
     }
     const ns: f64 = @floatFromInt(timer.lap());
     const secs = ns / 1_000_000_000;
-- 
cgit v1.2.3