tests/loader.cpp

   1 #include <msp/datafile/dataerror.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 bad_keyword();
  21         void bad_signature();
  22 };
  23
  24 class TestObject
  25 {
  26 public:
  27         class Loader: public DataFile::ObjectLoader<TestObject>
  28         {
  29         public:
  30                 Loader(TestObject &);
  31
  32         private:
  33                 void func();
  34         };
  35
  36         int i;
  37         float f;
  38         string s;
  39         bool func_called;
  40
  41         TestObject();
  42 };
  43
  44 LoaderTests::LoaderTests()
  45 {
  46         add(&LoaderTests::load, "Load");
  47         add(&LoaderTests::int_as_float, "Int -> float");
  48         add(&LoaderTests::bad_keyword, "Bad keyword").expect_throw<DataFile::data_error>();
  49         add(&LoaderTests::bad_signature, "Bad signature").expect_throw<DataFile::data_error>();
  50 }
  51
  52 void LoaderTests::load()
  53 {
  54         const char input[] =
  55                 "i 1;\n"
  56                 "f 2.5;\n"
  57                 "s \"foo\";\n"
  58                 "c;\n";
  59
  60         TestObject obj;
  61         IO::Memory mem(input, sizeof(input)-1);
  62         DataFile::Parser parser(mem, "-");
  63         TestObject::Loader loader(obj);
  64         loader.load(parser);
  65
  66         EXPECT_EQUAL(obj.i, 1);
  67         EXPECT_EQUAL(obj.f, 2.5);
  68         EXPECT_EQUAL(obj.s, "foo");
  69         EXPECT_EQUAL(obj.func_called, true);
  70 }
  71
  72 void LoaderTests::int_as_float()
  73 {
  74         const char input[] =
  75                 "f 2;\n";
  76
  77         TestObject obj;
  78         IO::Memory mem(input, sizeof(input)-1);
  79         DataFile::Parser parser(mem, "-");
  80         TestObject::Loader loader(obj);
  81         loader.load(parser);
  82
  83         EXPECT_EQUAL(obj.f, 2);
  84 }
  85
  86 void LoaderTests::bad_keyword()
  87 {
  88         const char input[] =
  89                 "a;\n";
  90
  91         TestObject obj;
  92         IO::Memory mem(input, sizeof(input)-1);
  93         DataFile::Parser parser(mem, "-");
  94         TestObject::Loader loader(obj);
  95         loader.load(parser);
  96 }
  97
  98 void LoaderTests::bad_signature()
  99 {
 100         const char input[] =
 101                 "i 2.5;\n";
 102
 103         TestObject obj;
 104         IO::Memory mem(input, sizeof(input)-1);
 105         DataFile::Parser parser(mem, "-");
 106         TestObject::Loader loader(obj);
 107         loader.load(parser);
 108 }
 109
 110 TestObject::TestObject():
 111         i(0),
 112         f(0),
 113         func_called(false)
 114 { }
 115
 116 TestObject::Loader::Loader(TestObject &o):
 117         DataFile::ObjectLoader<TestObject>(o)
 118 {
 119         add("i", &TestObject::i);
 120         add("f", &TestObject::f);
 121         add("s", &TestObject::s);
 122         add("c", &Loader::func);
 123 }
 124
 125 void TestObject::Loader::func()
 126 {
 127         obj.func_called = true;
 128 }