1const std = @import("std");
2const mem = std.mem;
3const testing = std.testing;
4const parse = @import("../parse.zig");
5
6const Node = parse.Node;
7const Tree = parse.Tree;
8
9test "explicit doc" {
10 const source =
11 \\--- !tapi-tbd
12 \\tbd-version: 4
13 \\abc-version: 5
14 \\...
15 ;
16
17 var tree = Tree.init(testing.allocator);
18 defer tree.deinit();
19 try tree.parse(source);
20
21 try testing.expectEqual(tree.docs.items.len, 1);
22
23 const doc = tree.docs.items[0].cast(Node.Doc).?;
24 try testing.expectEqual(doc.base.start, 0);
25 try testing.expectEqual(doc.base.end, tree.tokens.len - 2);
26
27 const directive = tree.tokens[doc.directive.?];
28 try testing.expectEqual(directive.id, .literal);
29 try testing.expectEqualStrings("tapi-tbd", tree.source[directive.start..directive.end]);
30
31 try testing.expect(doc.value != null);
32 try testing.expectEqual(doc.value.?.tag, .map);
33
34 const map = doc.value.?.cast(Node.Map).?;
35 try testing.expectEqual(map.base.start, 5);
36 try testing.expectEqual(map.base.end, 14);
37 try testing.expectEqual(map.values.items.len, 2);
38
39 {
40 const entry = map.values.items[0];
41
42 const key = tree.tokens[entry.key];
43 try testing.expectEqual(key.id, .literal);
44 try testing.expectEqualStrings("tbd-version", tree.source[key.start..key.end]);
45
46 const value = entry.value.?.cast(Node.Value).?;
47 const value_tok = tree.tokens[value.base.start];
48 try testing.expectEqual(value_tok.id, .literal);
49 try testing.expectEqualStrings("4", tree.source[value_tok.start..value_tok.end]);
50 }
51
52 {
53 const entry = map.values.items[1];
54
55 const key = tree.tokens[entry.key];
56 try testing.expectEqual(key.id, .literal);
57 try testing.expectEqualStrings("abc-version", tree.source[key.start..key.end]);
58
59 const value = entry.value.?.cast(Node.Value).?;
60 const value_tok = tree.tokens[value.base.start];
61 try testing.expectEqual(value_tok.id, .literal);
62 try testing.expectEqualStrings("5", tree.source[value_tok.start..value_tok.end]);
63 }
64}
65
66test "leaf in quotes" {
67 const source =
68 \\key1: no quotes
69 \\key2: 'single quoted'
70 \\key3: "double quoted"
71 ;
72
73 var tree = Tree.init(testing.allocator);
74 defer tree.deinit();
75 try tree.parse(source);
76
77 try testing.expectEqual(tree.docs.items.len, 1);
78
79 const doc = tree.docs.items[0].cast(Node.Doc).?;
80 try testing.expectEqual(doc.base.start, 0);
81 try testing.expectEqual(doc.base.end, tree.tokens.len - 2);
82 try testing.expect(doc.directive == null);
83
84 try testing.expect(doc.value != null);
85 try testing.expectEqual(doc.value.?.tag, .map);
86
87 const map = doc.value.?.cast(Node.Map).?;
88 try testing.expectEqual(map.base.start, 0);
89 try testing.expectEqual(map.base.end, tree.tokens.len - 2);
90 try testing.expectEqual(map.values.items.len, 3);
91
92 {
93 const entry = map.values.items[0];
94
95 const key = tree.tokens[entry.key];
96 try testing.expectEqual(key.id, .literal);
97 try testing.expectEqualStrings("key1", tree.source[key.start..key.end]);
98
99 const value = entry.value.?.cast(Node.Value).?;
100 const start = tree.tokens[value.base.start];
101 const end = tree.tokens[value.base.end];
102 try testing.expectEqual(start.id, .literal);
103 try testing.expectEqual(end.id, .literal);
104 try testing.expectEqualStrings("no quotes", tree.source[start.start..end.end]);
105 }
106}
107
108test "nested maps" {
109 const source =
110 \\key1:
111 \\ key1_1 : value1_1
112 \\ key1_2 : value1_2
113 \\key2 : value2
114 ;
115
116 var tree = Tree.init(testing.allocator);
117 defer tree.deinit();
118 try tree.parse(source);
119
120 try testing.expectEqual(tree.docs.items.len, 1);
121
122 const doc = tree.docs.items[0].cast(Node.Doc).?;
123 try testing.expectEqual(doc.base.start, 0);
124 try testing.expectEqual(doc.base.end, tree.tokens.len - 2);
125 try testing.expect(doc.directive == null);
126
127 try testing.expect(doc.value != null);
128 try testing.expectEqual(doc.value.?.tag, .map);
129
130 const map = doc.value.?.cast(Node.Map).?;
131 try testing.expectEqual(map.base.start, 0);
132 try testing.expectEqual(map.base.end, tree.tokens.len - 2);
133 try testing.expectEqual(map.values.items.len, 2);
134
135 {
136 const entry = map.values.items[0];
137
138 const key = tree.tokens[entry.key];
139 try testing.expectEqual(key.id, .literal);
140 try testing.expectEqualStrings("key1", tree.source[key.start..key.end]);
141
142 const nested_map = entry.value.?.cast(Node.Map).?;
143 try testing.expectEqual(nested_map.base.start, 4);
144 try testing.expectEqual(nested_map.base.end, 16);
145 try testing.expectEqual(nested_map.values.items.len, 2);
146
147 {
148 const nested_entry = nested_map.values.items[0];
149
150 const nested_key = tree.tokens[nested_entry.key];
151 try testing.expectEqual(nested_key.id, .literal);
152 try testing.expectEqualStrings("key1_1", tree.source[nested_key.start..nested_key.end]);
153
154 const nested_value = nested_entry.value.?.cast(Node.Value).?;
155 const nested_value_tok = tree.tokens[nested_value.base.start];
156 try testing.expectEqual(nested_value_tok.id, .literal);
157 try testing.expectEqualStrings(
158 "value1_1",
159 tree.source[nested_value_tok.start..nested_value_tok.end],
160 );
161 }
162
163 {
164 const nested_entry = nested_map.values.items[1];
165
166 const nested_key = tree.tokens[nested_entry.key];
167 try testing.expectEqual(nested_key.id, .literal);
168 try testing.expectEqualStrings("key1_2", tree.source[nested_key.start..nested_key.end]);
169
170 const nested_value = nested_entry.value.?.cast(Node.Value).?;
171 const nested_value_tok = tree.tokens[nested_value.base.start];
172 try testing.expectEqual(nested_value_tok.id, .literal);
173 try testing.expectEqualStrings(
174 "value1_2",
175 tree.source[nested_value_tok.start..nested_value_tok.end],
176 );
177 }
178 }
179
180 {
181 const entry = map.values.items[1];
182
183 const key = tree.tokens[entry.key];
184 try testing.expectEqual(key.id, .literal);
185 try testing.expectEqualStrings("key2", tree.source[key.start..key.end]);
186
187 const value = entry.value.?.cast(Node.Value).?;
188 const value_tok = tree.tokens[value.base.start];
189 try testing.expectEqual(value_tok.id, .literal);
190 try testing.expectEqualStrings("value2", tree.source[value_tok.start..value_tok.end]);
191 }
192}
193
194test "map of list of values" {
195 const source =
196 \\ints:
197 \\ - 0
198 \\ - 1
199 \\ - 2
200 ;
201 var tree = Tree.init(testing.allocator);
202 defer tree.deinit();
203 try tree.parse(source);
204
205 try testing.expectEqual(tree.docs.items.len, 1);
206
207 const doc = tree.docs.items[0].cast(Node.Doc).?;
208 try testing.expectEqual(doc.base.start, 0);
209 try testing.expectEqual(doc.base.end, tree.tokens.len - 2);
210
211 try testing.expect(doc.value != null);
212 try testing.expectEqual(doc.value.?.tag, .map);
213
214 const map = doc.value.?.cast(Node.Map).?;
215 try testing.expectEqual(map.base.start, 0);
216 try testing.expectEqual(map.base.end, tree.tokens.len - 2);
217 try testing.expectEqual(map.values.items.len, 1);
218
219 const entry = map.values.items[0];
220 const key = tree.tokens[entry.key];
221 try testing.expectEqual(key.id, .literal);
222 try testing.expectEqualStrings("ints", tree.source[key.start..key.end]);
223
224 const value = entry.value.?.cast(Node.List).?;
225 try testing.expectEqual(value.base.start, 4);
226 try testing.expectEqual(value.base.end, tree.tokens.len - 2);
227 try testing.expectEqual(value.values.items.len, 3);
228
229 {
230 const elem = value.values.items[0].cast(Node.Value).?;
231 const leaf = tree.tokens[elem.base.start];
232 try testing.expectEqual(leaf.id, .literal);
233 try testing.expectEqualStrings("0", tree.source[leaf.start..leaf.end]);
234 }
235
236 {
237 const elem = value.values.items[1].cast(Node.Value).?;
238 const leaf = tree.tokens[elem.base.start];
239 try testing.expectEqual(leaf.id, .literal);
240 try testing.expectEqualStrings("1", tree.source[leaf.start..leaf.end]);
241 }
242
243 {
244 const elem = value.values.items[2].cast(Node.Value).?;
245 const leaf = tree.tokens[elem.base.start];
246 try testing.expectEqual(leaf.id, .literal);
247 try testing.expectEqualStrings("2", tree.source[leaf.start..leaf.end]);
248 }
249}
250
251test "map of list of maps" {
252 const source =
253 \\key1:
254 \\- key2 : value2
255 \\- key3 : value3
256 \\- key4 : value4
257 ;
258
259 var tree = Tree.init(testing.allocator);
260 defer tree.deinit();
261 try tree.parse(source);
262
263 try testing.expectEqual(tree.docs.items.len, 1);
264
265 const doc = tree.docs.items[0].cast(Node.Doc).?;
266 try testing.expectEqual(doc.base.start, 0);
267 try testing.expectEqual(doc.base.end, tree.tokens.len - 2);
268
269 try testing.expect(doc.value != null);
270 try testing.expectEqual(doc.value.?.tag, .map);
271
272 const map = doc.value.?.cast(Node.Map).?;
273 try testing.expectEqual(map.base.start, 0);
274 try testing.expectEqual(map.base.end, tree.tokens.len - 2);
275 try testing.expectEqual(map.values.items.len, 1);
276
277 const entry = map.values.items[0];
278 const key = tree.tokens[entry.key];
279 try testing.expectEqual(key.id, .literal);
280 try testing.expectEqualStrings("key1", tree.source[key.start..key.end]);
281
282 const value = entry.value.?.cast(Node.List).?;
283 try testing.expectEqual(value.base.start, 3);
284 try testing.expectEqual(value.base.end, tree.tokens.len - 2);
285 try testing.expectEqual(value.values.items.len, 3);
286
287 {
288 const elem = value.values.items[0].cast(Node.Map).?;
289 const nested = elem.values.items[0];
290 const nested_key = tree.tokens[nested.key];
291 try testing.expectEqual(nested_key.id, .literal);
292 try testing.expectEqualStrings("key2", tree.source[nested_key.start..nested_key.end]);
293
294 const nested_v = nested.value.?.cast(Node.Value).?;
295 const leaf = tree.tokens[nested_v.base.start];
296 try testing.expectEqual(leaf.id, .literal);
297 try testing.expectEqualStrings("value2", tree.source[leaf.start..leaf.end]);
298 }
299
300 {
301 const elem = value.values.items[1].cast(Node.Map).?;
302 const nested = elem.values.items[0];
303 const nested_key = tree.tokens[nested.key];
304 try testing.expectEqual(nested_key.id, .literal);
305 try testing.expectEqualStrings("key3", tree.source[nested_key.start..nested_key.end]);
306
307 const nested_v = nested.value.?.cast(Node.Value).?;
308 const leaf = tree.tokens[nested_v.base.start];
309 try testing.expectEqual(leaf.id, .literal);
310 try testing.expectEqualStrings("value3", tree.source[leaf.start..leaf.end]);
311 }
312
313 {
314 const elem = value.values.items[2].cast(Node.Map).?;
315 const nested = elem.values.items[0];
316 const nested_key = tree.tokens[nested.key];
317 try testing.expectEqual(nested_key.id, .literal);
318 try testing.expectEqualStrings("key4", tree.source[nested_key.start..nested_key.end]);
319
320 const nested_v = nested.value.?.cast(Node.Value).?;
321 const leaf = tree.tokens[nested_v.base.start];
322 try testing.expectEqual(leaf.id, .literal);
323 try testing.expectEqualStrings("value4", tree.source[leaf.start..leaf.end]);
324 }
325}
326
327test "list of lists" {
328 const source =
329 \\- [name , hr, avg ]
330 \\- [Mark McGwire , 65, 0.278]
331 \\- [Sammy Sosa , 63, 0.288]
332 ;
333
334 var tree = Tree.init(testing.allocator);
335 defer tree.deinit();
336 try tree.parse(source);
337
338 try testing.expectEqual(tree.docs.items.len, 1);
339
340 const doc = tree.docs.items[0].cast(Node.Doc).?;
341 try testing.expectEqual(doc.base.start, 0);
342 try testing.expectEqual(doc.base.end, tree.tokens.len - 2);
343
344 try testing.expect(doc.value != null);
345 try testing.expectEqual(doc.value.?.tag, .list);
346
347 const list = doc.value.?.cast(Node.List).?;
348 try testing.expectEqual(list.base.start, 0);
349 try testing.expectEqual(list.base.end, tree.tokens.len - 2);
350 try testing.expectEqual(list.values.items.len, 3);
351
352 {
353 try testing.expectEqual(list.values.items[0].tag, .list);
354 const nested = list.values.items[0].cast(Node.List).?;
355 try testing.expectEqual(nested.values.items.len, 3);
356
357 {
358 try testing.expectEqual(nested.values.items[0].tag, .value);
359 const value = nested.values.items[0].cast(Node.Value).?;
360 const leaf = tree.tokens[value.base.start];
361 try testing.expectEqualStrings("name", tree.source[leaf.start..leaf.end]);
362 }
363
364 {
365 try testing.expectEqual(nested.values.items[1].tag, .value);
366 const value = nested.values.items[1].cast(Node.Value).?;
367 const leaf = tree.tokens[value.base.start];
368 try testing.expectEqualStrings("hr", tree.source[leaf.start..leaf.end]);
369 }
370
371 {
372 try testing.expectEqual(nested.values.items[2].tag, .value);
373 const value = nested.values.items[2].cast(Node.Value).?;
374 const leaf = tree.tokens[value.base.start];
375 try testing.expectEqualStrings("avg", tree.source[leaf.start..leaf.end]);
376 }
377 }
378
379 {
380 try testing.expectEqual(list.values.items[1].tag, .list);
381 const nested = list.values.items[1].cast(Node.List).?;
382 try testing.expectEqual(nested.values.items.len, 3);
383
384 {
385 try testing.expectEqual(nested.values.items[0].tag, .value);
386 const value = nested.values.items[0].cast(Node.Value).?;
387 const start = tree.tokens[value.base.start];
388 const end = tree.tokens[value.base.end];
389 try testing.expectEqualStrings("Mark McGwire", tree.source[start.start..end.end]);
390 }
391
392 {
393 try testing.expectEqual(nested.values.items[1].tag, .value);
394 const value = nested.values.items[1].cast(Node.Value).?;
395 const leaf = tree.tokens[value.base.start];
396 try testing.expectEqualStrings("65", tree.source[leaf.start..leaf.end]);
397 }
398
399 {
400 try testing.expectEqual(nested.values.items[2].tag, .value);
401 const value = nested.values.items[2].cast(Node.Value).?;
402 const leaf = tree.tokens[value.base.start];
403 try testing.expectEqualStrings("0.278", tree.source[leaf.start..leaf.end]);
404 }
405 }
406
407 {
408 try testing.expectEqual(list.values.items[2].tag, .list);
409 const nested = list.values.items[2].cast(Node.List).?;
410 try testing.expectEqual(nested.values.items.len, 3);
411
412 {
413 try testing.expectEqual(nested.values.items[0].tag, .value);
414 const value = nested.values.items[0].cast(Node.Value).?;
415 const start = tree.tokens[value.base.start];
416 const end = tree.tokens[value.base.end];
417 try testing.expectEqualStrings("Sammy Sosa", tree.source[start.start..end.end]);
418 }
419
420 {
421 try testing.expectEqual(nested.values.items[1].tag, .value);
422 const value = nested.values.items[1].cast(Node.Value).?;
423 const leaf = tree.tokens[value.base.start];
424 try testing.expectEqualStrings("63", tree.source[leaf.start..leaf.end]);
425 }
426
427 {
428 try testing.expectEqual(nested.values.items[2].tag, .value);
429 const value = nested.values.items[2].cast(Node.Value).?;
430 const leaf = tree.tokens[value.base.start];
431 try testing.expectEqualStrings("0.288", tree.source[leaf.start..leaf.end]);
432 }
433 }
434}
435
436test "inline list" {
437 const source =
438 \\[name , hr, avg ]
439 ;
440
441 var tree = Tree.init(testing.allocator);
442 defer tree.deinit();
443 try tree.parse(source);
444
445 try testing.expectEqual(tree.docs.items.len, 1);
446
447 const doc = tree.docs.items[0].cast(Node.Doc).?;
448 try testing.expectEqual(doc.base.start, 0);
449 try testing.expectEqual(doc.base.end, tree.tokens.len - 2);
450
451 try testing.expect(doc.value != null);
452 try testing.expectEqual(doc.value.?.tag, .list);
453
454 const list = doc.value.?.cast(Node.List).?;
455 try testing.expectEqual(list.base.start, 0);
456 try testing.expectEqual(list.base.end, tree.tokens.len - 2);
457 try testing.expectEqual(list.values.items.len, 3);
458
459 {
460 try testing.expectEqual(list.values.items[0].tag, .value);
461 const value = list.values.items[0].cast(Node.Value).?;
462 const leaf = tree.tokens[value.base.start];
463 try testing.expectEqualStrings("name", tree.source[leaf.start..leaf.end]);
464 }
465
466 {
467 try testing.expectEqual(list.values.items[1].tag, .value);
468 const value = list.values.items[1].cast(Node.Value).?;
469 const leaf = tree.tokens[value.base.start];
470 try testing.expectEqualStrings("hr", tree.source[leaf.start..leaf.end]);
471 }
472
473 {
474 try testing.expectEqual(list.values.items[2].tag, .value);
475 const value = list.values.items[2].cast(Node.Value).?;
476 const leaf = tree.tokens[value.base.start];
477 try testing.expectEqualStrings("avg", tree.source[leaf.start..leaf.end]);
478 }
479}
480
481test "inline list as mapping value" {
482 const source =
483 \\key : [
484 \\ name ,
485 \\ hr, avg ]
486 ;
487
488 var tree = Tree.init(testing.allocator);
489 defer tree.deinit();
490 try tree.parse(source);
491
492 try testing.expectEqual(tree.docs.items.len, 1);
493
494 const doc = tree.docs.items[0].cast(Node.Doc).?;
495 try testing.expectEqual(doc.base.start, 0);
496 try testing.expectEqual(doc.base.end, tree.tokens.len - 2);
497
498 try testing.expect(doc.value != null);
499 try testing.expectEqual(doc.value.?.tag, .map);
500
501 const map = doc.value.?.cast(Node.Map).?;
502 try testing.expectEqual(map.base.start, 0);
503 try testing.expectEqual(map.base.end, tree.tokens.len - 2);
504 try testing.expectEqual(map.values.items.len, 1);
505
506 const entry = map.values.items[0];
507 const key = tree.tokens[entry.key];
508 try testing.expectEqual(key.id, .literal);
509 try testing.expectEqualStrings("key", tree.source[key.start..key.end]);
510
511 const list = entry.value.?.cast(Node.List).?;
512 try testing.expectEqual(list.base.start, 4);
513 try testing.expectEqual(list.base.end, tree.tokens.len - 2);
514 try testing.expectEqual(list.values.items.len, 3);
515
516 {
517 try testing.expectEqual(list.values.items[0].tag, .value);
518 const value = list.values.items[0].cast(Node.Value).?;
519 const leaf = tree.tokens[value.base.start];
520 try testing.expectEqualStrings("name", tree.source[leaf.start..leaf.end]);
521 }
522
523 {
524 try testing.expectEqual(list.values.items[1].tag, .value);
525 const value = list.values.items[1].cast(Node.Value).?;
526 const leaf = tree.tokens[value.base.start];
527 try testing.expectEqualStrings("hr", tree.source[leaf.start..leaf.end]);
528 }
529
530 {
531 try testing.expectEqual(list.values.items[2].tag, .value);
532 const value = list.values.items[2].cast(Node.Value).?;
533 const leaf = tree.tokens[value.base.start];
534 try testing.expectEqualStrings("avg", tree.source[leaf.start..leaf.end]);
535 }
536}
537
538fn parseSuccess(comptime source: []const u8) !void {
539 var tree = Tree.init(testing.allocator);
540 defer tree.deinit();
541 try tree.parse(source);
542}
543
544fn parseError(comptime source: []const u8, err: parse.ParseError) !void {
545 var tree = Tree.init(testing.allocator);
546 defer tree.deinit();
547 try testing.expectError(err, tree.parse(source));
548}
549
550test "empty doc with spaces and comments" {
551 try parseSuccess(
552 \\
553 \\
554 \\ # this is a comment in a weird place
555 \\# and this one is too
556 );
557}
558
559test "comment between --- and ! in document start" {
560 try parseError(
561 \\--- # what is it?
562 \\!
563 , error.UnexpectedToken);
564}
565
566test "correct doc start with tag" {
567 try parseSuccess(
568 \\--- !some-tag
569 \\
570 );
571}
572
573test "doc close without explicit doc open" {
574 try parseError(
575 \\
576 \\
577 \\# something cool
578 \\...
579 , error.UnexpectedToken);
580}
581
582test "doc open and close are ok" {
583 try parseSuccess(
584 \\---
585 \\# first doc
586 \\
587 \\
588 \\---
589 \\# second doc
590 \\
591 \\
592 \\...
593 );
594}
595
596test "doc with a single string is ok" {
597 try parseSuccess(
598 \\a string of some sort
599 \\
600 );
601}
602
603test "explicit doc with a single string is ok" {
604 try parseSuccess(
605 \\--- !anchor
606 \\# nothing to see here except one string
607 \\ # not a lot to go on with
608 \\a single string
609 \\...
610 );
611}
612
613test "doc with two string is bad" {
614 try parseError(
615 \\first
616 \\second
617 \\# this should fail already
618 , error.UnexpectedToken);
619}
620
621test "single quote string can have new lines" {
622 try parseSuccess(
623 \\'what is this
624 \\ thing?'
625 );
626}
627
628test "single quote string on one line is fine" {
629 try parseSuccess(
630 \\'here''s an apostrophe'
631 );
632}
633
634test "double quote string can have new lines" {
635 try parseSuccess(
636 \\"what is this
637 \\ thing?"
638 );
639}
640
641test "double quote string on one line is fine" {
642 try parseSuccess(
643 \\"a newline\nand a\ttab"
644 );
645}
646
647test "map with key and value literals" {
648 try parseSuccess(
649 \\key1: val1
650 \\key2 : val2
651 );
652}
653
654test "map of maps" {
655 try parseSuccess(
656 \\
657 \\# the first key
658 \\key1:
659 \\ # the first subkey
660 \\ key1_1: 0
661 \\ key1_2: 1
662 \\# the second key
663 \\key2:
664 \\ key2_1: -1
665 \\ key2_2: -2
666 \\# the end of map
667 );
668}
669
670test "map value indicator needs to be on the same line" {
671 try parseError(
672 \\a
673 \\ : b
674 , error.UnexpectedToken);
675}
676
677test "value needs to be indented" {
678 try parseError(
679 \\a:
680 \\b
681 , error.MalformedYaml);
682}
683
684test "comment between a key and a value is fine" {
685 try parseSuccess(
686 \\a:
687 \\ # this is a value
688 \\ b
689 );
690}
691
692test "simple list" {
693 try parseSuccess(
694 \\# first el
695 \\- a
696 \\# second el
697 \\- b
698 \\# third el
699 \\- c
700 );
701}
702
703test "list indentation matters" {
704 try parseSuccess(
705 \\ - a
706 \\- b
707 );
708
709 try parseSuccess(
710 \\- a
711 \\ - b
712 );
713}
714
715test "unindented list is fine too" {
716 try parseSuccess(
717 \\a:
718 \\- 0
719 \\- 1
720 );
721}
722
723test "empty values in a map" {
724 try parseSuccess(
725 \\a:
726 \\b:
727 \\- 0
728 );
729}
730
731test "weirdly nested map of maps of lists" {
732 try parseSuccess(
733 \\a:
734 \\ b:
735 \\ - 0
736 \\ - 1
737 );
738}
739
740test "square brackets denote a list" {
741 try parseSuccess(
742 \\[ a,
743 \\ b, c ]
744 );
745}
746
747test "empty list" {
748 try parseSuccess(
749 \\[ ]
750 );
751}
752
753test "comment within a bracketed list is an error" {
754 try parseError(
755 \\[ # something
756 \\]
757 , error.MalformedYaml);
758}
759
760test "mixed ints with floats in a list" {
761 try parseSuccess(
762 \\[0, 1.0]
763 );
764}