1const std = @import("std");
2const json = std.json;
3const mem = std.mem;
4const testing = std.testing;
5const ArenaAllocator = std.heap.ArenaAllocator;
6const Allocator = std.mem.Allocator;
7const Writer = std.Io.Writer;
8
9const ObjectMap = @import("dynamic.zig").ObjectMap;
10const Array = @import("dynamic.zig").Array;
11const Value = @import("dynamic.zig").Value;
12
13const parseFromSlice = @import("static.zig").parseFromSlice;
14const parseFromSliceLeaky = @import("static.zig").parseFromSliceLeaky;
15const parseFromTokenSource = @import("static.zig").parseFromTokenSource;
16const parseFromValueLeaky = @import("static.zig").parseFromValueLeaky;
17const ParseOptions = @import("static.zig").ParseOptions;
18
19const Scanner = @import("Scanner.zig");
20
21test "json.parser.dynamic" {
22 const s =
23 \\{
24 \\ "Image": {
25 \\ "Width": 800,
26 \\ "Height": 600,
27 \\ "Title": "View from 15th Floor",
28 \\ "Thumbnail": {
29 \\ "Url": "http://www.example.com/image/481989943",
30 \\ "Height": 125,
31 \\ "Width": 100
32 \\ },
33 \\ "Animated" : false,
34 \\ "IDs": [116, 943, 234, 38793],
35 \\ "ArrayOfObject": [{"n": "m"}],
36 \\ "double": 1.3412,
37 \\ "LargeInt": 18446744073709551615
38 \\ }
39 \\}
40 ;
41
42 var parsed = try parseFromSlice(Value, testing.allocator, s, .{});
43 defer parsed.deinit();
44
45 var root = parsed.value;
46
47 var image = root.object.get("Image").?;
48
49 const width = image.object.get("Width").?;
50 try testing.expect(width.integer == 800);
51
52 const height = image.object.get("Height").?;
53 try testing.expect(height.integer == 600);
54
55 const title = image.object.get("Title").?;
56 try testing.expect(mem.eql(u8, title.string, "View from 15th Floor"));
57
58 const animated = image.object.get("Animated").?;
59 try testing.expect(animated.bool == false);
60
61 const array_of_object = image.object.get("ArrayOfObject").?;
62 try testing.expect(array_of_object.array.items.len == 1);
63
64 const obj0 = array_of_object.array.items[0].object.get("n").?;
65 try testing.expect(mem.eql(u8, obj0.string, "m"));
66
67 const double = image.object.get("double").?;
68 try testing.expect(double.float == 1.3412);
69
70 const large_int = image.object.get("LargeInt").?;
71 try testing.expect(mem.eql(u8, large_int.number_string, "18446744073709551615"));
72}
73
74test "write json then parse it" {
75 var out_buffer: [1000]u8 = undefined;
76 var fixed_writer: Writer = .fixed(&out_buffer);
77 var jw: json.Stringify = .{ .writer = &fixed_writer, .options = .{} };
78
79 try jw.beginObject();
80
81 try jw.objectField("f");
82 try jw.write(false);
83
84 try jw.objectField("t");
85 try jw.write(true);
86
87 try jw.objectField("int");
88 try jw.write(1234);
89
90 try jw.objectField("array");
91 try jw.beginArray();
92 try jw.write(null);
93 try jw.write(12.34);
94 try jw.endArray();
95
96 try jw.objectField("str");
97 try jw.write("hello");
98
99 try jw.endObject();
100
101 var fbs: std.Io.Reader = .fixed(fixed_writer.buffered());
102 var json_reader: Scanner.Reader = .init(testing.allocator, &fbs);
103 defer json_reader.deinit();
104 var parsed = try parseFromTokenSource(Value, testing.allocator, &json_reader, .{});
105 defer parsed.deinit();
106
107 try testing.expect(parsed.value.object.get("f").?.bool == false);
108 try testing.expect(parsed.value.object.get("t").?.bool == true);
109 try testing.expect(parsed.value.object.get("int").?.integer == 1234);
110 try testing.expect(parsed.value.object.get("array").?.array.items[0].null == {});
111 try testing.expect(parsed.value.object.get("array").?.array.items[1].float == 12.34);
112 try testing.expect(mem.eql(u8, parsed.value.object.get("str").?.string, "hello"));
113}
114
115fn testParse(allocator: std.mem.Allocator, json_str: []const u8) !Value {
116 return parseFromSliceLeaky(Value, allocator, json_str, .{});
117}
118
119test "parsing empty string gives appropriate error" {
120 var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
121 defer arena_allocator.deinit();
122 try testing.expectError(error.UnexpectedEndOfInput, testParse(arena_allocator.allocator(), ""));
123}
124
125test "Value.array allocator should still be usable after parsing" {
126 var parsed = try parseFromSlice(Value, std.testing.allocator, "[]", .{});
127 defer parsed.deinit();
128
129 // Allocation should succeed
130 var i: usize = 0;
131 while (i < 100) : (i += 1) {
132 try parsed.value.array.append(Value{ .integer = 100 });
133 }
134 try testing.expectEqual(parsed.value.array.items.len, 100);
135}
136
137test "integer after float has proper type" {
138 var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
139 defer arena_allocator.deinit();
140 const parsed = try testParse(arena_allocator.allocator(),
141 \\{
142 \\ "float": 3.14,
143 \\ "ints": [1, 2, 3]
144 \\}
145 );
146 try std.testing.expect(parsed.object.get("ints").?.array.items[0] == .integer);
147}
148
149test "ParseOptions.parse_numbers prevents parsing when false" {
150 var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
151 defer arena_allocator.deinit();
152 const parsed = try parseFromSliceLeaky(Value, arena_allocator.allocator(),
153 \\{
154 \\ "float": 3.14,
155 \\ "int": 3
156 \\}
157 , .{ .parse_numbers = false });
158 try std.testing.expect(parsed.object.get("float").? == .number_string);
159 try std.testing.expect(parsed.object.get("int").? == .number_string);
160}
161
162test "escaped characters" {
163 var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
164 defer arena_allocator.deinit();
165 const input =
166 \\{
167 \\ "backslash": "\\",
168 \\ "forwardslash": "\/",
169 \\ "newline": "\n",
170 \\ "carriagereturn": "\r",
171 \\ "tab": "\t",
172 \\ "formfeed": "\f",
173 \\ "backspace": "\b",
174 \\ "doublequote": "\"",
175 \\ "unicode": "\u0105",
176 \\ "surrogatepair": "\ud83d\ude02"
177 \\}
178 ;
179
180 const obj = (try testParse(arena_allocator.allocator(), input)).object;
181
182 try testing.expectEqualSlices(u8, obj.get("backslash").?.string, "\\");
183 try testing.expectEqualSlices(u8, obj.get("forwardslash").?.string, "/");
184 try testing.expectEqualSlices(u8, obj.get("newline").?.string, "\n");
185 try testing.expectEqualSlices(u8, obj.get("carriagereturn").?.string, "\r");
186 try testing.expectEqualSlices(u8, obj.get("tab").?.string, "\t");
187 try testing.expectEqualSlices(u8, obj.get("formfeed").?.string, "\x0C");
188 try testing.expectEqualSlices(u8, obj.get("backspace").?.string, "\x08");
189 try testing.expectEqualSlices(u8, obj.get("doublequote").?.string, "\"");
190 try testing.expectEqualSlices(u8, obj.get("unicode").?.string, "ą");
191 try testing.expectEqualSlices(u8, obj.get("surrogatepair").?.string, "😂");
192}
193
194test "Value with duplicate fields" {
195 var arena_allocator = std.heap.ArenaAllocator.init(std.testing.allocator);
196 defer arena_allocator.deinit();
197
198 const doc =
199 \\{
200 \\ "abc": 0,
201 \\ "abc": 1
202 \\}
203 ;
204
205 try testing.expectError(error.DuplicateField, parseFromSliceLeaky(std.json.Value, arena_allocator.allocator(), doc, .{
206 .duplicate_field_behavior = .@"error",
207 }));
208
209 const first = try parseFromSliceLeaky(std.json.Value, arena_allocator.allocator(), doc, .{
210 .duplicate_field_behavior = .use_first,
211 });
212 try testing.expectEqual(@as(usize, 1), first.object.count());
213 try testing.expectEqual(@as(i64, 0), first.object.get("abc").?.integer);
214
215 const last = try parseFromSliceLeaky(std.json.Value, arena_allocator.allocator(), doc, .{
216 .duplicate_field_behavior = .use_last,
217 });
218 try testing.expectEqual(@as(usize, 1), last.object.count());
219 try testing.expectEqual(@as(i64, 1), last.object.get("abc").?.integer);
220}
221
222test "Value.jsonStringify" {
223 const gpa = testing.allocator;
224 var vals = [_]Value{
225 .{ .integer = 1 },
226 .{ .integer = 2 },
227 .{ .number_string = "3" },
228 };
229 var obj: ObjectMap = .empty;
230 defer obj.deinit(gpa);
231 try obj.putNoClobber(gpa, "a", .{ .string = "b" });
232 const array = [_]Value{
233 .null,
234 .{ .bool = true },
235 .{ .integer = 42 },
236 .{ .number_string = "43" },
237 .{ .float = 42 },
238 .{ .string = "weeee" },
239 .{ .array = Array.fromOwnedSlice(undefined, &vals) },
240 .{ .object = obj },
241 };
242 var buffer: [0x1000]u8 = undefined;
243 var fixed_writer: Writer = .fixed(&buffer);
244
245 var jw: json.Stringify = .{ .writer = &fixed_writer, .options = .{ .whitespace = .indent_1 } };
246 try jw.write(array);
247
248 const expected =
249 \\[
250 \\ null,
251 \\ true,
252 \\ 42,
253 \\ 43,
254 \\ 42,
255 \\ "weeee",
256 \\ [
257 \\ 1,
258 \\ 2,
259 \\ 3
260 \\ ],
261 \\ {
262 \\ "a": "b"
263 \\ }
264 \\]
265 ;
266 try testing.expectEqualStrings(expected, fixed_writer.buffered());
267}
268
269test "parseFromValue(std.json.Value,...)" {
270 const str =
271 \\{
272 \\ "int": 32,
273 \\ "float": 3.2,
274 \\ "str": "str",
275 \\ "array": [3, 2],
276 \\ "object": {}
277 \\}
278 ;
279
280 const parsed_tree = try parseFromSlice(Value, testing.allocator, str, .{});
281 defer parsed_tree.deinit();
282 const tree = try parseFromValueLeaky(Value, parsed_tree.arena.allocator(), parsed_tree.value, .{});
283 try testing.expect(std.meta.eql(parsed_tree.value, tree));
284}
285
286test "polymorphic parsing" {
287 if (true) return error.SkipZigTest; // See https://github.com/ziglang/zig/issues/16108
288 const doc =
289 \\{ "type": "div",
290 \\ "color": "blue",
291 \\ "children": [
292 \\ { "type": "button",
293 \\ "caption": "OK" },
294 \\ { "type": "button",
295 \\ "caption": "Cancel" } ] }
296 ;
297 const Node = union(enum) {
298 div: Div,
299 button: Button,
300 const Self = @This();
301 const Div = struct {
302 color: enum { red, blue },
303 children: []Self,
304 };
305 const Button = struct {
306 caption: []const u8,
307 };
308
309 pub fn jsonParseFromValue(allocator: Allocator, source: Value, options: ParseOptions) !@This() {
310 if (source != .object) return error.UnexpectedToken;
311 const type_value = source.object.get("type") orelse return error.UnexpectedToken; // Missing "type" field.
312 if (type_value != .string) return error.UnexpectedToken; // "type" expected to be string.
313 const type_str = type_value.string;
314 var child_options = options;
315 child_options.ignore_unknown_fields = true;
316 if (std.mem.eql(u8, type_str, "div")) return .{ .div = try parseFromValueLeaky(Div, allocator, source, child_options) };
317 if (std.mem.eql(u8, type_str, "button")) return .{ .button = try parseFromValueLeaky(Button, allocator, source, child_options) };
318 return error.UnexpectedToken; // unknown type.
319 }
320 };
321
322 var arena = ArenaAllocator.init(testing.allocator);
323 defer arena.deinit();
324 const dynamic_tree = try parseFromSliceLeaky(Value, arena.allocator(), doc, .{});
325 const tree = try parseFromValueLeaky(Node, arena.allocator(), dynamic_tree, .{});
326
327 try testing.expect(tree.div.color == .blue);
328 try testing.expectEqualStrings("Cancel", tree.div.children[1].button.caption);
329}
330
331test "long object value" {
332 const value = "01234567890123456789";
333 const doc = "{\"key\":\"" ++ value ++ "\"}";
334 var fbs: std.Io.Reader = .fixed(doc);
335 var reader = smallBufferJsonReader(testing.allocator, &fbs);
336 defer reader.deinit();
337 var parsed = try parseFromTokenSource(Value, testing.allocator, &reader, .{});
338 defer parsed.deinit();
339
340 try testing.expectEqualStrings(value, parsed.value.object.get("key").?.string);
341}
342
343test "ParseOptions.max_value_len" {
344 var arena = ArenaAllocator.init(testing.allocator);
345 defer arena.deinit();
346
347 const str = "\"0800fc577294c34e0b28ad2839435945\"";
348
349 const value = try std.json.parseFromSliceLeaky(std.json.Value, arena.allocator(), str, .{ .max_value_len = 32 });
350
351 try testing.expect(value == .string);
352 try testing.expect(value.string.len == 32);
353
354 try testing.expectError(error.ValueTooLong, std.json.parseFromSliceLeaky(std.json.Value, arena.allocator(), str, .{ .max_value_len = 31 }));
355}
356
357test "many object keys" {
358 const doc =
359 \\{
360 \\ "k1": "v1",
361 \\ "k2": "v2",
362 \\ "k3": "v3",
363 \\ "k4": "v4",
364 \\ "k5": "v5"
365 \\}
366 ;
367 var fbs: std.Io.Reader = .fixed(doc);
368 var reader = smallBufferJsonReader(testing.allocator, &fbs);
369 defer reader.deinit();
370 var parsed = try parseFromTokenSource(Value, testing.allocator, &reader, .{});
371 defer parsed.deinit();
372
373 try testing.expectEqualStrings("v1", parsed.value.object.get("k1").?.string);
374 try testing.expectEqualStrings("v2", parsed.value.object.get("k2").?.string);
375 try testing.expectEqualStrings("v3", parsed.value.object.get("k3").?.string);
376 try testing.expectEqualStrings("v4", parsed.value.object.get("k4").?.string);
377 try testing.expectEqualStrings("v5", parsed.value.object.get("k5").?.string);
378}
379
380test "negative zero" {
381 const doc = "-0";
382 var fbs: std.Io.Reader = .fixed(doc);
383 var reader = smallBufferJsonReader(testing.allocator, &fbs);
384 defer reader.deinit();
385 var parsed = try parseFromTokenSource(Value, testing.allocator, &reader, .{});
386 defer parsed.deinit();
387
388 try testing.expect(std.math.isNegativeZero(parsed.value.float));
389}
390
391fn smallBufferJsonReader(allocator: Allocator, io_reader: anytype) Scanner.Reader {
392 return .init(allocator, io_reader);
393}