tests/loader.cpp

   1 #include <msp/datafile/except.h>
   2 #include <msp/datafile/loader.h>
   3 #include <msp/datafile/objectloader.h>
   4 #include <msp/io/memory.h>
   5 #include <msp/test/test.h>
   6
   7 using namespace std;
   8 using namespace Msp;
   9
  10 class LoaderTests: public Test::RegisteredTest<LoaderTests>
  11 {
  12 public:
  13         LoaderTests();
  14
  15         static const char *get_name() { return "Loader"; }
  16
  17 private:
  18         void load();
  19         void int_as_float();
  20         void overload();
  21         void bad_keyword();
  22         void bad_signature();
  23 };
  24
  25 class TestObject
  26 {
  27 public:
  28         class Loader: public DataFile::ObjectLoader<TestObject>
  29         {
  30         public:
  31                 Loader(TestObject &);
  32
  33         private:
  34                 void func();
  35         };
  36
  37         int i;
  38         float f;
  39         string s;
  40         bool func_called;
  41
  42         TestObject();
  43 };
  44
  45 LoaderTests::LoaderTests()
  46 {
  47         add(&LoaderTests::load, "Load");
  48         add(&LoaderTests::int_as_float, "Int -> float");
  49         add(&LoaderTests::overload, "Overload resolution");
  50         add(&LoaderTests::bad_keyword, "Bad keyword").expect_throw<DataFile::data_error>();
  51         add(&LoaderTests::bad_signature, "Bad signature").expect_throw<DataFile::data_error>();
  52 }
  53
  54 void LoaderTests::load()
  55 {
  56         const char input[] =
  57                 "i 1;\n"
  58                 "f 2.5;\n"
  59                 "s \"foo\";\n"
  60                 "c;\n";
  61
  62         TestObject obj;
  63         IO::Memory mem(input, sizeof(input)-1);
  64         DataFile::Parser parser(mem, "-");
  65         TestObject::Loader loader(obj);
  66         loader.load(parser);
  67
  68         EXPECT_EQUAL(obj.i, 1);
  69         EXPECT_EQUAL(obj.f, 2.5);
  70         EXPECT_EQUAL(obj.s, "foo");
  71         EXPECT_EQUAL(obj.func_called, true);
  72 }
  73
  74 void LoaderTests::int_as_float()
  75 {
  76         const char input[] =
  77                 "f 2;\n";
  78
  79         TestObject obj;
  80         IO::Memory mem(input, sizeof(input)-1);
  81         DataFile::Parser parser(mem, "-");
  82         TestObject::Loader loader(obj);
  83         loader.load(parser);
  84
  85         EXPECT_EQUAL(obj.f, 2);
  86 }
  87
  88 void LoaderTests::overload()
  89 {
  90         const char input[] =
  91                 "o 1.0;\n"
  92                 "o 2;\n";
  93
  94         TestObject obj;
  95         IO::Memory mem(input, sizeof(input)-1);
  96         DataFile::Parser parser(mem, "-");
  97         TestObject::Loader loader(obj);
  98         loader.load(parser);
  99
 100         EXPECT_EQUAL(obj.f, 1.0f);
 101         EXPECT_EQUAL(obj.i, 2);
 102 }
 103
 104 void LoaderTests::bad_keyword()
 105 {
 106         const char input[] =
 107                 "a;\n";
 108
 109         TestObject obj;
 110         IO::Memory mem(input, sizeof(input)-1);
 111         DataFile::Parser parser(mem, "-");
 112         TestObject::Loader loader(obj);
 113         loader.load(parser);
 114 }
 115
 116 void LoaderTests::bad_signature()
 117 {
 118         const char input[] =
 119                 "i 2.5;\n";
 120
 121         TestObject obj;
 122         IO::Memory mem(input, sizeof(input)-1);
 123         DataFile::Parser parser(mem, "-");
 124         TestObject::Loader loader(obj);
 125         loader.load(parser);
 126 }
 127
 128 TestObject::TestObject():
 129         i(0),
 130         f(0),
 131         func_called(false)
 132 { }
 133
 134 TestObject::Loader::Loader(TestObject &o):
 135         DataFile::ObjectLoader<TestObject>(o)
 136 {
 137         add("i", &TestObject::i);
 138         add("f", &TestObject::f);
 139         add("o", &TestObject::i);
 140         add("o", &TestObject::f);
 141         add("s", &TestObject::s);
 142         add("c", &Loader::func);
 143 }
 144
 145 void TestObject::Loader::func()
 146 {
 147         obj.func_called = true;
 148 }