src/tests/eet_cxx/eet_cxx_test_descriptors.cc

   1
   2 #include "Eet.hh"
   3
   4 #include <algorithm>
   5
   6 #include <iostream>
   7
   8 #include <check.h>
   9
  10 struct pod_type
  11 {
  12   int i;
  13   char c;
  14 };
  15
  16 START_TEST(eet_cxx_descriptors)
  17 {
  18   efl::eet::eet_init init;
  19
  20   auto d = efl::eet::make_descriptor
  21     ("pod_type"
  22      , efl::eet::type("i", &pod_type::i)
  23      , efl::eet::type("c", &pod_type::c));
  24   static_assert(std::is_same<efl::eet::descriptor<pod_type, int, char>, decltype(d)>::value, "");
  25
  26   Eet_File* file = eet_open("/tmp/eet_file_test.eet", EET_FILE_MODE_READ_WRITE);
  27   ck_assert(file != 0);
  28
  29   pod_type pod = {1, 2};
  30
  31   int s = eet_data_write(file, d.native_handle(), "pod", &pod, true);
  32   std::cout << "bytes written " << s << std::endl;
  33   ck_assert(s > 0);
  34   eet_sync(file);
  35   auto p = efl::eet::read_by_ptr(file, "pod", d);
  36   ck_assert(p != 0);
  37   ck_assert(p->i == 1);
  38   ck_assert(p->c == 2);
  39
  40   eet_close(file);
  41 }
  42 END_TEST
  43
  44 int constructors_called = 0
  45     , destructors_called = 0;
  46
  47 struct non_pod
  48 {
  49   non_pod() : i(10)
  50   {
  51     ++constructors_called;
  52   }
  53   non_pod(non_pod const& other)
  54     : i(other.i)
  55   {
  56     ++constructors_called;
  57   }
  58   ~non_pod()
  59   {
  60     ++destructors_called;
  61   }
  62
  63   int i;
  64 };
  65
  66 START_TEST(eet_cxx_descriptors_non_pod)
  67 {
  68   efl::eet::eet_init init;
  69
  70   auto d = efl::eet::make_descriptor
  71     ("pod_type", EET_CXX_MEMBER(non_pod, i));
  72   static_assert(std::is_same<efl::eet::descriptor<non_pod, int>, decltype(d)>::value, "");
  73
  74   {
  75     Eet_File* file = eet_open("/tmp/eet_file_test.eet", EET_FILE_MODE_READ_WRITE);
  76     ck_assert(file != 0);
  77
  78     ::non_pod non_pod;
  79
  80     int s = eet_data_write(file, d.native_handle(), "non_pod", &non_pod, true);
  81     std::cout << "bytes written " << s << std::endl;
  82     ck_assert(s > 0);
  83     eet_sync(file);
  84     auto p = efl::eet::read_by_ptr(file, "non_pod", d);
  85     ck_assert(p != 0);
  86     ck_assert(p->i == 10);
  87
  88     auto v = efl::eet::read(file, "non_pod", d);
  89     ck_assert(v.i == 10);
  90
  91     eet_close(file);
  92   }
  93
  94   std::cout << "constructors called for non pod: " << constructors_called
  95             << " destructors called for non pod: " << destructors_called << std::endl;
  96
  97   ck_assert(constructors_called == destructors_called);
  98 }
  99 END_TEST
 100
 101 struct pod_composited
 102 {
 103   pod_type* member;
 104 };
 105
 106 struct pod_composited_with_non_pod
 107 {
 108   non_pod* member;
 109 };
 110
 111 struct pod_value_composited
 112 {
 113   pod_type member;
 114 };
 115
 116 START_TEST(eet_cxx_descriptors_composition)
 117 {
 118   efl::eet::eet_init init;
 119
 120   auto pod_descriptor = efl::eet::make_descriptor
 121     ("pod_type"
 122      , efl::eet::type("i", &pod_type::i)
 123      , efl::eet::type("c", &pod_type::c));
 124   static_assert(std::is_same<efl::eet::descriptor<pod_type, int, char>
 125                 , decltype(pod_descriptor)>::value, "");
 126
 127   auto non_pod_descriptor = efl::eet::make_descriptor
 128     ("non_pod"
 129      , efl::eet::type("i", &non_pod::i));
 130   static_assert(std::is_same<efl::eet::descriptor<non_pod, int>
 131                 , decltype(non_pod_descriptor)>::value, "");
 132
 133   {
 134     auto d = efl::eet::make_descriptor
 135       ("pod_composited", efl::eet::type("pod_composited", &pod_composited::member, pod_descriptor));
 136     static_assert(std::is_same<efl::eet::descriptor<pod_composited, pod_type*>, decltype(d)>::value, "");
 137
 138     Eet_File* file = eet_open("/tmp/eet_file_test.eet", EET_FILE_MODE_READ_WRITE);
 139     ck_assert(file != 0);
 140
 141     ::pod_composited pod_composited {new pod_type{5, 'a'}};
 142
 143     int s = eet_data_write(file, d.native_handle(), "foo", &pod_composited, false);
 144     ck_assert(s > 0);
 145     eet_sync(file);
 146     auto p = efl::eet::read_by_ptr(file, "foo", d);
 147     ck_assert(p != 0);
 148     ck_assert(p->member->i == 5);
 149     ck_assert(p->member->c == 'a');
 150
 151     delete p->member;
 152
 153     auto v = efl::eet::read(file, "foo", d);
 154     ck_assert(v.member->i == 5);
 155     ck_assert(v.member->c == 'a');
 156
 157     delete v.member;
 158
 159     eet_close(file);
 160   }
 161
 162   {
 163     auto d = efl::eet::make_descriptor
 164       ("pod_composited_with_non_pod", efl::eet::type("pod_composited_with_non_pod", &pod_composited_with_non_pod::member, non_pod_descriptor));
 165     static_assert(std::is_same<efl::eet::descriptor<pod_composited_with_non_pod, non_pod*>, decltype(d)>::value, "");
 166
 167     Eet_File* file = eet_open("/tmp/eet_file_test.eet", EET_FILE_MODE_READ_WRITE);
 168     ck_assert(file != 0);
 169
 170     ::pod_composited_with_non_pod pod_composited_with_non_pod {new non_pod};
 171
 172     int s = eet_data_write(file, d.native_handle(), "foo", &pod_composited_with_non_pod, false);
 173     ck_assert(s > 0);
 174     eet_sync(file);
 175     auto p = efl::eet::read_by_ptr(file, "foo", d);
 176     ck_assert(p != 0);
 177     ck_assert(p->member->i == 10);
 178
 179     delete p->member;
 180
 181     auto v = efl::eet::read(file, "foo", d);
 182     ck_assert(v.member->i == 10);
 183
 184     delete v.member;
 185
 186     eet_close(file);
 187
 188     delete pod_composited_with_non_pod.member;
 189   }
 190
 191   std::cout << "constructors called for non pod: " << constructors_called
 192             << " destructors called for non pod: " << destructors_called << std::endl;
 193
 194   ck_assert(constructors_called == destructors_called);
 195
 196   {
 197     auto d = efl::eet::make_descriptor
 198       ("pod_value_composited", efl::eet::type("member"
 199                                               , &pod_value_composited::member, pod_descriptor));
 200     static_assert(std::is_same<efl::eet::descriptor<pod_value_composited, pod_type>, decltype(d)>::value, "");
 201
 202     Eet_File* file = eet_open("/tmp/eet_file_test.eet", EET_FILE_MODE_READ_WRITE);
 203     ck_assert(file != 0);
 204
 205     ::pod_value_composited pod_value_composited {{5, 'a'}};
 206
 207     int s = eet_data_write(file, d.native_handle(), "foo", &pod_value_composited, false);
 208     ck_assert(s > 0);
 209     eet_sync(file);
 210     auto p = efl::eet::read_by_ptr(file, "foo", d);
 211     ck_assert(p != 0);
 212     ck_assert(p->member.i == 5);
 213     ck_assert(p->member.c == 'a');
 214
 215     auto v = efl::eet::read(file, "foo", d);
 216     ck_assert(v.member.i == 5);
 217     ck_assert(v.member.c == 'a');
 218
 219     eet_close(file);
 220   }
 221
 222 }
 223 END_TEST
 224
 225 void
 226 eet_test_descriptors(TCase* tc)
 227 {
 228   tcase_add_test(tc, eet_cxx_descriptors);
 229   tcase_add_test(tc, eet_cxx_descriptors_non_pod);
 230   tcase_add_test(tc, eet_cxx_descriptors_composition);
 231 }