]> git.tdb.fi Git - libs/datafile.git/blob - tests/parser.cpp
Update a SFINAE construct
[libs/datafile.git] / tests / parser.cpp
1 #include <msp/datafile/except.h>
2 #include <msp/datafile/parser.h>
3 #include <msp/datafile/statement.h>
4 #include <msp/io/memory.h>
5 #include <msp/test/test.h>
6
7 using namespace Msp;
8
9 class ParserTests: public Test::RegisteredTest<ParserTests>
10 {
11 public:
12         ParserTests();
13
14         static const char *get_name() { return "Parser"; }
15
16 private:
17         void keyword_only();
18         void arguments();
19         void substatements();
20         void empty();
21         void comments();
22         void unterminated_comment();
23         void missing_semicolon();
24         void bad_string();
25         void bad_float();
26 };
27
28 ParserTests::ParserTests()
29 {
30         add(&ParserTests::keyword_only, "Keyword only");
31         add(&ParserTests::arguments, "Arguments");
32         add(&ParserTests::substatements, "Substatements");
33         add(&ParserTests::empty, "Empty input");
34         add(&ParserTests::comments, "Comments");
35         add(&ParserTests::unterminated_comment, "Unterminated comment").expect_throw<DataFile::data_error>();
36         add(&ParserTests::missing_semicolon, "Missing semicolon").expect_throw<DataFile::data_error>();
37         add(&ParserTests::bad_string, "Bad string").expect_throw<DataFile::data_error>();
38         add(&ParserTests::bad_float, "Bad float").expect_throw<DataFile::data_error>();
39 }
40
41 void ParserTests::keyword_only()
42 {
43         static const char input[] =
44                 "foo; bar;\n"
45                 "quux;\n";
46
47         IO::Memory mem(input, sizeof(input)-1);
48         DataFile::Parser parser(mem, "-");
49         DataFile::Statement st = parser.parse();
50         EXPECT_EQUAL(st.keyword, "foo");
51         st = parser.parse();
52         EXPECT_EQUAL(st.keyword, "bar");
53         st = parser.parse();
54         EXPECT_EQUAL(st.keyword, "quux");
55 }
56
57 void ParserTests::arguments()
58 {
59         static const char input[] =
60                 "foo 1 true;\n"
61                 "bar 3.45;\n"
62                 "quux a \"s\";\n";
63
64         IO::Memory mem(input, sizeof(input)-1);
65         DataFile::Parser parser(mem, "-");
66         DataFile::Statement st = parser.parse();
67         EXPECT_EQUAL(st.keyword, "foo");
68         EXPECT_EQUAL(st.args.size(), 2);
69         EXPECT_EQUAL(st.args[0].get_signature(), DataFile::IntType::signature);
70         EXPECT_EQUAL(st.args[1].get_signature(), DataFile::BoolType::signature);
71         st = parser.parse();
72         EXPECT_EQUAL(st.keyword, "bar");
73         EXPECT_EQUAL(st.args.size(), 1);
74         EXPECT_EQUAL(st.args[0].get_signature(), DataFile::FloatType::signature);
75         st = parser.parse();
76         EXPECT_EQUAL(st.keyword, "quux");
77         EXPECT_EQUAL(st.args.size(), 2);
78         EXPECT_EQUAL(st.args[0].get_signature(), DataFile::SymbolType::signature);
79         EXPECT_EQUAL(st.args[1].get_signature(), DataFile::StringType::signature);
80 }
81
82 void ParserTests::substatements()
83 {
84         static const char input[] =
85                 "top { sub; };\n";
86
87         IO::Memory mem(input, sizeof(input)-1);
88         DataFile::Parser parser(mem, "-");
89         DataFile::Statement st = parser.parse();
90         EXPECT_EQUAL(st.keyword, "top");
91         EXPECT_EQUAL(st.sub.size(), 1);
92         EXPECT_EQUAL(st.sub.front().keyword, "sub");
93 }
94
95 void ParserTests::empty()
96 {
97         static const char input[] = { 0 };
98
99         IO::Memory mem(input, 0U);
100         DataFile::Parser parser(mem, "-");
101         DataFile::Statement st = parser.parse();
102         EXPECT(!st.valid);
103 }
104
105 void ParserTests::comments()
106 {
107         static const char input[] =
108                 "// line comment\n"
109                 "a;\n"
110                 "/* block\n"
111                 "comment */\n"
112                 "b;\n"
113                 "/* block comment with embedded // double\n"
114                 "slash */\n"
115                 "c;\n"
116                 "// line comment with embedded /* slash star\n"
117                 "d;\n";
118
119         IO::Memory mem(input, sizeof(input)-1);
120         DataFile::Parser parser(mem, "-");
121         DataFile::Statement st = parser.parse();
122         EXPECT_EQUAL(st.keyword, "a");
123         st = parser.parse();
124         EXPECT_EQUAL(st.keyword, "b");
125         st = parser.parse();
126         EXPECT_EQUAL(st.keyword, "c");
127         st = parser.parse();
128         EXPECT_EQUAL(st.keyword, "d");
129 }
130
131 void ParserTests::unterminated_comment()
132 {
133         static const char input[] =
134                 " /* comment\n";
135
136         IO::Memory mem(input, sizeof(input)-1);
137         DataFile::Parser parser(mem, "-");
138         parser.parse();
139 }
140
141 void ParserTests::missing_semicolon()
142 {
143         static const char input[] =
144                 "foo { }\nbar;\n";
145
146         IO::Memory mem(input, sizeof(input)-1);
147         DataFile::Parser parser(mem, "-");
148         parser.parse();
149 }
150
151 void ParserTests::bad_string()
152 {
153         static const char input[] =
154                 "foo \"quu\"x;\n";
155
156         IO::Memory mem(input, sizeof(input)-1);
157         DataFile::Parser parser(mem, "-");
158         parser.parse();
159 }
160
161 void ParserTests::bad_float()
162 {
163         static const char input[] =
164                 "foo 1.234.5;\n";
165
166         IO::Memory mem(input, sizeof(input)-1);
167         DataFile::Parser parser(mem, "-");
168         parser.parse();
169 }