From 051c7af49ad3e3d4575fd63c68cf96eff144bed7 Mon Sep 17 00:00:00 2001 From: Andrew Kelley Date: Mon, 17 Feb 2025 19:49:36 -0800 Subject: [PATCH] get std lib json tests passing --- lib/std/io/BufferedWriter.zig | 4 +- lib/std/io/Writer.zig | 17 ++++ lib/std/json/Stringify.zig | 165 ++++++++++++---------------------- lib/std/json/dynamic_test.zig | 8 +- lib/std/json/hashmap_test.zig | 2 +- lib/std/json/scanner_test.zig | 18 ++-- lib/std/json/static_test.zig | 8 +- 7 files changed, 95 insertions(+), 127 deletions(-) diff --git a/lib/std/io/BufferedWriter.zig b/lib/std/io/BufferedWriter.zig index af6d394042ab4ae3362b01b020431f04dcbd308a..ac3ac673e45ba023d39eacfecd456f51f1ae4bd8 100644 --- a/lib/std/io/BufferedWriter.zig +++ b/lib/std/io/BufferedWriter.zig @@ -757,9 +757,9 @@ pub fn printValue( return printValue(bw, actual_fmt, options, value.*, max_depth); }, else => { - const buffers: [2][]const u8 = .{ @typeName(ptr_info.child), "@" }; + var buffers: [2][]const u8 = .{ @typeName(ptr_info.child), "@" }; try writevAll(bw, &buffers); - try printIntOptions(bw, @intFromPtr(value), 16, .lower); + try printIntOptions(bw, @intFromPtr(value), 16, .lower, options); }, }, .many, .c => { diff --git a/lib/std/io/Writer.zig b/lib/std/io/Writer.zig index 75a1668ac9cf0def6a47a70cf0dfb594950f4cd2..45b1cc21184531b480232640d598a426da4f5f05 100644 --- a/lib/std/io/Writer.zig +++ b/lib/std/io/Writer.zig @@ -76,6 +76,23 @@ pub fn writeFile( return w.vtable.writeFile(w.context, file, offset, len, headers_and_trailers, headers_len); } +pub fn unimplemented_writeFile( + context: *anyopaque, + file: std.fs.File, + offset: u64, + len: VTable.FileLen, + headers_and_trailers: []const []const u8, + headers_len: usize, +) anyerror!usize { + _ = context; + _ = file; + _ = offset; + _ = len; + _ = headers_and_trailers; + _ = headers_len; + return error.Unimplemented; +} + pub fn write(w: Writer, bytes: []const u8) anyerror!usize { const single: [1][]const u8 = .{bytes}; return w.vtable.writeSplat(w.context, &single, 1); diff --git a/lib/std/json/Stringify.zig b/lib/std/json/Stringify.zig index 4df62dfed9e48763532bced8ab69bfe874c6d27e..feb6d7214c5be3930f7e3c4396dc3ac6bdc47705 100644 --- a/lib/std/json/Stringify.zig +++ b/lib/std/json/Stringify.zig @@ -24,8 +24,10 @@ const ArrayList = std.ArrayList; const BitStack = std.BitStack; const Stringify = @This(); -const OBJECT_MODE = 0; -const ARRAY_MODE = 1; +const IndentationMode = enum(u1) { + object = 0, + array = 1, +}; writer: *std.io.BufferedWriter, options: Options = .{}, @@ -78,22 +80,22 @@ else pub fn beginArray(self: *Stringify) anyerror!void { if (build_mode_has_safety) assert(self.raw_streaming_mode == .none); try self.valueStart(); - try self.stream.writeByte('['); - try self.pushIndentation(ARRAY_MODE); + try self.writer.writeByte('['); + try self.pushIndentation(.array); self.next_punctuation = .none; } pub fn beginObject(self: *Stringify) anyerror!void { if (build_mode_has_safety) assert(self.raw_streaming_mode == .none); try self.valueStart(); - try self.stream.writeByte('{'); - try self.pushIndentation(OBJECT_MODE); + try self.writer.writeByte('{'); + try self.pushIndentation(.object); self.next_punctuation = .none; } pub fn endArray(self: *Stringify) anyerror!void { if (build_mode_has_safety) assert(self.raw_streaming_mode == .none); - self.popIndentation(ARRAY_MODE); + self.popIndentation(.array); switch (self.next_punctuation) { .none => {}, .comma => { @@ -101,13 +103,13 @@ pub fn endArray(self: *Stringify) anyerror!void { }, .the_beginning, .colon => unreachable, } - try self.stream.writeByte(']'); + try self.writer.writeByte(']'); self.valueDone(); } pub fn endObject(self: *Stringify) anyerror!void { if (build_mode_has_safety) assert(self.raw_streaming_mode == .none); - self.popIndentation(OBJECT_MODE); + self.popIndentation(.object); switch (self.next_punctuation) { .none => {}, .comma => { @@ -115,24 +117,24 @@ pub fn endObject(self: *Stringify) anyerror!void { }, .the_beginning, .colon => unreachable, } - try self.stream.writeByte('}'); + try self.writer.writeByte('}'); self.valueDone(); } -fn pushIndentation(self: *Stringify, mode: u1) !void { +fn pushIndentation(self: *Stringify, mode: IndentationMode) !void { switch (safety_checks) { .checked_to_fixed_depth => { - BitStack.pushWithStateAssumeCapacity(&self.nesting_stack, &self.indent_level, mode); + BitStack.pushWithStateAssumeCapacity(&self.nesting_stack, &self.indent_level, @intFromEnum(mode)); }, .assumed_correct => { self.indent_level += 1; }, } } -fn popIndentation(self: *Stringify, assert_its_this_one: u1) void { +fn popIndentation(self: *Stringify, expected_mode: IndentationMode) void { switch (safety_checks) { .checked_to_fixed_depth => { - assert(BitStack.popWithState(&self.nesting_stack, &self.indent_level) == assert_its_this_one); + assert(BitStack.popWithState(&self.nesting_stack, &self.indent_level) == @intFromEnum(expected_mode)); }, .assumed_correct => { self.indent_level -= 1; @@ -154,8 +156,8 @@ fn indent(self: *Stringify) !void { break :blk self.indent_level; }, }; - try self.stream.writeByte('\n'); - try self.stream.writeByteNTimes(char, n_chars); + try self.writer.writeByte('\n'); + try self.writer.splatByteAll(char, n_chars); } fn valueStart(self: *Stringify) !void { @@ -178,13 +180,13 @@ fn valueStartAssumeTypeOk(self: *Stringify) !void { }, .comma => { // Subsequent item in a container. - try self.stream.writeByte(','); + try self.writer.writeByte(','); try self.indent(); }, .colon => { - try self.stream.writeByte(':'); + try self.writer.writeByte(':'); if (self.options.whitespace != .minified) { - try self.stream.writeByte(' '); + try self.writer.writeByte(' '); } }, } @@ -197,7 +199,7 @@ fn valueDone(self: *Stringify) void { fn isObjectKeyExpected(self: *const Stringify) ?bool { switch (safety_checks) { .checked_to_fixed_depth => return self.indent_level > 0 and - BitStack.peekWithState(&self.nesting_stack, self.indent_level) == OBJECT_MODE and + BitStack.peekWithState(&self.nesting_stack, self.indent_level) == @intFromEnum(IndentationMode.object) and self.next_punctuation != .colon, .assumed_correct => return null, } @@ -214,7 +216,7 @@ fn isComplete(self: *const Stringify) bool { pub fn print(self: *Stringify, comptime fmt: []const u8, args: anytype) anyerror!void { if (build_mode_has_safety) assert(self.raw_streaming_mode == .none); try self.valueStart(); - try self.stream.print(fmt, args); + try self.writer.print(fmt, args); self.valueDone(); } @@ -224,7 +226,6 @@ test print { out.initFixed(&out_buf); var w: Stringify = .{ .writer = &out, .options = .{ .whitespace = .indent_2 } }; - defer w.deinit(); try w.beginObject(); try w.objectField("a"); @@ -248,8 +249,8 @@ test print { try std.testing.expectEqualStrings(expected, out.getWritten()); } -/// An alternative to calling `write` that allows you to write directly to the `.stream` field, e.g. with `.stream.writeAll()`. -/// Call `beginWriteRaw()`, then write a complete value (including any quotes if necessary) directly to the `.stream` field, +/// An alternative to calling `write` that allows you to write directly to the `.writer` field, e.g. with `.writer.writeAll()`. +/// Call `beginWriteRaw()`, then write a complete value (including any quotes if necessary) directly to the `.writer` field, /// then call `endWriteRaw()`. /// This can be useful for streaming very long strings into the output without needing it all buffered in memory. pub fn beginWriteRaw(self: *Stringify) !void { @@ -276,7 +277,7 @@ pub fn endWriteRaw(self: *Stringify) void { pub fn objectField(self: *Stringify, key: []const u8) anyerror!void { if (build_mode_has_safety) assert(self.raw_streaming_mode == .none); try self.objectFieldStart(); - try encodeJsonString(key, self.options, self.stream); + try encodeJsonString(key, self.options, self.writer); self.next_punctuation = .colon; } /// See `Stringify` for when to call this method. @@ -287,12 +288,12 @@ pub fn objectFieldRaw(self: *Stringify, quoted_key: []const u8) anyerror!void { if (build_mode_has_safety) assert(self.raw_streaming_mode == .none); assert(quoted_key.len >= 2 and quoted_key[0] == '"' and quoted_key[quoted_key.len - 1] == '"'); // quoted_key should be "quoted". try self.objectFieldStart(); - try self.stream.writeAll(quoted_key); + try self.writer.writeAll(quoted_key); self.next_punctuation = .colon; } /// In the rare case that you need to write very long object field names, -/// this is an alternative to `objectField` and `objectFieldRaw` that allows you to write directly to the `.stream` field +/// this is an alternative to `objectField` and `objectFieldRaw` that allows you to write directly to the `.writer` field /// similar to `beginWriteRaw`. /// Call `endObjectFieldRaw()` when you're done. pub fn beginObjectFieldRaw(self: *Stringify) !void { @@ -351,9 +352,9 @@ pub fn write(self: *Stringify, v: anytype) anyerror!void { if (self.options.emit_nonportable_numbers_as_strings and (v <= -(1 << 53) or v >= (1 << 53))) { - try self.stream.print("\"{}\"", .{v}); + try self.writer.print("\"{}\"", .{v}); } else { - try self.stream.print("{}", .{v}); + try self.writer.print("{}", .{v}); } self.valueDone(); return; @@ -364,25 +365,25 @@ pub fn write(self: *Stringify, v: anytype) anyerror!void { .float, .comptime_float => { if (@as(f64, @floatCast(v)) == v) { try self.valueStart(); - try self.stream.print("{}", .{@as(f64, @floatCast(v))}); + try self.writer.print("{}", .{@as(f64, @floatCast(v))}); self.valueDone(); return; } try self.valueStart(); - try self.stream.print("\"{}\"", .{v}); + try self.writer.print("\"{}\"", .{v}); self.valueDone(); return; }, .bool => { try self.valueStart(); - try self.stream.writeAll(if (v) "true" else "false"); + try self.writer.writeAll(if (v) "true" else "false"); self.valueDone(); return; }, .null => { try self.valueStart(); - try self.stream.writeAll("null"); + try self.writer.writeAll("null"); self.valueDone(); return; }, @@ -529,7 +530,7 @@ pub fn write(self: *Stringify, v: anytype) anyerror!void { fn stringValue(self: *Stringify, s: []const u8) !void { try self.valueStart(); - try encodeJsonString(s, self.options, self.stream); + try encodeJsonString(s, self.options, self.writer); self.valueDone(); } @@ -564,7 +565,7 @@ pub const Options = struct { emit_nonportable_numbers_as_strings: bool = false, }; -/// Writes the given value to the `std.io.Writer` stream. +/// Writes the given value to the `std.io.Writer` writer. /// See `Stringify` for how the given value is serialized into JSON. /// The maximum nesting depth of the output JSON document is 256. pub 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 var aw: std.io.AllocatingWriter = undefined; const writer = aw.init(gpa); defer aw.deinit(); - try value(v, options, writer); + value(v, options, writer) catch return error.OutOfMemory; // TODO: try @errorCast(...) return aw.toOwnedSlice(); } @@ -631,27 +632,27 @@ test valueAlloc { try std.testing.expectEqualStrings(expected, actual); } -fn outputUnicodeEscape(codepoint: u21, out_stream: *std.io.BufferedWriter) !void { +fn outputUnicodeEscape(codepoint: u21, bw: *std.io.BufferedWriter) anyerror!void { if (codepoint <= 0xFFFF) { // If the character is in the Basic Multilingual Plane (U+0000 through U+FFFF), // then it may be represented as a six-character sequence: a reverse solidus, followed // by the lowercase letter u, followed by four hexadecimal digits that encode the character's code point. - try out_stream.writeAll("\\u"); - try std.fmt.formatIntValue(codepoint, "x", std.fmt.FormatOptions{ .width = 4, .fill = '0' }, out_stream); + try bw.writeAll("\\u"); + try bw.printInt("x", .{ .width = 4, .fill = '0' }, codepoint); } else { assert(codepoint <= 0x10FFFF); // To escape an extended character that is not in the Basic Multilingual Plane, // the character is represented as a 12-character sequence, encoding the UTF-16 surrogate pair. const high = @as(u16, @intCast((codepoint - 0x10000) >> 10)) + 0xD800; const low = @as(u16, @intCast(codepoint & 0x3FF)) + 0xDC00; - try out_stream.writeAll("\\u"); - try std.fmt.formatIntValue(high, "x", std.fmt.FormatOptions{ .width = 4, .fill = '0' }, out_stream); - try out_stream.writeAll("\\u"); - try std.fmt.formatIntValue(low, "x", std.fmt.FormatOptions{ .width = 4, .fill = '0' }, out_stream); + try bw.writeAll("\\u"); + try bw.printInt("x", .{ .width = 4, .fill = '0' }, high); + try bw.writeAll("\\u"); + try bw.printInt("x", .{ .width = 4, .fill = '0' }, low); } } -fn outputSpecialEscape(c: u8, writer: *std.io.BufferedWriter) !void { +fn outputSpecialEscape(c: u8, writer: *std.io.BufferedWriter) anyerror!void { switch (c) { '\\' => try writer.writeAll("\\\\"), '\"' => try writer.writeAll("\\\""), @@ -665,14 +666,14 @@ fn outputSpecialEscape(c: u8, writer: *std.io.BufferedWriter) !void { } /// Write `string` to `writer` as a JSON encoded string. -pub fn encodeJsonString(string: []const u8, options: Options, writer: *std.io.BufferedWriter) !void { +pub fn encodeJsonString(string: []const u8, options: Options, writer: *std.io.BufferedWriter) anyerror!void { try writer.writeByte('\"'); try encodeJsonStringChars(string, options, writer); try writer.writeByte('\"'); } /// Write `chars` to `writer` as JSON encoded string characters. -pub fn encodeJsonStringChars(chars: []const u8, options: Options, writer: *std.io.BufferedWriter) !void { +pub fn encodeJsonStringChars(chars: []const u8, options: Options, writer: *std.io.BufferedWriter) anyerror!void { var write_cursor: usize = 0; var i: usize = 0; if (options.escape_unicode) { @@ -721,8 +722,8 @@ test "json write stream" { try testBasicWriteStream(&w); } -fn testBasicWriteStream(w: *Stringify, out: *std.io.BufferedWriter) !void { - out.reset(); +fn testBasicWriteStream(w: *Stringify) anyerror!void { + w.writer.reset(); try w.beginObject(); @@ -765,7 +766,7 @@ fn testBasicWriteStream(w: *Stringify, out: *std.io.BufferedWriter) !void { \\ "float": 3.5e0 \\} ; - try std.testing.expectEqualStrings(expected, out.getWritten()); + try std.testing.expectEqualStrings(expected, w.writer.getWritten()); } fn getJsonObject(allocator: std.mem.Allocator) !std.json.Value { @@ -967,59 +968,11 @@ test "stringify struct with custom stringifier" { } fn testStringify(expected: []const u8, v: anytype, options: Options) !void { - const ValidationWriter = struct { - const Self = @This(); - pub const Writer = std.io.Writer(*Self, Error, Self.write); - pub const Error = error{ - TooMuchData, - DifferentData, - }; - - expected_remaining: []const u8, - - fn init(exp: []const u8) Self { - return .{ .expected_remaining = exp }; - } - - pub fn writer(self: *Self) Writer { - return .{ .context = self }; - } - - fn write(self: *Self, bytes: []const u8) Error!usize { - if (self.expected_remaining.len < bytes.len) { - std.debug.print( - \\====== expected this output: ========= - \\{s} - \\======== instead found this: ========= - \\{s} - \\====================================== - , .{ - self.expected_remaining, - bytes, - }); - return error.TooMuchData; - } - if (!std.mem.eql(u8, self.expected_remaining[0..bytes.len], bytes)) { - std.debug.print( - \\====== expected this output: ========= - \\{s} - \\======== instead found this: ========= - \\{s} - \\====================================== - , .{ - self.expected_remaining[0..bytes.len], - bytes, - }); - return error.DifferentData; - } - self.expected_remaining = self.expected_remaining[bytes.len..]; - return bytes.len; - } - }; - - var vos = ValidationWriter.init(expected); - try value(v, options, vos.writer()); - if (vos.expected_remaining.len > 0) return error.NotEnoughData; + var buffer: [4096]u8 = undefined; + var bw: std.io.BufferedWriter = undefined; + bw.initFixed(&buffer); + try value(v, options, &bw); + try std.testing.expectEqualStrings(expected, bw.getWritten()); } test "raw streaming" { @@ -1030,12 +983,12 @@ test "raw streaming" { var w: Stringify = .{ .writer = &out, .options = .{ .whitespace = .indent_2 } }; try w.beginObject(); try w.beginObjectFieldRaw(); - try w.stream.writeAll("\"long"); - try w.stream.writeAll(" key\""); + try w.writer.writeAll("\"long"); + try w.writer.writeAll(" key\""); w.endObjectFieldRaw(); try w.beginWriteRaw(); - try w.stream.writeAll("\"long"); - try w.stream.writeAll(" value\""); + try w.writer.writeAll("\"long"); + try w.writer.writeAll(" value\""); w.endWriteRaw(); try w.endObject(); diff --git a/lib/std/json/dynamic_test.zig b/lib/std/json/dynamic_test.zig index 3f117db7531fe44c54b3a95e6013f46d036f003d..6537685b489ee6f93ad561f321b464d519129d19 100644 --- a/lib/std/json/dynamic_test.zig +++ b/lib/std/json/dynamic_test.zig @@ -76,7 +76,6 @@ test "write json then parse it" { var fixed_writer: std.io.BufferedWriter = undefined; fixed_writer.initFixed(&out_buffer); var jw: json.Stringify = .{ .writer = &fixed_writer, .options = .{} }; - defer jw.deinit(); try jw.beginObject(); @@ -245,7 +244,6 @@ test "Value.jsonStringify" { fixed_writer.initFixed(&buffer); var jw: json.Stringify = .{ .writer = &fixed_writer, .options = .{ .whitespace = .indent_1 } }; - defer jw.deinit(); try jw.write(array); const expected = @@ -334,7 +332,7 @@ test "polymorphic parsing" { test "long object value" { const value = "01234567890123456789"; const doc = "{\"key\":\"" ++ value ++ "\"}"; - var fbs = std.io.fixedBufferStream(doc); + var fbs: std.io.FixedBufferStream = .{ .buffer = doc }; var reader = smallBufferJsonReader(testing.allocator, fbs.reader()); defer reader.deinit(); var parsed = try parseFromTokenSource(Value, testing.allocator, &reader, .{}); @@ -367,7 +365,7 @@ test "many object keys" { \\ "k5": "v5" \\} ; - var fbs = std.io.fixedBufferStream(doc); + var fbs: std.io.FixedBufferStream = .{ .buffer = doc }; var reader = smallBufferJsonReader(testing.allocator, fbs.reader()); defer reader.deinit(); var parsed = try parseFromTokenSource(Value, testing.allocator, &reader, .{}); @@ -382,7 +380,7 @@ test "many object keys" { test "negative zero" { const doc = "-0"; - var fbs = std.io.fixedBufferStream(doc); + var fbs: std.io.FixedBufferStream = .{ .buffer = doc }; var reader = smallBufferJsonReader(testing.allocator, fbs.reader()); defer reader.deinit(); var parsed = try parseFromTokenSource(Value, testing.allocator, &reader, .{}); diff --git a/lib/std/json/hashmap_test.zig b/lib/std/json/hashmap_test.zig index 576e4868760eec2c8a1bbfdc6c02e39428ee4415..4614d751bd533652b2fea230b4ca144ee3261731 100644 --- a/lib/std/json/hashmap_test.zig +++ b/lib/std/json/hashmap_test.zig @@ -39,7 +39,7 @@ test "parse json hashmap while streaming" { \\ "xyz": {"i": 1, "s": "w"} \\} ; - var stream = std.io.fixedBufferStream(doc); + var stream: std.io.FixedBufferStream = .{ .buffer = doc }; var json_reader = jsonReader(testing.allocator, stream.reader()); var parsed = try parseFromTokenSource( diff --git a/lib/std/json/scanner_test.zig b/lib/std/json/scanner_test.zig index d085cb661a7beafc8ee640f0180bf80c822b1273..ec6c18edab339850e5f95654304defb9437a27de 100644 --- a/lib/std/json/scanner_test.zig +++ b/lib/std/json/scanner_test.zig @@ -142,12 +142,12 @@ test "peek all types" { defer scanner.deinit(); try testAllTypes(&scanner, true); - var stream = std.io.fixedBufferStream(all_types_test_case); + var stream: std.io.FixedBufferStream = .{ .buffer = all_types_test_case }; var json_reader = jsonReader(std.testing.allocator, stream.reader()); defer json_reader.deinit(); try testAllTypes(&json_reader, true); - var tiny_stream = std.io.fixedBufferStream(all_types_test_case); + var tiny_stream: std.io.FixedBufferStream = .{ .buffer = all_types_test_case }; var tiny_json_reader = JsonReader(1, @TypeOf(tiny_stream.reader())).init(std.testing.allocator, tiny_stream.reader()); defer tiny_json_reader.deinit(); try testAllTypes(&tiny_json_reader, false); @@ -182,7 +182,7 @@ test "JsonScanner basic" { } test "JsonReader basic" { - var stream = std.io.fixedBufferStream(example_document_str); + var stream: std.io.FixedBufferStream = .{ .buffer = example_document_str }; var json_reader = jsonReader(std.testing.allocator, stream.reader()); defer json_reader.deinit(); @@ -243,7 +243,7 @@ const string_test_cases = .{ test "strings" { inline for (string_test_cases) |tuple| { - var stream = std.io.fixedBufferStream("\"" ++ tuple[0] ++ "\""); + var stream: std.io.FixedBufferStream = .{ .buffer = "\"" ++ tuple[0] ++ "\"" }; var arena = std.heap.ArenaAllocator.init(std.testing.allocator); defer arena.deinit(); var json_reader = jsonReader(std.testing.allocator, stream.reader()); @@ -352,8 +352,8 @@ fn expectEqualTokens(expected_token: Token, actual_token: Token) !void { } fn testTinyBufferSize(document_str: []const u8) !void { - var tiny_stream = std.io.fixedBufferStream(document_str); - var normal_stream = std.io.fixedBufferStream(document_str); + var tiny_stream: std.io.FixedBufferStream = .{ .buffer = document_str }; + var normal_stream: std.io.FixedBufferStream = .{ .buffer = document_str }; var tiny_json_reader = JsonReader(1, @TypeOf(tiny_stream.reader())).init(std.testing.allocator, tiny_stream.reader()); defer tiny_json_reader.deinit(); @@ -402,7 +402,7 @@ fn testSkipValue(s: []const u8) !void { try scanner.skipValue(); try expectEqualTokens(.end_of_document, try scanner.next()); - var stream = std.io.fixedBufferStream(s); + var stream: std.io.FixedBufferStream = .{ .buffer = s }; var json_reader = jsonReader(std.testing.allocator, stream.reader()); defer json_reader.deinit(); try json_reader.skipValue(); @@ -477,12 +477,12 @@ fn testDiagnostics(expected_error: ?anyerror, line: u64, col: u64, byte_offset: defer scanner.deinit(); try testDiagnosticsFromSource(expected_error, line, col, byte_offset, &scanner); - var tiny_stream = std.io.fixedBufferStream(s); + var tiny_stream: std.io.FixedBufferStream = .{ .buffer = s }; var tiny_json_reader = JsonReader(1, @TypeOf(tiny_stream.reader())).init(std.testing.allocator, tiny_stream.reader()); defer tiny_json_reader.deinit(); try testDiagnosticsFromSource(expected_error, line, col, byte_offset, &tiny_json_reader); - var medium_stream = std.io.fixedBufferStream(s); + var medium_stream: std.io.FixedBufferStream = .{ .buffer = s }; var medium_json_reader = JsonReader(5, @TypeOf(medium_stream.reader())).init(std.testing.allocator, medium_stream.reader()); defer medium_json_reader.deinit(); try testDiagnosticsFromSource(expected_error, line, col, byte_offset, &medium_json_reader); diff --git a/lib/std/json/static_test.zig b/lib/std/json/static_test.zig index 3a1919e40c0016b2c980e422c14642b90699559d..38edbf7f0a22409137ea4ace785af5baca214368 100644 --- a/lib/std/json/static_test.zig +++ b/lib/std/json/static_test.zig @@ -317,7 +317,7 @@ fn testAllParseFunctions(comptime T: type, expected: T, doc: []const u8) !void { try testing.expectEqualDeep(expected, parsed.value); } { - var stream = std.io.fixedBufferStream(doc); + var stream: std.io.FixedBufferStream = .{ .buffer = doc }; var json_reader = jsonReader(std.testing.allocator, stream.reader()); defer json_reader.deinit(); var parsed = try parseFromTokenSource(T, testing.allocator, &json_reader, .{}); @@ -336,7 +336,7 @@ fn testAllParseFunctions(comptime T: type, expected: T, doc: []const u8) !void { try testing.expectEqualDeep(expected, try parseFromTokenSourceLeaky(T, arena.allocator(), &scanner, .{})); } { - var stream = std.io.fixedBufferStream(doc); + var stream: std.io.FixedBufferStream = .{ .buffer = doc }; var json_reader = jsonReader(std.testing.allocator, stream.reader()); defer json_reader.deinit(); try testing.expectEqualDeep(expected, try parseFromTokenSourceLeaky(T, arena.allocator(), &json_reader, .{})); @@ -771,7 +771,7 @@ test "parseFromTokenSource" { } { - var stream = std.io.fixedBufferStream("123"); + var stream: std.io.FixedBufferStream = .{ .buffer = "123" }; var json_reader = jsonReader(std.testing.allocator, stream.reader()); defer json_reader.deinit(); var parsed = try parseFromTokenSource(u32, testing.allocator, &json_reader, .{}); @@ -886,7 +886,7 @@ test "json parse allocate when streaming" { var arena = ArenaAllocator.init(allocator); defer arena.deinit(); - var stream = std.io.fixedBufferStream(str); + var stream: std.io.FixedBufferStream = .{ .buffer = str }; var json_reader = jsonReader(std.testing.allocator, stream.reader()); const parsed = parseFromTokenSourceLeaky(T, arena.allocator(), &json_reader, .{}) catch |err| { -- 2.54.0