mirror of
https://github.com/ziglang/zig.git
synced 2025-12-28 09:03:21 +00:00
557 lines
19 KiB
Zig
557 lines
19 KiB
Zig
const std = @import("std");
|
|
const mem = std.mem;
|
|
const testing = std.testing;
|
|
const Tree = @import("../parse.zig").Tree;
|
|
const Node = @import("../parse.zig").Node;
|
|
|
|
test "explicit doc" {
|
|
const source =
|
|
\\--- !tapi-tbd
|
|
\\tbd-version: 4
|
|
\\abc-version: 5
|
|
\\...
|
|
;
|
|
|
|
var tree = Tree.init(testing.allocator);
|
|
defer tree.deinit();
|
|
try tree.parse(source);
|
|
|
|
try testing.expectEqual(tree.docs.items.len, 1);
|
|
|
|
const doc = tree.docs.items[0].cast(Node.Doc).?;
|
|
try testing.expectEqual(doc.start.?, 0);
|
|
try testing.expectEqual(doc.end.?, tree.tokens.len - 2);
|
|
|
|
const directive = tree.tokens[doc.directive.?];
|
|
try testing.expectEqual(directive.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "tapi-tbd", tree.source[directive.start..directive.end]));
|
|
|
|
try testing.expect(doc.value != null);
|
|
try testing.expectEqual(doc.value.?.tag, .map);
|
|
|
|
const map = doc.value.?.cast(Node.Map).?;
|
|
try testing.expectEqual(map.start.?, 5);
|
|
try testing.expectEqual(map.end.?, 14);
|
|
try testing.expectEqual(map.values.items.len, 2);
|
|
|
|
{
|
|
const entry = map.values.items[0];
|
|
|
|
const key = tree.tokens[entry.key];
|
|
try testing.expectEqual(key.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "tbd-version", tree.source[key.start..key.end]));
|
|
|
|
const value = entry.value.cast(Node.Value).?;
|
|
const value_tok = tree.tokens[value.start.?];
|
|
try testing.expectEqual(value_tok.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "4", tree.source[value_tok.start..value_tok.end]));
|
|
}
|
|
|
|
{
|
|
const entry = map.values.items[1];
|
|
|
|
const key = tree.tokens[entry.key];
|
|
try testing.expectEqual(key.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "abc-version", tree.source[key.start..key.end]));
|
|
|
|
const value = entry.value.cast(Node.Value).?;
|
|
const value_tok = tree.tokens[value.start.?];
|
|
try testing.expectEqual(value_tok.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "5", tree.source[value_tok.start..value_tok.end]));
|
|
}
|
|
}
|
|
|
|
test "leaf in quotes" {
|
|
const source =
|
|
\\key1: no quotes
|
|
\\key2: 'single quoted'
|
|
\\key3: "double quoted"
|
|
;
|
|
|
|
var tree = Tree.init(testing.allocator);
|
|
defer tree.deinit();
|
|
try tree.parse(source);
|
|
|
|
try testing.expectEqual(tree.docs.items.len, 1);
|
|
|
|
const doc = tree.docs.items[0].cast(Node.Doc).?;
|
|
try testing.expectEqual(doc.start.?, 0);
|
|
try testing.expectEqual(doc.end.?, tree.tokens.len - 2);
|
|
try testing.expect(doc.directive == null);
|
|
|
|
try testing.expect(doc.value != null);
|
|
try testing.expectEqual(doc.value.?.tag, .map);
|
|
|
|
const map = doc.value.?.cast(Node.Map).?;
|
|
try testing.expectEqual(map.start.?, 0);
|
|
try testing.expectEqual(map.end.?, tree.tokens.len - 2);
|
|
try testing.expectEqual(map.values.items.len, 3);
|
|
|
|
{
|
|
const entry = map.values.items[0];
|
|
|
|
const key = tree.tokens[entry.key];
|
|
try testing.expectEqual(key.id, .Literal);
|
|
try testing.expect(mem.eql(
|
|
u8,
|
|
"key1",
|
|
tree.source[key.start..key.end],
|
|
));
|
|
|
|
const value = entry.value.cast(Node.Value).?;
|
|
const start = tree.tokens[value.start.?];
|
|
const end = tree.tokens[value.end.?];
|
|
try testing.expectEqual(start.id, .Literal);
|
|
try testing.expectEqual(end.id, .Literal);
|
|
try testing.expect(mem.eql(
|
|
u8,
|
|
"no quotes",
|
|
tree.source[start.start..end.end],
|
|
));
|
|
}
|
|
}
|
|
|
|
test "nested maps" {
|
|
const source =
|
|
\\key1:
|
|
\\ key1_1 : value1_1
|
|
\\ key1_2 : value1_2
|
|
\\key2 : value2
|
|
;
|
|
|
|
var tree = Tree.init(testing.allocator);
|
|
defer tree.deinit();
|
|
try tree.parse(source);
|
|
|
|
try testing.expectEqual(tree.docs.items.len, 1);
|
|
|
|
const doc = tree.docs.items[0].cast(Node.Doc).?;
|
|
try testing.expectEqual(doc.start.?, 0);
|
|
try testing.expectEqual(doc.end.?, tree.tokens.len - 2);
|
|
try testing.expect(doc.directive == null);
|
|
|
|
try testing.expect(doc.value != null);
|
|
try testing.expectEqual(doc.value.?.tag, .map);
|
|
|
|
const map = doc.value.?.cast(Node.Map).?;
|
|
try testing.expectEqual(map.start.?, 0);
|
|
try testing.expectEqual(map.end.?, tree.tokens.len - 2);
|
|
try testing.expectEqual(map.values.items.len, 2);
|
|
|
|
{
|
|
const entry = map.values.items[0];
|
|
|
|
const key = tree.tokens[entry.key];
|
|
try testing.expectEqual(key.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "key1", tree.source[key.start..key.end]));
|
|
|
|
const nested_map = entry.value.cast(Node.Map).?;
|
|
try testing.expectEqual(nested_map.start.?, 4);
|
|
try testing.expectEqual(nested_map.end.?, 16);
|
|
try testing.expectEqual(nested_map.values.items.len, 2);
|
|
|
|
{
|
|
const nested_entry = nested_map.values.items[0];
|
|
|
|
const nested_key = tree.tokens[nested_entry.key];
|
|
try testing.expectEqual(nested_key.id, .Literal);
|
|
try testing.expect(mem.eql(
|
|
u8,
|
|
"key1_1",
|
|
tree.source[nested_key.start..nested_key.end],
|
|
));
|
|
|
|
const nested_value = nested_entry.value.cast(Node.Value).?;
|
|
const nested_value_tok = tree.tokens[nested_value.start.?];
|
|
try testing.expectEqual(nested_value_tok.id, .Literal);
|
|
try testing.expect(mem.eql(
|
|
u8,
|
|
"value1_1",
|
|
tree.source[nested_value_tok.start..nested_value_tok.end],
|
|
));
|
|
}
|
|
|
|
{
|
|
const nested_entry = nested_map.values.items[1];
|
|
|
|
const nested_key = tree.tokens[nested_entry.key];
|
|
try testing.expectEqual(nested_key.id, .Literal);
|
|
try testing.expect(mem.eql(
|
|
u8,
|
|
"key1_2",
|
|
tree.source[nested_key.start..nested_key.end],
|
|
));
|
|
|
|
const nested_value = nested_entry.value.cast(Node.Value).?;
|
|
const nested_value_tok = tree.tokens[nested_value.start.?];
|
|
try testing.expectEqual(nested_value_tok.id, .Literal);
|
|
try testing.expect(mem.eql(
|
|
u8,
|
|
"value1_2",
|
|
tree.source[nested_value_tok.start..nested_value_tok.end],
|
|
));
|
|
}
|
|
}
|
|
|
|
{
|
|
const entry = map.values.items[1];
|
|
|
|
const key = tree.tokens[entry.key];
|
|
try testing.expectEqual(key.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "key2", tree.source[key.start..key.end]));
|
|
|
|
const value = entry.value.cast(Node.Value).?;
|
|
const value_tok = tree.tokens[value.start.?];
|
|
try testing.expectEqual(value_tok.id, .Literal);
|
|
try testing.expect(mem.eql(
|
|
u8,
|
|
"value2",
|
|
tree.source[value_tok.start..value_tok.end],
|
|
));
|
|
}
|
|
}
|
|
|
|
test "map of list of values" {
|
|
const source =
|
|
\\ints:
|
|
\\ - 0
|
|
\\ - 1
|
|
\\ - 2
|
|
;
|
|
var tree = Tree.init(testing.allocator);
|
|
defer tree.deinit();
|
|
try tree.parse(source);
|
|
|
|
try testing.expectEqual(tree.docs.items.len, 1);
|
|
|
|
const doc = tree.docs.items[0].cast(Node.Doc).?;
|
|
try testing.expectEqual(doc.start.?, 0);
|
|
try testing.expectEqual(doc.end.?, tree.tokens.len - 2);
|
|
|
|
try testing.expect(doc.value != null);
|
|
try testing.expectEqual(doc.value.?.tag, .map);
|
|
|
|
const map = doc.value.?.cast(Node.Map).?;
|
|
try testing.expectEqual(map.start.?, 0);
|
|
try testing.expectEqual(map.end.?, tree.tokens.len - 2);
|
|
try testing.expectEqual(map.values.items.len, 1);
|
|
|
|
const entry = map.values.items[0];
|
|
const key = tree.tokens[entry.key];
|
|
try testing.expectEqual(key.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "ints", tree.source[key.start..key.end]));
|
|
|
|
const value = entry.value.cast(Node.List).?;
|
|
try testing.expectEqual(value.start.?, 4);
|
|
try testing.expectEqual(value.end.?, tree.tokens.len - 2);
|
|
try testing.expectEqual(value.values.items.len, 3);
|
|
|
|
{
|
|
const elem = value.values.items[0].cast(Node.Value).?;
|
|
const leaf = tree.tokens[elem.start.?];
|
|
try testing.expectEqual(leaf.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "0", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
|
|
{
|
|
const elem = value.values.items[1].cast(Node.Value).?;
|
|
const leaf = tree.tokens[elem.start.?];
|
|
try testing.expectEqual(leaf.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "1", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
|
|
{
|
|
const elem = value.values.items[2].cast(Node.Value).?;
|
|
const leaf = tree.tokens[elem.start.?];
|
|
try testing.expectEqual(leaf.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "2", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
}
|
|
|
|
test "map of list of maps" {
|
|
const source =
|
|
\\key1:
|
|
\\- key2 : value2
|
|
\\- key3 : value3
|
|
\\- key4 : value4
|
|
;
|
|
|
|
var tree = Tree.init(testing.allocator);
|
|
defer tree.deinit();
|
|
try tree.parse(source);
|
|
|
|
try testing.expectEqual(tree.docs.items.len, 1);
|
|
|
|
const doc = tree.docs.items[0].cast(Node.Doc).?;
|
|
try testing.expectEqual(doc.start.?, 0);
|
|
try testing.expectEqual(doc.end.?, tree.tokens.len - 2);
|
|
|
|
try testing.expect(doc.value != null);
|
|
try testing.expectEqual(doc.value.?.tag, .map);
|
|
|
|
const map = doc.value.?.cast(Node.Map).?;
|
|
try testing.expectEqual(map.start.?, 0);
|
|
try testing.expectEqual(map.end.?, tree.tokens.len - 2);
|
|
try testing.expectEqual(map.values.items.len, 1);
|
|
|
|
const entry = map.values.items[0];
|
|
const key = tree.tokens[entry.key];
|
|
try testing.expectEqual(key.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "key1", tree.source[key.start..key.end]));
|
|
|
|
const value = entry.value.cast(Node.List).?;
|
|
try testing.expectEqual(value.start.?, 3);
|
|
try testing.expectEqual(value.end.?, tree.tokens.len - 2);
|
|
try testing.expectEqual(value.values.items.len, 3);
|
|
|
|
{
|
|
const elem = value.values.items[0].cast(Node.Map).?;
|
|
const nested = elem.values.items[0];
|
|
const nested_key = tree.tokens[nested.key];
|
|
try testing.expectEqual(nested_key.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "key2", tree.source[nested_key.start..nested_key.end]));
|
|
|
|
const nested_v = nested.value.cast(Node.Value).?;
|
|
const leaf = tree.tokens[nested_v.start.?];
|
|
try testing.expectEqual(leaf.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "value2", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
|
|
{
|
|
const elem = value.values.items[1].cast(Node.Map).?;
|
|
const nested = elem.values.items[0];
|
|
const nested_key = tree.tokens[nested.key];
|
|
try testing.expectEqual(nested_key.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "key3", tree.source[nested_key.start..nested_key.end]));
|
|
|
|
const nested_v = nested.value.cast(Node.Value).?;
|
|
const leaf = tree.tokens[nested_v.start.?];
|
|
try testing.expectEqual(leaf.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "value3", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
|
|
{
|
|
const elem = value.values.items[2].cast(Node.Map).?;
|
|
const nested = elem.values.items[0];
|
|
const nested_key = tree.tokens[nested.key];
|
|
try testing.expectEqual(nested_key.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "key4", tree.source[nested_key.start..nested_key.end]));
|
|
|
|
const nested_v = nested.value.cast(Node.Value).?;
|
|
const leaf = tree.tokens[nested_v.start.?];
|
|
try testing.expectEqual(leaf.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "value4", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
}
|
|
|
|
test "list of lists" {
|
|
const source =
|
|
\\- [name , hr, avg ]
|
|
\\- [Mark McGwire , 65, 0.278]
|
|
\\- [Sammy Sosa , 63, 0.288]
|
|
;
|
|
|
|
var tree = Tree.init(testing.allocator);
|
|
defer tree.deinit();
|
|
try tree.parse(source);
|
|
|
|
try testing.expectEqual(tree.docs.items.len, 1);
|
|
|
|
const doc = tree.docs.items[0].cast(Node.Doc).?;
|
|
try testing.expectEqual(doc.start.?, 0);
|
|
try testing.expectEqual(doc.end.?, tree.tokens.len - 2);
|
|
|
|
try testing.expect(doc.value != null);
|
|
try testing.expectEqual(doc.value.?.tag, .list);
|
|
|
|
const list = doc.value.?.cast(Node.List).?;
|
|
try testing.expectEqual(list.start.?, 0);
|
|
try testing.expectEqual(list.end.?, tree.tokens.len - 2);
|
|
try testing.expectEqual(list.values.items.len, 3);
|
|
|
|
{
|
|
try testing.expectEqual(list.values.items[0].tag, .list);
|
|
const nested = list.values.items[0].cast(Node.List).?;
|
|
try testing.expectEqual(nested.values.items.len, 3);
|
|
|
|
{
|
|
try testing.expectEqual(nested.values.items[0].tag, .value);
|
|
const value = nested.values.items[0].cast(Node.Value).?;
|
|
const leaf = tree.tokens[value.start.?];
|
|
try testing.expect(mem.eql(u8, "name", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
|
|
{
|
|
try testing.expectEqual(nested.values.items[1].tag, .value);
|
|
const value = nested.values.items[1].cast(Node.Value).?;
|
|
const leaf = tree.tokens[value.start.?];
|
|
try testing.expect(mem.eql(u8, "hr", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
|
|
{
|
|
try testing.expectEqual(nested.values.items[2].tag, .value);
|
|
const value = nested.values.items[2].cast(Node.Value).?;
|
|
const leaf = tree.tokens[value.start.?];
|
|
try testing.expect(mem.eql(u8, "avg", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
}
|
|
|
|
{
|
|
try testing.expectEqual(list.values.items[1].tag, .list);
|
|
const nested = list.values.items[1].cast(Node.List).?;
|
|
try testing.expectEqual(nested.values.items.len, 3);
|
|
|
|
{
|
|
try testing.expectEqual(nested.values.items[0].tag, .value);
|
|
const value = nested.values.items[0].cast(Node.Value).?;
|
|
const start = tree.tokens[value.start.?];
|
|
const end = tree.tokens[value.end.?];
|
|
try testing.expect(mem.eql(u8, "Mark McGwire", tree.source[start.start..end.end]));
|
|
}
|
|
|
|
{
|
|
try testing.expectEqual(nested.values.items[1].tag, .value);
|
|
const value = nested.values.items[1].cast(Node.Value).?;
|
|
const leaf = tree.tokens[value.start.?];
|
|
try testing.expect(mem.eql(u8, "65", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
|
|
{
|
|
try testing.expectEqual(nested.values.items[2].tag, .value);
|
|
const value = nested.values.items[2].cast(Node.Value).?;
|
|
const leaf = tree.tokens[value.start.?];
|
|
try testing.expect(mem.eql(u8, "0.278", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
}
|
|
|
|
{
|
|
try testing.expectEqual(list.values.items[2].tag, .list);
|
|
const nested = list.values.items[2].cast(Node.List).?;
|
|
try testing.expectEqual(nested.values.items.len, 3);
|
|
|
|
{
|
|
try testing.expectEqual(nested.values.items[0].tag, .value);
|
|
const value = nested.values.items[0].cast(Node.Value).?;
|
|
const start = tree.tokens[value.start.?];
|
|
const end = tree.tokens[value.end.?];
|
|
try testing.expect(mem.eql(u8, "Sammy Sosa", tree.source[start.start..end.end]));
|
|
}
|
|
|
|
{
|
|
try testing.expectEqual(nested.values.items[1].tag, .value);
|
|
const value = nested.values.items[1].cast(Node.Value).?;
|
|
const leaf = tree.tokens[value.start.?];
|
|
try testing.expect(mem.eql(u8, "63", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
|
|
{
|
|
try testing.expectEqual(nested.values.items[2].tag, .value);
|
|
const value = nested.values.items[2].cast(Node.Value).?;
|
|
const leaf = tree.tokens[value.start.?];
|
|
try testing.expect(mem.eql(u8, "0.288", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
}
|
|
}
|
|
|
|
test "inline list" {
|
|
const source =
|
|
\\[name , hr, avg ]
|
|
;
|
|
|
|
var tree = Tree.init(testing.allocator);
|
|
defer tree.deinit();
|
|
try tree.parse(source);
|
|
|
|
try testing.expectEqual(tree.docs.items.len, 1);
|
|
|
|
const doc = tree.docs.items[0].cast(Node.Doc).?;
|
|
try testing.expectEqual(doc.start.?, 0);
|
|
try testing.expectEqual(doc.end.?, tree.tokens.len - 2);
|
|
|
|
try testing.expect(doc.value != null);
|
|
try testing.expectEqual(doc.value.?.tag, .list);
|
|
|
|
const list = doc.value.?.cast(Node.List).?;
|
|
try testing.expectEqual(list.start.?, 0);
|
|
try testing.expectEqual(list.end.?, tree.tokens.len - 2);
|
|
try testing.expectEqual(list.values.items.len, 3);
|
|
|
|
{
|
|
try testing.expectEqual(list.values.items[0].tag, .value);
|
|
const value = list.values.items[0].cast(Node.Value).?;
|
|
const leaf = tree.tokens[value.start.?];
|
|
try testing.expect(mem.eql(u8, "name", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
|
|
{
|
|
try testing.expectEqual(list.values.items[1].tag, .value);
|
|
const value = list.values.items[1].cast(Node.Value).?;
|
|
const leaf = tree.tokens[value.start.?];
|
|
try testing.expect(mem.eql(u8, "hr", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
|
|
{
|
|
try testing.expectEqual(list.values.items[2].tag, .value);
|
|
const value = list.values.items[2].cast(Node.Value).?;
|
|
const leaf = tree.tokens[value.start.?];
|
|
try testing.expect(mem.eql(u8, "avg", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
}
|
|
|
|
test "inline list as mapping value" {
|
|
const source =
|
|
\\key : [
|
|
\\ name ,
|
|
\\ hr, avg ]
|
|
;
|
|
|
|
var tree = Tree.init(testing.allocator);
|
|
defer tree.deinit();
|
|
try tree.parse(source);
|
|
|
|
try testing.expectEqual(tree.docs.items.len, 1);
|
|
|
|
const doc = tree.docs.items[0].cast(Node.Doc).?;
|
|
try testing.expectEqual(doc.start.?, 0);
|
|
try testing.expectEqual(doc.end.?, tree.tokens.len - 2);
|
|
|
|
try testing.expect(doc.value != null);
|
|
try testing.expectEqual(doc.value.?.tag, .map);
|
|
|
|
const map = doc.value.?.cast(Node.Map).?;
|
|
try testing.expectEqual(map.start.?, 0);
|
|
try testing.expectEqual(map.end.?, tree.tokens.len - 2);
|
|
try testing.expectEqual(map.values.items.len, 1);
|
|
|
|
const entry = map.values.items[0];
|
|
const key = tree.tokens[entry.key];
|
|
try testing.expectEqual(key.id, .Literal);
|
|
try testing.expect(mem.eql(u8, "key", tree.source[key.start..key.end]));
|
|
|
|
const list = entry.value.cast(Node.List).?;
|
|
try testing.expectEqual(list.start.?, 4);
|
|
try testing.expectEqual(list.end.?, tree.tokens.len - 2);
|
|
try testing.expectEqual(list.values.items.len, 3);
|
|
|
|
{
|
|
try testing.expectEqual(list.values.items[0].tag, .value);
|
|
const value = list.values.items[0].cast(Node.Value).?;
|
|
const leaf = tree.tokens[value.start.?];
|
|
try testing.expect(mem.eql(u8, "name", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
|
|
{
|
|
try testing.expectEqual(list.values.items[1].tag, .value);
|
|
const value = list.values.items[1].cast(Node.Value).?;
|
|
const leaf = tree.tokens[value.start.?];
|
|
try testing.expect(mem.eql(u8, "hr", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
|
|
{
|
|
try testing.expectEqual(list.values.items[2].tag, .value);
|
|
const value = list.values.items[2].cast(Node.Value).?;
|
|
const leaf = tree.tokens[value.start.?];
|
|
try testing.expect(mem.eql(u8, "avg", tree.source[leaf.start..leaf.end]));
|
|
}
|
|
}
|