mirror of
https://github.com/ziglang/zig.git
synced 2026-01-06 05:25:10 +00:00
get std lib json tests passing
This commit is contained in:
Andrew Kelley
parent
e154b62d63
commit
051c7af49a
@ -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 => {
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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();
|
||||
|
||||
|
||||
@ -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, .{});
|
||||
|
||||
@ -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(
|
||||
|
||||
@ -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);
|
||||
|
||||
@ -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| {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user