test/test_held_type.cpp

   1 #include <boost/shared_ptr.hpp>
   2 #include <boost/weak_ptr.hpp>
   3 #include <memory>
   4
   5 #include "test.h"
   6
   7 namespace luabind
   8 {
   9         template<class T>
  10         T* get_pointer(boost::shared_ptr<T>& p) { return p.get(); }
  11
  12         template<class A>
  13         boost::shared_ptr<const A>* get_const_holder(boost::shared_ptr<A>*)
  14         {
  15                 return 0;
  16         }
  17 }
  18
  19 namespace
  20 {
  21
  22         LUABIND_ANONYMOUS_FIX int feedback = 0;
  23
  24         struct base
  25         {
  26                 base(): n(4) { feedback = 3; }
  27                 virtual ~base() { feedback = 1; }
  28
  29                 void f(int)
  30                 {
  31                         feedback = n;
  32                 }
  33
  34                 int n;
  35         };
  36
  37         // this is here to make sure the pointer offsetting works
  38         struct first_base
  39         {
  40                 virtual void a() {}
  41                 int padding;
  42         };
  43
  44         struct derived: first_base, base
  45         {
  46                 derived(): n2(7) { feedback = 7; }
  47                 void f() { feedback = 5; }
  48                 int n2;
  49         };
  50
  51         void tester(base* t)
  52         {
  53                 if (t->n == 4) feedback = 2;
  54         }
  55
  56         void tester_(derived* t)
  57         {
  58                 if (t->n2 == 7) feedback = 8;
  59         }
  60
  61         void tester2(boost::shared_ptr<base> t)
  62         {
  63                 if (t->n == 4) feedback = 9;
  64         }
  65
  66         void tester3(boost::shared_ptr<const base> t)
  67         {
  68                 if (t->n == 4) feedback = 10;
  69         }
  70
  71         void tester4(const boost::shared_ptr<const base>& t)
  72         {
  73                 if (t->n == 4) feedback = 11;
  74         }
  75
  76         void tester5(const boost::shared_ptr<const base>* t)
  77         {
  78                 if ((*t)->n == 4) feedback = 12;
  79         }
  80
  81         void tester6(const boost::shared_ptr<base>* t)
  82         {
  83                 if ((*t)->n == 4) feedback = 13;
  84         }
  85
  86         void tester7(boost::shared_ptr<base>* t)
  87         {
  88                 if ((*t)->n == 4) feedback = 14;
  89         }
  90
  91         boost::shared_ptr<base> tester9()
  92         {
  93                 feedback = 20;
  94                 return boost::shared_ptr<base>(new base());
  95         }
  96
  97         struct tester10
  98         {
  99                 tester10() : m_member(new base()) {}
 100                 const boost::shared_ptr<base>& test() { return m_member; }
 101                 boost::shared_ptr<base> m_member;
 102         };
 103
 104         struct base_2 {};
 105
 106         LUABIND_ANONYMOUS_FIX int pointer_cnt = 0;
 107
 108         struct base_holder
 109         {
 110                 static int counter;
 111
 112                 explicit base_holder(base_2* p): ptr(p), secret(2068)
 113                 { ++counter; }
 114
 115                 base_holder(const base_holder&)
 116                         : secret(9999)
 117                 {
 118                         ++counter;
 119                 }
 120
 121                 ~base_holder()
 122                 {
 123                         --counter;
 124                         assert(secret == 2068);
 125                         secret = 0;
 126                 }
 127
 128                 base_2* get() const { return ptr; }
 129
 130                 base_2* ptr;
 131
 132                 int secret;
 133         };
 134
 135         int base_holder::counter = 0;
 136
 137         struct const_base_holder
 138         {
 139                 static int counter;
 140
 141                 explicit const_base_holder(const base_2* p): ptr(p), secret(9999)
 142                 {
 143                         ++counter;
 144                 }
 145
 146                 const_base_holder(const base_holder& x)
 147                         : secret(9999)
 148                 { ++counter; }
 149
 150                 const_base_holder(const const_base_holder&)
 151                         : secret(9999)
 152                 {
 153                         ++counter;
 154                 }
 155
 156                 ~const_base_holder()
 157                 {
 158                         --counter;
 159                         assert(secret == 9999);
 160                         secret = 0;
 161                 }
 162
 163                 const base_2* get() const { return ptr; }
 164
 165                 const base_2* ptr;
 166
 167                 int secret;
 168                 char garbage[16];
 169         };
 170
 171         int const_base_holder::counter = 0;
 172
 173         void tester8(const const_base_holder&)
 174         {
 175                 feedback = 100;
 176         }
 177
 178         void tester15(const_base_holder)
 179         {
 180                 feedback = 101;
 181         }
 182
 183         const_base_holder tester16()
 184         {
 185                 return const_base_holder(0);
 186         }
 187
 188 } // anonymous namespace
 189
 190 namespace luabind
 191 {
 192         base_2* get_pointer(const base_holder& p) { return p.get(); }
 193         const base_2* get_pointer(const const_base_holder& p) { return p.get(); }
 194
 195         const_base_holder* get_const_holder(base_holder*)
 196         {
 197                 return 0;
 198         }
 199 }
 200
 201 bool test_held_type()
 202 {
 203         using namespace luabind;
 204
 205         boost::shared_ptr<base> ptr(new base());
 206
 207         {
 208                 lua_State* L = lua_open();
 209                 lua_baselibopen(L);
 210                 lua_closer c(L);
 211                 int top = lua_gettop(L);
 212
 213                 open(L);
 214
 215                 module(L)
 216                 [
 217                         def("tester", &tester),
 218                         def("tester", &tester_),
 219                         def("tester2", &tester2),
 220                         def("tester3", &tester3),
 221                         def("tester4", &tester4),
 222                         def("tester5", &tester5),
 223                         def("tester6", &tester6),
 224                         def("tester7", &tester7),
 225                         def("tester8", &tester8),
 226                         def("tester9", &tester9),
 227                         def("tester15", &tester15),
 228                         def("tester16", &tester16),
 229
 230                         class_<base, boost::shared_ptr<base> >("base")
 231                                 .def(constructor<>())
 232                                 .def("f", &base::f),
 233
 234                         class_<derived, base, boost::shared_ptr<base> >("derived")
 235                                 .def(constructor<>())
 236                                 .def("f", &derived::f),
 237
 238                         class_<tester10>("tester10")
 239                                 .def(constructor<>())
 240                                 .def("test", &tester10::test),
 241
 242                         class_<base_2, base_holder>("base_")
 243                                 .def(constructor<>())
 244                 ];
 245
 246                 lua_gettop(L);
 247
 248                 object g = get_globals(L);
 249                 g["test"] = ptr;
 250                 g["foobar"] = boost::shared_ptr<const base>(new base());
 251
 252                 if (dostring(L, "tester(test)")) return false;
 253                 if (feedback != 2) return false;
 254                 if (dostring(L, "a = base()")) return false;
 255                 if (feedback != 3) return false;
 256                 if (dostring(L, "b = derived()")) return false;
 257                 if (feedback != 7) return false;
 258                 if (dostring(L, "tester(a)")) return false;
 259                 if (feedback != 2) return false;
 260                 if (dostring(L, "tester(b)")) return false;
 261                 if (feedback != 8) return false;
 262                 if (dostring(L, "tester2(b)")) return false;
 263                 if (feedback != 9) return false;
 264                 if (dostring(L, "tester3(b)")) return false;
 265                 if (feedback != 10) return false;
 266                 if (dostring(L, "tester4(foobar)")) return false;
 267                 if (feedback != 11) return false;
 268                 if (dostring(L, "tester5(foobar)")) return false;
 269                 if (feedback != 12) return false;
 270                 if (dostring(L, "tester6(b)")) return false;
 271                 if (feedback != 13) return false;
 272                 if (dostring(L, "tester7(b)")) return false;
 273                 if (feedback != 14) return false;
 274 //              if (dostring(L, "tester8(b)")) return false;
 275 //              if (feedback != 19) return false;
 276                 if (dostring(L, "c = tester9()")) return false;
 277                 if (feedback != 3) return false;
 278                 feedback= 0;
 279
 280                 if (dostring(L, "d = tester10()")) return false;
 281                 if (dostring(L, "e = d:test()")) return false;
 282                 if (feedback != 3) return false;
 283
 284                 if (dostring(L, "a = base_()")) return false;
 285                 if (dostring(L, "tester8(a)")) return false;
 286                 if (feedback != 100) return false;
 287                 if (dostring(L, "tester15(a)")) return false;
 288                 if (feedback != 101) return false;
 289                 if (dostring(L, "tester8(tester16())")) return false;
 290                 if (feedback != 100) return false;
 291
 292                 if (top != lua_gettop(L)) return false;
 293         }
 294
 295         ptr.reset();
 296
 297         if (feedback != 1) return false;
 298
 299         if (base_holder::counter != 0) return false;
 300         if (const_base_holder::counter != 0) return false;
 301
 302         return true;
 303 }