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 }