1 files changed, 63 insertions, 15 deletions

diff --git a/src/libzisp.zig b/src/libzisp.zig
index f67f568..3a217fd 100644
--- a/src/libzisp.zig
+++ b/src/libzisp.zig
@@ -47,7 +47,7 @@ test "ptr" {
     const ptr = value.ptr;
 
     const val: [*]Hval = @ptrFromInt(256);
-    const tag = ptr.Tag.istr;
+    const tag = ptr.Tag.pair;
 
     const p = ptr.pack(val, tag);
     try std.testing.expect(ptr.check(p));
@@ -246,6 +246,31 @@ test "pair" {
     try std.testing.expectEqual(4, value.fixnum.unpack(cdr2));
 }
 
+test "istr" {
+    const istr = value.istr;
+    const fx = value.fixnum;
+
+    const s1 = "foo bar baz";
+    const v1 = istr.intern(s1, false);
+    const v1_len: usize = @intCast(fx.unpack(istr.len(v1)));
+    try std.testing.expectEqualStrings(s1, istr.getHeader(v1).bytes());
+    try std.testing.expectEqual(s1.len, v1_len);
+
+    const file = try std.fs.cwd().openFile("test-data/string.txt", .{});
+    defer file.close();
+    var s2_buf: [4096]u8 = undefined;
+    const s2_len = try file.readAll(&s2_buf);
+    var s2: []u8 = s2_buf[0..s2_len];
+    const v2 = istr.intern(s2, false);
+    const v2_len: usize = @intCast(fx.unpack(istr.len(v2)));
+    var s2_orig_buf: [4096]u8 = undefined;
+    @memcpy(&s2_orig_buf, &s2_buf);
+    const s2_orig = s2_orig_buf[0..s2_len];
+    s2[0] = s2[0] +% 1;
+    try std.testing.expectEqualStrings(s2_orig, istr.getHeader(v2).bytes());
+    try std.testing.expectEqual(s2_len, v2_len);
+}
+
 fn parseString(str: []const u8) Value {
     var fbs = std.io.fixedBufferStream(str);
     return io.parser.parse(fbs.reader().any());
@@ -303,42 +328,65 @@ test "parse4" {
     try std.testing.expectEqualStrings("bar", f.slice());
 }
 
-test "parse bench" {
+fn parseBench(path: []const u8) !void {
     const iters = switch (@import("builtin").mode) {
         .Debug, .ReleaseSmall => 1000,
         .ReleaseSafe => 10_000,
         .ReleaseFast => 100_000,
     };
+
+    var buf: [8196]u8 = undefined;
+    const file = try std.fs.cwd().openFile(path, .{});
+    defer file.close();
+    const count = try file.readAll(&buf);
+
+    var fbs = std.io.fixedBufferStream(buf[0..count]);
+    const reader = fbs.reader().any();
+
     var timer = try std.time.Timer.start();
-    std.mem.doNotOptimizeAway(timer.lap());
     for (0..iters) |i| {
         _ = i;
-        std.mem.doNotOptimizeAway(parseString(
-            \\(a b c (x y z (a b c (x y z (a b c (x y z (a b c (x y z (a b c
-            \\(x y z (a b c (x y z (a b c (x y z) d e f) d e f) d e f) d e f)
-            \\d e f) d e f) d e f) d e f) d e f) d e f) d e f) 1 2 3))
-        ));
+        var v: Value = undefined;
+        while (true) {
+            v = io.parser.parse(reader);
+            if (value.eof.check(v)) {
+                break;
+            }
+        }
+        try fbs.seekTo(0);
     }
     const ns: f64 = @floatFromInt(timer.lap());
     const secs = ns / 1_000_000_000;
-    std.debug.print("parse {} times: {d:.3}s\n", .{ iters, secs });
+    std.debug.print(
+        "parse {s} x {}: {d:.3}s\n",
+        .{ path, iters, secs },
+    );
 }
 
-test "unparse" {
-    const unparse = io.unparser.unparse;
+test "parse bench" {
+    try parseBench("test-data/parser-test-1.scm");
+    try parseBench("test-data/parser-test-2.scm");
+}
 
+test "unparse" {
     var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
     var out: std.ArrayList(u8) = .init(gpa.allocator());
 
     const w = out.writer();
     const v = parseString("#foo");
-    try unparse(w, v);
+    try io.unparser.unparse(w, v);
     try std.testing.expectEqualStrings("#foo", try out.toOwnedSlice());
 }
 
 test "unparse2" {
-    try io.unparser.unparse(
-        std.io.getStdErr().writer(),
-        parseString("#{foo bar['x]}"),
+    var gpa: std.heap.GeneralPurposeAllocator(.{}) = .init;
+    var out: std.ArrayList(u8) = .init(gpa.allocator());
+
+    const w = out.writer();
+    const v = parseString("#{foo bar['x]}");
+    try io.unparser.unparse(w, v);
+    try std.testing.expectEqualStrings(
+        "(#HASH #BRACE foo (#JOIN bar #SQUARE (#QUOTE . x)))",
+        try out.toOwnedSlice(),
     );
 }