1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
|
use knuffel::span::Span;
use knuffel::traits::Decode;
use knuffel::ast::{TypeName, BuiltinType};
#[derive(knuffel_derive::Decode, Debug, PartialEq)]
struct Child;
#[derive(knuffel_derive::Decode, Debug, PartialEq)]
#[knuffel(span_type=Span)]
struct NodeSpan {
#[knuffel(span)]
span: Span,
#[knuffel(argument)]
name: String,
#[knuffel(children)]
children: Vec<Child>,
}
#[derive(knuffel_derive::Decode, Debug, PartialEq)]
struct NodeType {
#[knuffel(type_name)]
type_name: String,
}
#[derive(knuffel_derive::Decode, Debug, PartialEq)]
struct NameAndType {
#[knuffel(node_name)]
node_name: String,
#[knuffel(type_name)]
type_name: Option<TypeName>,
}
fn parse<T: Decode<Span>>(text: &str) -> T {
let mut nodes: Vec<T> = knuffel::parse("<test>", text).unwrap();
assert_eq!(nodes.len(), 1);
nodes.remove(0)
}
#[test]
fn parse_node_span() {
assert_eq!(parse::<NodeSpan>(r#"node "hello""#),
NodeSpan {
span: Span(0, 12),
name: "hello".into(),
children: Vec::new(),
});
assert_eq!(parse::<NodeSpan>(r#" node "hello" "#),
NodeSpan {
span: Span(3, 21),
name: "hello".into(),
children: Vec::new(),
});
assert_eq!(parse::<NodeSpan>(r#" node "hello"; "#),
NodeSpan {
span: Span(3, 17),
name: "hello".into(),
children: Vec::new(),
});
assert_eq!(parse::<NodeSpan>(r#" node "hello" { child; }"#),
NodeSpan {
span: Span(3, 35),
name: "hello".into(),
children: vec![Child],
});
}
#[test]
fn parse_node_type() {
assert_eq!(parse::<NodeType>(r#"(unknown)node {}"#),
NodeType { type_name: "unknown".into() });
}
#[test]
fn parse_name_and_type() {
assert_eq!(parse::<NameAndType>(r#"(u32)nodexxx"#),
NameAndType {
node_name: "nodexxx".into(),
type_name: Some(BuiltinType::U32.into()),
});
assert_eq!(parse::<NameAndType>(r#"yyynode /-{ }"#),
NameAndType {
node_name: "yyynode".into(),
type_name: None,
});
}
|
