]> git.tdb.fi Git - libs/datafile.git/blob - tests/parser.cpp
Improve the documentation of Collection
[libs/datafile.git] / tests / parser.cpp
1 #include <msp/datafile/dataerror.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 unterminated_comment();
22         void missing_semicolon();
23         void bad_string();
24         void bad_float();
25 };
26
27 ParserTests::ParserTests()
28 {
29         add(&ParserTests::keyword_only, "Keyword only");
30         add(&ParserTests::arguments, "Arguments");
31         add(&ParserTests::substatements, "Substatements");
32         add(&ParserTests::empty, "Empty input");
33         add(&ParserTests::unterminated_comment, "Unterminated comment").expect_throw<DataFile::data_error>();
34         add(&ParserTests::missing_semicolon, "Missing semicolon").expect_throw<DataFile::data_error>();
35         add(&ParserTests::bad_string, "Bad string").expect_throw<DataFile::data_error>();
36         add(&ParserTests::bad_float, "Bad float").expect_throw<DataFile::data_error>();
37 }
38
39 void ParserTests::keyword_only()
40 {
41         static const char input[] =
42                 "foo; bar;\n"
43                 "quux;\n";
44
45         IO::Memory mem(input, sizeof(input)-1);
46         DataFile::Parser parser(mem, "-");
47         DataFile::Statement st = parser.parse();
48         EXPECT_EQUAL(st.keyword, "foo");
49         st = parser.parse();
50         EXPECT_EQUAL(st.keyword, "bar");
51         st = parser.parse();
52         EXPECT_EQUAL(st.keyword, "quux");
53 }
54
55 void ParserTests::arguments()
56 {
57         static const char input[] =
58                 "foo 1 true;\n"
59                 "bar 3.45;\n"
60                 "quux a \"s\";\n";
61
62         IO::Memory mem(input, sizeof(input)-1);
63         DataFile::Parser parser(mem, "-");
64         DataFile::Statement st = parser.parse();
65         EXPECT_EQUAL(st.keyword, "foo");
66         EXPECT_EQUAL(st.args.size(), 2);
67         EXPECT_EQUAL(st.args[0].get_signature(), DataFile::IntType::signature);
68         EXPECT_EQUAL(st.args[1].get_signature(), DataFile::BoolType::signature);
69         st = parser.parse();
70         EXPECT_EQUAL(st.keyword, "bar");
71         EXPECT_EQUAL(st.args.size(), 1);
72         EXPECT_EQUAL(st.args[0].get_signature(), DataFile::FloatType::signature);
73         st = parser.parse();
74         EXPECT_EQUAL(st.keyword, "quux");
75         EXPECT_EQUAL(st.args.size(), 2);
76         EXPECT_EQUAL(st.args[0].get_signature(), DataFile::SymbolType::signature);
77         EXPECT_EQUAL(st.args[1].get_signature(), DataFile::StringType::signature);
78 }
79
80 void ParserTests::substatements()
81 {
82         static const char input[] =
83                 "top { sub; };\n";
84
85         IO::Memory mem(input, sizeof(input)-1);
86         DataFile::Parser parser(mem, "-");
87         DataFile::Statement st = parser.parse();
88         EXPECT_EQUAL(st.keyword, "top");
89         EXPECT_EQUAL(st.sub.size(), 1);
90         EXPECT_EQUAL(st.sub.front().keyword, "sub");
91 }
92
93 void ParserTests::empty()
94 {
95         static const char input[] = { 0 };
96
97         IO::Memory mem(input, 0U);
98         DataFile::Parser parser(mem, "-");
99         DataFile::Statement st = parser.parse();
100         EXPECT(!st.valid);
101 }
102
103 void ParserTests::unterminated_comment()
104 {
105         static const char input[] =
106                 " /* comment\n";
107
108         IO::Memory mem(input, sizeof(input)-1);
109         DataFile::Parser parser(mem, "-");
110         parser.parse();
111 }
112
113 void ParserTests::missing_semicolon()
114 {
115         static const char input[] =
116                 "foo { }\nbar;\n";
117
118         IO::Memory mem(input, sizeof(input)-1);
119         DataFile::Parser parser(mem, "-");
120         parser.parse();
121 }
122
123 void ParserTests::bad_string()
124 {
125         static const char input[] =
126                 "foo \"quu\"x;\n";
127
128         IO::Memory mem(input, sizeof(input)-1);
129         DataFile::Parser parser(mem, "-");
130         parser.parse();
131 }
132
133 void ParserTests::bad_float()
134 {
135         static const char input[] =
136                 "foo 1.234.5;\n";
137
138         IO::Memory mem(input, sizeof(input)-1);
139         DataFile::Parser parser(mem, "-");
140         parser.parse();
141 }