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 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 }