]> git.tdb.fi Git - libs/datafile.git/blob - tests/loader.cpp
Update a SFINAE construct
[libs/datafile.git] / 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 }