authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-02-17 19:49:36-08:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2025-07-01 16:35:26-07:00
log051c7af49ad3e3d4575fd63c68cf96eff144bed7
treeaaa629b7e8c38bdbd94fcd1a47e020a22a28224a
parente154b62d63539cdd0f281dd4eaadc5ab229d2e24

get std lib json tests passing

7 files changed, 95 insertions(+), 127 deletions(-)

lib/std/io/BufferedWriter.zig+2-2
......@@ -757,9 +757,9 @@ pub fn printValue(
757757 return printValue(bw, actual_fmt, options, value.*, max_depth);
758758 },
759759 else => {
760 const buffers: [2][]const u8 = .{ @typeName(ptr_info.child), "@" };
760 var buffers: [2][]const u8 = .{ @typeName(ptr_info.child), "@" };
761761 try writevAll(bw, &buffers);
762 try printIntOptions(bw, @intFromPtr(value), 16, .lower);
762 try printIntOptions(bw, @intFromPtr(value), 16, .lower, options);
763763 },
764764 },
765765 .many, .c => {
lib/std/io/Writer.zig+17
......@@ -76,6 +76,23 @@ pub fn writeFile(
7676 return w.vtable.writeFile(w.context, file, offset, len, headers_and_trailers, headers_len);
7777}
7878
79pub fn unimplemented_writeFile(
80 context: *anyopaque,
81 file: std.fs.File,
82 offset: u64,
83 len: VTable.FileLen,
84 headers_and_trailers: []const []const u8,
85 headers_len: usize,
86) anyerror!usize {
87 _ = context;
88 _ = file;
89 _ = offset;
90 _ = len;
91 _ = headers_and_trailers;
92 _ = headers_len;
93 return error.Unimplemented;
94}
95
7996pub fn write(w: Writer, bytes: []const u8) anyerror!usize {
8097 const single: [1][]const u8 = .{bytes};
8198 return w.vtable.writeSplat(w.context, &single, 1);
lib/std/json/Stringify.zig+59-106
......@@ -24,8 +24,10 @@ const ArrayList = std.ArrayList;
2424const BitStack = std.BitStack;
2525const Stringify = @This();
2626
27const OBJECT_MODE = 0;
28const ARRAY_MODE = 1;
27const IndentationMode = enum(u1) {
28 object = 0,
29 array = 1,
30};
2931
3032writer: *std.io.BufferedWriter,
3133options: Options = .{},
......@@ -78,22 +80,22 @@ else
7880pub fn beginArray(self: *Stringify) anyerror!void {
7981 if (build_mode_has_safety) assert(self.raw_streaming_mode == .none);
8082 try self.valueStart();
81 try self.stream.writeByte('[');
82 try self.pushIndentation(ARRAY_MODE);
83 try self.writer.writeByte('[');
84 try self.pushIndentation(.array);
8385 self.next_punctuation = .none;
8486}
8587
8688pub fn beginObject(self: *Stringify) anyerror!void {
8789 if (build_mode_has_safety) assert(self.raw_streaming_mode == .none);
8890 try self.valueStart();
89 try self.stream.writeByte('{');
90 try self.pushIndentation(OBJECT_MODE);
91 try self.writer.writeByte('{');
92 try self.pushIndentation(.object);
9193 self.next_punctuation = .none;
9294}
9395
9496pub fn endArray(self: *Stringify) anyerror!void {
9597 if (build_mode_has_safety) assert(self.raw_streaming_mode == .none);
96 self.popIndentation(ARRAY_MODE);
98 self.popIndentation(.array);
9799 switch (self.next_punctuation) {
98100 .none => {},
99101 .comma => {
......@@ -101,13 +103,13 @@ pub fn endArray(self: *Stringify) anyerror!void {
101103 },
102104 .the_beginning, .colon => unreachable,
103105 }
104 try self.stream.writeByte(']');
106 try self.writer.writeByte(']');
105107 self.valueDone();
106108}
107109
108110pub fn endObject(self: *Stringify) anyerror!void {
109111 if (build_mode_has_safety) assert(self.raw_streaming_mode == .none);
110 self.popIndentation(OBJECT_MODE);
112 self.popIndentation(.object);
111113 switch (self.next_punctuation) {
112114 .none => {},
113115 .comma => {
......@@ -115,24 +117,24 @@ pub fn endObject(self: *Stringify) anyerror!void {
115117 },
116118 .the_beginning, .colon => unreachable,
117119 }
118 try self.stream.writeByte('}');
120 try self.writer.writeByte('}');
119121 self.valueDone();
120122}
121123
122fn pushIndentation(self: *Stringify, mode: u1) !void {
124fn pushIndentation(self: *Stringify, mode: IndentationMode) !void {
123125 switch (safety_checks) {
124126 .checked_to_fixed_depth => {
125 BitStack.pushWithStateAssumeCapacity(&self.nesting_stack, &self.indent_level, mode);
127 BitStack.pushWithStateAssumeCapacity(&self.nesting_stack, &self.indent_level, @intFromEnum(mode));
126128 },
127129 .assumed_correct => {
128130 self.indent_level += 1;
129131 },
130132 }
131133}
132fn popIndentation(self: *Stringify, assert_its_this_one: u1) void {
134fn popIndentation(self: *Stringify, expected_mode: IndentationMode) void {
133135 switch (safety_checks) {
134136 .checked_to_fixed_depth => {
135 assert(BitStack.popWithState(&self.nesting_stack, &self.indent_level) == assert_its_this_one);
137 assert(BitStack.popWithState(&self.nesting_stack, &self.indent_level) == @intFromEnum(expected_mode));
136138 },
137139 .assumed_correct => {
138140 self.indent_level -= 1;
......@@ -154,8 +156,8 @@ fn indent(self: *Stringify) !void {
154156 break :blk self.indent_level;
155157 },
156158 };
157 try self.stream.writeByte('\n');
158 try self.stream.writeByteNTimes(char, n_chars);
159 try self.writer.writeByte('\n');
160 try self.writer.splatByteAll(char, n_chars);
159161}
160162
161163fn valueStart(self: *Stringify) !void {
......@@ -178,13 +180,13 @@ fn valueStartAssumeTypeOk(self: *Stringify) !void {
178180 },
179181 .comma => {
180182 // Subsequent item in a container.
181 try self.stream.writeByte(',');
183 try self.writer.writeByte(',');
182184 try self.indent();
183185 },
184186 .colon => {
185 try self.stream.writeByte(':');
187 try self.writer.writeByte(':');
186188 if (self.options.whitespace != .minified) {
187 try self.stream.writeByte(' ');
189 try self.writer.writeByte(' ');
188190 }
189191 },
190192 }
......@@ -197,7 +199,7 @@ fn valueDone(self: *Stringify) void {
197199fn isObjectKeyExpected(self: *const Stringify) ?bool {
198200 switch (safety_checks) {
199201 .checked_to_fixed_depth => return self.indent_level > 0 and
200 BitStack.peekWithState(&self.nesting_stack, self.indent_level) == OBJECT_MODE and
202 BitStack.peekWithState(&self.nesting_stack, self.indent_level) == @intFromEnum(IndentationMode.object) and
201203 self.next_punctuation != .colon,
202204 .assumed_correct => return null,
203205 }
......@@ -214,7 +216,7 @@ fn isComplete(self: *const Stringify) bool {
214216pub fn print(self: *Stringify, comptime fmt: []const u8, args: anytype) anyerror!void {
215217 if (build_mode_has_safety) assert(self.raw_streaming_mode == .none);
216218 try self.valueStart();
217 try self.stream.print(fmt, args);
219 try self.writer.print(fmt, args);
218220 self.valueDone();
219221}
220222
......@@ -224,7 +226,6 @@ test print {
224226 out.initFixed(&out_buf);
225227
226228 var w: Stringify = .{ .writer = &out, .options = .{ .whitespace = .indent_2 } };
227 defer w.deinit();
228229
229230 try w.beginObject();
230231 try w.objectField("a");
......@@ -248,8 +249,8 @@ test print {
248249 try std.testing.expectEqualStrings(expected, out.getWritten());
249250}
250251
251/// An alternative to calling `write` that allows you to write directly to the `.stream` field, e.g. with `.stream.writeAll()`.
252/// Call `beginWriteRaw()`, then write a complete value (including any quotes if necessary) directly to the `.stream` field,
252/// An alternative to calling `write` that allows you to write directly to the `.writer` field, e.g. with `.writer.writeAll()`.
253/// Call `beginWriteRaw()`, then write a complete value (including any quotes if necessary) directly to the `.writer` field,
253254/// then call `endWriteRaw()`.
254255/// This can be useful for streaming very long strings into the output without needing it all buffered in memory.
255256pub fn beginWriteRaw(self: *Stringify) !void {
......@@ -276,7 +277,7 @@ pub fn endWriteRaw(self: *Stringify) void {
276277pub fn objectField(self: *Stringify, key: []const u8) anyerror!void {
277278 if (build_mode_has_safety) assert(self.raw_streaming_mode == .none);
278279 try self.objectFieldStart();
279 try encodeJsonString(key, self.options, self.stream);
280 try encodeJsonString(key, self.options, self.writer);
280281 self.next_punctuation = .colon;
281282}
282283/// See `Stringify` for when to call this method.
......@@ -287,12 +288,12 @@ pub fn objectFieldRaw(self: *Stringify, quoted_key: []const u8) anyerror!void {
287288 if (build_mode_has_safety) assert(self.raw_streaming_mode == .none);
288289 assert(quoted_key.len >= 2 and quoted_key[0] == '"' and quoted_key[quoted_key.len - 1] == '"'); // quoted_key should be "quoted".
289290 try self.objectFieldStart();
290 try self.stream.writeAll(quoted_key);
291 try self.writer.writeAll(quoted_key);
291292 self.next_punctuation = .colon;
292293}
293294
294295/// In the rare case that you need to write very long object field names,
295/// this is an alternative to `objectField` and `objectFieldRaw` that allows you to write directly to the `.stream` field
296/// this is an alternative to `objectField` and `objectFieldRaw` that allows you to write directly to the `.writer` field
296297/// similar to `beginWriteRaw`.
297298/// Call `endObjectFieldRaw()` when you're done.
298299pub fn beginObjectFieldRaw(self: *Stringify) !void {
......@@ -351,9 +352,9 @@ pub fn write(self: *Stringify, v: anytype) anyerror!void {
351352 if (self.options.emit_nonportable_numbers_as_strings and
352353 (v <= -(1 << 53) or v >= (1 << 53)))
353354 {
354 try self.stream.print("\"{}\"", .{v});
355 try self.writer.print("\"{}\"", .{v});
355356 } else {
356 try self.stream.print("{}", .{v});
357 try self.writer.print("{}", .{v});
357358 }
358359 self.valueDone();
359360 return;
......@@ -364,25 +365,25 @@ pub fn write(self: *Stringify, v: anytype) anyerror!void {
364365 .float, .comptime_float => {
365366 if (@as(f64, @floatCast(v)) == v) {
366367 try self.valueStart();
367 try self.stream.print("{}", .{@as(f64, @floatCast(v))});
368 try self.writer.print("{}", .{@as(f64, @floatCast(v))});
368369 self.valueDone();
369370 return;
370371 }
371372 try self.valueStart();
372 try self.stream.print("\"{}\"", .{v});
373 try self.writer.print("\"{}\"", .{v});
373374 self.valueDone();
374375 return;
375376 },
376377
377378 .bool => {
378379 try self.valueStart();
379 try self.stream.writeAll(if (v) "true" else "false");
380 try self.writer.writeAll(if (v) "true" else "false");
380381 self.valueDone();
381382 return;
382383 },
383384 .null => {
384385 try self.valueStart();
385 try self.stream.writeAll("null");
386 try self.writer.writeAll("null");
386387 self.valueDone();
387388 return;
388389 },
......@@ -529,7 +530,7 @@ pub fn write(self: *Stringify, v: anytype) anyerror!void {
529530
530531fn stringValue(self: *Stringify, s: []const u8) !void {
531532 try self.valueStart();
532 try encodeJsonString(s, self.options, self.stream);
533 try encodeJsonString(s, self.options, self.writer);
533534 self.valueDone();
534535}
535536
......@@ -564,7 +565,7 @@ pub const Options = struct {
564565 emit_nonportable_numbers_as_strings: bool = false,
565566};
566567
567/// Writes the given value to the `std.io.Writer` stream.
568/// Writes the given value to the `std.io.Writer` writer.
568569/// See `Stringify` for how the given value is serialized into JSON.
569570/// The maximum nesting depth of the output JSON document is 256.
570571pub fn value(v: anytype, options: Options, writer: *std.io.BufferedWriter) anyerror!void {
......@@ -616,7 +617,7 @@ pub fn valueAlloc(gpa: Allocator, v: anytype, options: Options) error{OutOfMemor
616617 var aw: std.io.AllocatingWriter = undefined;
617618 const writer = aw.init(gpa);
618619 defer aw.deinit();
619 try value(v, options, writer);
620 value(v, options, writer) catch return error.OutOfMemory; // TODO: try @errorCast(...)
620621 return aw.toOwnedSlice();
621622}
622623
......@@ -631,27 +632,27 @@ test valueAlloc {
631632 try std.testing.expectEqualStrings(expected, actual);
632633}
633634
634fn outputUnicodeEscape(codepoint: u21, out_stream: *std.io.BufferedWriter) !void {
635fn outputUnicodeEscape(codepoint: u21, bw: *std.io.BufferedWriter) anyerror!void {
635636 if (codepoint <= 0xFFFF) {
636637 // If the character is in the Basic Multilingual Plane (U+0000 through U+FFFF),
637638 // then it may be represented as a six-character sequence: a reverse solidus, followed
638639 // by the lowercase letter u, followed by four hexadecimal digits that encode the character's code point.
639 try out_stream.writeAll("\\u");
640 try std.fmt.formatIntValue(codepoint, "x", std.fmt.FormatOptions{ .width = 4, .fill = '0' }, out_stream);
640 try bw.writeAll("\\u");
641 try bw.printInt("x", .{ .width = 4, .fill = '0' }, codepoint);
641642 } else {
642643 assert(codepoint <= 0x10FFFF);
643644 // To escape an extended character that is not in the Basic Multilingual Plane,
644645 // the character is represented as a 12-character sequence, encoding the UTF-16 surrogate pair.
645646 const high = @as(u16, @intCast((codepoint - 0x10000) >> 10)) + 0xD800;
646647 const low = @as(u16, @intCast(codepoint & 0x3FF)) + 0xDC00;
647 try out_stream.writeAll("\\u");
648 try std.fmt.formatIntValue(high, "x", std.fmt.FormatOptions{ .width = 4, .fill = '0' }, out_stream);
649 try out_stream.writeAll("\\u");
650 try std.fmt.formatIntValue(low, "x", std.fmt.FormatOptions{ .width = 4, .fill = '0' }, out_stream);
648 try bw.writeAll("\\u");
649 try bw.printInt("x", .{ .width = 4, .fill = '0' }, high);
650 try bw.writeAll("\\u");
651 try bw.printInt("x", .{ .width = 4, .fill = '0' }, low);
651652 }
652653}
653654
654fn outputSpecialEscape(c: u8, writer: *std.io.BufferedWriter) !void {
655fn outputSpecialEscape(c: u8, writer: *std.io.BufferedWriter) anyerror!void {
655656 switch (c) {
656657 '\\' => try writer.writeAll("\\\\"),
657658 '\"' => try writer.writeAll("\\\""),
......@@ -665,14 +666,14 @@ fn outputSpecialEscape(c: u8, writer: *std.io.BufferedWriter) !void {
665666}
666667
667668/// Write `string` to `writer` as a JSON encoded string.
668pub fn encodeJsonString(string: []const u8, options: Options, writer: *std.io.BufferedWriter) !void {
669pub fn encodeJsonString(string: []const u8, options: Options, writer: *std.io.BufferedWriter) anyerror!void {
669670 try writer.writeByte('\"');
670671 try encodeJsonStringChars(string, options, writer);
671672 try writer.writeByte('\"');
672673}
673674
674675/// Write `chars` to `writer` as JSON encoded string characters.
675pub fn encodeJsonStringChars(chars: []const u8, options: Options, writer: *std.io.BufferedWriter) !void {
676pub fn encodeJsonStringChars(chars: []const u8, options: Options, writer: *std.io.BufferedWriter) anyerror!void {
676677 var write_cursor: usize = 0;
677678 var i: usize = 0;
678679 if (options.escape_unicode) {
......@@ -721,8 +722,8 @@ test "json write stream" {
721722 try testBasicWriteStream(&w);
722723}
723724
724fn testBasicWriteStream(w: *Stringify, out: *std.io.BufferedWriter) !void {
725 out.reset();
725fn testBasicWriteStream(w: *Stringify) anyerror!void {
726 w.writer.reset();
726727
727728 try w.beginObject();
728729
......@@ -765,7 +766,7 @@ fn testBasicWriteStream(w: *Stringify, out: *std.io.BufferedWriter) !void {
765766 \\ "float": 3.5e0
766767 \\}
767768 ;
768 try std.testing.expectEqualStrings(expected, out.getWritten());
769 try std.testing.expectEqualStrings(expected, w.writer.getWritten());
769770}
770771
771772fn getJsonObject(allocator: std.mem.Allocator) !std.json.Value {
......@@ -967,59 +968,11 @@ test "stringify struct with custom stringifier" {
967968}
968969
969970fn testStringify(expected: []const u8, v: anytype, options: Options) !void {
970 const ValidationWriter = struct {
971 const Self = @This();
972 pub const Writer = std.io.Writer(*Self, Error, Self.write);
973 pub const Error = error{
974 TooMuchData,
975 DifferentData,
976 };
977
978 expected_remaining: []const u8,
979
980 fn init(exp: []const u8) Self {
981 return .{ .expected_remaining = exp };
982 }
983
984 pub fn writer(self: *Self) Writer {
985 return .{ .context = self };
986 }
987
988 fn write(self: *Self, bytes: []const u8) Error!usize {
989 if (self.expected_remaining.len < bytes.len) {
990 std.debug.print(
991 \\====== expected this output: =========
992 \\{s}
993 \\======== instead found this: =========
994 \\{s}
995 \\======================================
996 , .{
997 self.expected_remaining,
998 bytes,
999 });
1000 return error.TooMuchData;
1001 }
1002 if (!std.mem.eql(u8, self.expected_remaining[0..bytes.len], bytes)) {
1003 std.debug.print(
1004 \\====== expected this output: =========
1005 \\{s}
1006 \\======== instead found this: =========
1007 \\{s}
1008 \\======================================
1009 , .{
1010 self.expected_remaining[0..bytes.len],
1011 bytes,
1012 });
1013 return error.DifferentData;
1014 }
1015 self.expected_remaining = self.expected_remaining[bytes.len..];
1016 return bytes.len;
1017 }
1018 };
1019
1020 var vos = ValidationWriter.init(expected);
1021 try value(v, options, vos.writer());
1022 if (vos.expected_remaining.len > 0) return error.NotEnoughData;
971 var buffer: [4096]u8 = undefined;
972 var bw: std.io.BufferedWriter = undefined;
973 bw.initFixed(&buffer);
974 try value(v, options, &bw);
975 try std.testing.expectEqualStrings(expected, bw.getWritten());
1023976}
1024977
1025978test "raw streaming" {
......@@ -1030,12 +983,12 @@ test "raw streaming" {
1030983 var w: Stringify = .{ .writer = &out, .options = .{ .whitespace = .indent_2 } };
1031984 try w.beginObject();
1032985 try w.beginObjectFieldRaw();
1033 try w.stream.writeAll("\"long");
1034 try w.stream.writeAll(" key\"");
986 try w.writer.writeAll("\"long");
987 try w.writer.writeAll(" key\"");
1035988 w.endObjectFieldRaw();
1036989 try w.beginWriteRaw();
1037 try w.stream.writeAll("\"long");
1038 try w.stream.writeAll(" value\"");
990 try w.writer.writeAll("\"long");
991 try w.writer.writeAll(" value\"");
1039992 w.endWriteRaw();
1040993 try w.endObject();
1041994
lib/std/json/dynamic_test.zig+3-5
......@@ -76,7 +76,6 @@ test "write json then parse it" {
7676 var fixed_writer: std.io.BufferedWriter = undefined;
7777 fixed_writer.initFixed(&out_buffer);
7878 var jw: json.Stringify = .{ .writer = &fixed_writer, .options = .{} };
79 defer jw.deinit();
8079
8180 try jw.beginObject();
8281
......@@ -245,7 +244,6 @@ test "Value.jsonStringify" {
245244 fixed_writer.initFixed(&buffer);
246245
247246 var jw: json.Stringify = .{ .writer = &fixed_writer, .options = .{ .whitespace = .indent_1 } };
248 defer jw.deinit();
249247 try jw.write(array);
250248
251249 const expected =
......@@ -334,7 +332,7 @@ test "polymorphic parsing" {
334332test "long object value" {
335333 const value = "01234567890123456789";
336334 const doc = "{\"key\":\"" ++ value ++ "\"}";
337 var fbs = std.io.fixedBufferStream(doc);
335 var fbs: std.io.FixedBufferStream = .{ .buffer = doc };
338336 var reader = smallBufferJsonReader(testing.allocator, fbs.reader());
339337 defer reader.deinit();
340338 var parsed = try parseFromTokenSource(Value, testing.allocator, &reader, .{});
......@@ -367,7 +365,7 @@ test "many object keys" {
367365 \\ "k5": "v5"
368366 \\}
369367 ;
370 var fbs = std.io.fixedBufferStream(doc);
368 var fbs: std.io.FixedBufferStream = .{ .buffer = doc };
371369 var reader = smallBufferJsonReader(testing.allocator, fbs.reader());
372370 defer reader.deinit();
373371 var parsed = try parseFromTokenSource(Value, testing.allocator, &reader, .{});
......@@ -382,7 +380,7 @@ test "many object keys" {
382380
383381test "negative zero" {
384382 const doc = "-0";
385 var fbs = std.io.fixedBufferStream(doc);
383 var fbs: std.io.FixedBufferStream = .{ .buffer = doc };
386384 var reader = smallBufferJsonReader(testing.allocator, fbs.reader());
387385 defer reader.deinit();
388386 var parsed = try parseFromTokenSource(Value, testing.allocator, &reader, .{});
lib/std/json/hashmap_test.zig+1-1
......@@ -39,7 +39,7 @@ test "parse json hashmap while streaming" {
3939 \\ "xyz": {"i": 1, "s": "w"}
4040 \\}
4141 ;
42 var stream = std.io.fixedBufferStream(doc);
42 var stream: std.io.FixedBufferStream = .{ .buffer = doc };
4343 var json_reader = jsonReader(testing.allocator, stream.reader());
4444
4545 var parsed = try parseFromTokenSource(
lib/std/json/scanner_test.zig+9-9
......@@ -142,12 +142,12 @@ test "peek all types" {
142142 defer scanner.deinit();
143143 try testAllTypes(&scanner, true);
144144
145 var stream = std.io.fixedBufferStream(all_types_test_case);
145 var stream: std.io.FixedBufferStream = .{ .buffer = all_types_test_case };
146146 var json_reader = jsonReader(std.testing.allocator, stream.reader());
147147 defer json_reader.deinit();
148148 try testAllTypes(&json_reader, true);
149149
150 var tiny_stream = std.io.fixedBufferStream(all_types_test_case);
150 var tiny_stream: std.io.FixedBufferStream = .{ .buffer = all_types_test_case };
151151 var tiny_json_reader = JsonReader(1, @TypeOf(tiny_stream.reader())).init(std.testing.allocator, tiny_stream.reader());
152152 defer tiny_json_reader.deinit();
153153 try testAllTypes(&tiny_json_reader, false);
......@@ -182,7 +182,7 @@ test "JsonScanner basic" {
182182}
183183
184184test "JsonReader basic" {
185 var stream = std.io.fixedBufferStream(example_document_str);
185 var stream: std.io.FixedBufferStream = .{ .buffer = example_document_str };
186186
187187 var json_reader = jsonReader(std.testing.allocator, stream.reader());
188188 defer json_reader.deinit();
......@@ -243,7 +243,7 @@ const string_test_cases = .{
243243
244244test "strings" {
245245 inline for (string_test_cases) |tuple| {
246 var stream = std.io.fixedBufferStream("\"" ++ tuple[0] ++ "\"");
246 var stream: std.io.FixedBufferStream = .{ .buffer = "\"" ++ tuple[0] ++ "\"" };
247247 var arena = std.heap.ArenaAllocator.init(std.testing.allocator);
248248 defer arena.deinit();
249249 var json_reader = jsonReader(std.testing.allocator, stream.reader());
......@@ -352,8 +352,8 @@ fn expectEqualTokens(expected_token: Token, actual_token: Token) !void {
352352}
353353
354354fn testTinyBufferSize(document_str: []const u8) !void {
355 var tiny_stream = std.io.fixedBufferStream(document_str);
356 var normal_stream = std.io.fixedBufferStream(document_str);
355 var tiny_stream: std.io.FixedBufferStream = .{ .buffer = document_str };
356 var normal_stream: std.io.FixedBufferStream = .{ .buffer = document_str };
357357
358358 var tiny_json_reader = JsonReader(1, @TypeOf(tiny_stream.reader())).init(std.testing.allocator, tiny_stream.reader());
359359 defer tiny_json_reader.deinit();
......@@ -402,7 +402,7 @@ fn testSkipValue(s: []const u8) !void {
402402 try scanner.skipValue();
403403 try expectEqualTokens(.end_of_document, try scanner.next());
404404
405 var stream = std.io.fixedBufferStream(s);
405 var stream: std.io.FixedBufferStream = .{ .buffer = s };
406406 var json_reader = jsonReader(std.testing.allocator, stream.reader());
407407 defer json_reader.deinit();
408408 try json_reader.skipValue();
......@@ -477,12 +477,12 @@ fn testDiagnostics(expected_error: ?anyerror, line: u64, col: u64, byte_offset:
477477 defer scanner.deinit();
478478 try testDiagnosticsFromSource(expected_error, line, col, byte_offset, &scanner);
479479
480 var tiny_stream = std.io.fixedBufferStream(s);
480 var tiny_stream: std.io.FixedBufferStream = .{ .buffer = s };
481481 var tiny_json_reader = JsonReader(1, @TypeOf(tiny_stream.reader())).init(std.testing.allocator, tiny_stream.reader());
482482 defer tiny_json_reader.deinit();
483483 try testDiagnosticsFromSource(expected_error, line, col, byte_offset, &tiny_json_reader);
484484
485 var medium_stream = std.io.fixedBufferStream(s);
485 var medium_stream: std.io.FixedBufferStream = .{ .buffer = s };
486486 var medium_json_reader = JsonReader(5, @TypeOf(medium_stream.reader())).init(std.testing.allocator, medium_stream.reader());
487487 defer medium_json_reader.deinit();
488488 try testDiagnosticsFromSource(expected_error, line, col, byte_offset, &medium_json_reader);
lib/std/json/static_test.zig+4-4
......@@ -317,7 +317,7 @@ fn testAllParseFunctions(comptime T: type, expected: T, doc: []const u8) !void {
317317 try testing.expectEqualDeep(expected, parsed.value);
318318 }
319319 {
320 var stream = std.io.fixedBufferStream(doc);
320 var stream: std.io.FixedBufferStream = .{ .buffer = doc };
321321 var json_reader = jsonReader(std.testing.allocator, stream.reader());
322322 defer json_reader.deinit();
323323 var parsed = try parseFromTokenSource(T, testing.allocator, &json_reader, .{});
......@@ -336,7 +336,7 @@ fn testAllParseFunctions(comptime T: type, expected: T, doc: []const u8) !void {
336336 try testing.expectEqualDeep(expected, try parseFromTokenSourceLeaky(T, arena.allocator(), &scanner, .{}));
337337 }
338338 {
339 var stream = std.io.fixedBufferStream(doc);
339 var stream: std.io.FixedBufferStream = .{ .buffer = doc };
340340 var json_reader = jsonReader(std.testing.allocator, stream.reader());
341341 defer json_reader.deinit();
342342 try testing.expectEqualDeep(expected, try parseFromTokenSourceLeaky(T, arena.allocator(), &json_reader, .{}));
......@@ -771,7 +771,7 @@ test "parseFromTokenSource" {
771771 }
772772
773773 {
774 var stream = std.io.fixedBufferStream("123");
774 var stream: std.io.FixedBufferStream = .{ .buffer = "123" };
775775 var json_reader = jsonReader(std.testing.allocator, stream.reader());
776776 defer json_reader.deinit();
777777 var parsed = try parseFromTokenSource(u32, testing.allocator, &json_reader, .{});
......@@ -886,7 +886,7 @@ test "json parse allocate when streaming" {
886886 var arena = ArenaAllocator.init(allocator);
887887 defer arena.deinit();
888888
889 var stream = std.io.fixedBufferStream(str);
889 var stream: std.io.FixedBufferStream = .{ .buffer = str };
890890 var json_reader = jsonReader(std.testing.allocator, stream.reader());
891891
892892 const parsed = parseFromTokenSourceLeaky(T, arena.allocator(), &json_reader, .{}) catch |err| {