test/test_held_type.cpp

   1 #include <boost/shared_ptr.hpp>
   2 #include <boost/weak_ptr.hpp>
   3 #include <memory>
   4
   5 namespace luabind
   6 {
   7         template<class T>
   8         T* get_pointer(boost::shared_ptr<T>& p) { return p.get(); }
   9
  10         template<class T>
  11         T* get_pointer(const std::auto_ptr<T>& p) { return p.get(); }
  12 }
  13
  14 #include "test.h"
  15
  16 namespace
  17 {
  18
  19         LUABIND_ANONYMOUS_FIX int feedback = 0;
  20
  21         struct base
  22         {
  23                 base(): n(4) { feedback = 3; }
  24                 virtual ~base() { feedback = 1; }
  25
  26                 void f(int)
  27                 {
  28                         feedback = n;
  29                 }
  30
  31                 int n;
  32         };
  33
  34         // this is here to make sure the pointer offsetting works
  35         struct first_base
  36         {
  37                 virtual void a() {}
  38                 int padding;
  39         };
  40
  41         struct derived: first_base, base
  42         {
  43                 derived(): n2(7) { feedback = 7; }
  44                 void f() { feedback = 5; }
  45                 int n2;
  46         };
  47
  48         void tester(base* t)
  49         {
  50                 if (t->n == 4) feedback = 2;
  51         }
  52
  53         void tester_(derived* t)
  54         {
  55                 if (t->n2 == 7) feedback = 8;
  56         }
  57
  58         void tester2(boost::shared_ptr<base> t)
  59         {
  60                 if (t->n == 4) feedback = 9;
  61         }
  62
  63         void tester3(boost::shared_ptr<const base> t)
  64         {
  65                 if (t->n == 4) feedback = 10;
  66         }
  67
  68         void tester4(const boost::shared_ptr<const base>& t)
  69         {
  70                 if (t->n == 4) feedback = 11;
  71         }
  72
  73         void tester5(const boost::shared_ptr<const base>* t)
  74         {
  75                 if ((*t)->n == 4) feedback = 12;
  76         }
  77
  78         void tester6(const boost::shared_ptr<base>* t)
  79         {
  80                 if ((*t)->n == 4) feedback = 13;
  81         }
  82
  83         void tester7(boost::shared_ptr<base>* t)
  84         {
  85                 if ((*t)->n == 4) feedback = 14;
  86         }
  87
  88         void tester8(boost::weak_ptr<base> t)
  89         {
  90                 if (!t.expired()) feedback = 19;
  91         }
  92
  93         boost::shared_ptr<base> tester9()
  94         {
  95                 feedback = 20;
  96                 return boost::shared_ptr<base>(new base());
  97         }
  98
  99         struct tester10
 100         {
 101                 tester10() : m_member(new base()) {}
 102                 const boost::shared_ptr<base>& test() { return m_member; }
 103                 boost::shared_ptr<base> m_member;
 104         };
 105
 106         struct ownership {};
 107
 108         void test_auto_ptr(std::auto_ptr<ownership>) {}
 109
 110 } // anonymous namespace
 111
 112
 113 namespace luabind
 114 {
 115         template<class A>
 116         type<boost::shared_ptr<const A> > get_const_holder(type<boost::shared_ptr<A> >)
 117         {
 118                 return type<boost::shared_ptr<const A> >();
 119         }
 120 }
 121
 122 bool test_held_type()
 123 {
 124         // This feature is not finished yet
 125
 126         using namespace luabind;
 127
 128         boost::shared_ptr<base> ptr(new base());
 129
 130         {
 131                 lua_State* L = lua_open();
 132                 lua_baselibopen(L);
 133                 lua_closer c(L);
 134                 int top = lua_gettop(L);
 135
 136                 open(L);
 137
 138                 int (a)[6];
 139
 140                 module(L)
 141                 [
 142                         class_<ownership, std::auto_ptr<ownership> >("ownership")
 143                                 .def(constructor<>()),
 144
 145                         def("test_auto_ptr", &test_auto_ptr),
 146
 147                         def("tester", &tester),
 148                         def("tester", &tester_),
 149                         def("tester2", &tester2),
 150                         def("tester3", &tester3),
 151                         def("tester4", &tester4),
 152                         def("tester5", &tester5),
 153                         def("tester6", &tester6),
 154                         def("tester7", &tester7),
 155 //                      def("tester8", &tester8),
 156                         def("tester9", &tester9),
 157
 158                         class_<base, boost::shared_ptr<base> >("base")
 159                                 .def(constructor<>())
 160                                 .def("f", &base::f),
 161
 162                         class_<derived, base, boost::shared_ptr<base> >("derived")
 163                                 .def(constructor<>())
 164                                 .def("f", &derived::f),
 165
 166                         class_<tester10>("tester10")
 167                                 .def(constructor<>())
 168                                 .def("test", &tester10::test)
 169                 ];
 170
 171                 lua_gettop(L);
 172
 173                 object g = get_globals(L);
 174                 g["test"] = ptr;
 175                 g["foobar"] = boost::shared_ptr<const base>(new base());
 176
 177                 if (dostring(L, "tester(test)")) return false;
 178                 if (feedback != 2) return false;
 179                 if (dostring(L, "a = base()")) return false;
 180                 if (feedback != 3) return false;
 181                 if (dostring(L, "b = derived()")) return false;
 182                 if (feedback != 7) return false;
 183                 if (dostring(L, "tester(a)")) return false;
 184                 if (feedback != 2) return false;
 185                 if (dostring(L, "tester(b)")) return false;
 186                 if (feedback != 8) return false;
 187                 if (dostring(L, "tester2(b)")) return false;
 188                 if (feedback != 9) return false;
 189                 if (dostring(L, "tester3(b)")) return false;
 190                 if (feedback != 10) return false;
 191                 if (dostring(L, "tester4(b)")) return false;
 192                 if (feedback != 11) return false;
 193                 if (dostring(L, "tester5(b)")) return false;
 194                 if (feedback != 12) return false;
 195                 if (dostring(L, "tester6(b)")) return false;
 196                 if (feedback != 13) return false;
 197                 if (dostring(L, "tester7(b)")) return false;
 198                 if (feedback != 14) return false;
 199 //              if (dostring(L, "tester8(b)")) return false;
 200 //              if (feedback != 19) return false;
 201                 if (dostring(L, "c = tester9()")) return false;
 202                 if (feedback != 3) return false;
 203                 feedback= 0;
 204
 205                 if (dostring(L, "d = tester10()")) return false;
 206                 if (dostring(L, "e = d:test()")) return false;
 207                 if (feedback != 3) return false;
 208
 209
 210                 if (top != lua_gettop(L)) return false;
 211
 212         }
 213
 214         ptr.reset();
 215
 216         if (feedback != 1) return false;
 217
 218         return true;
 219 }
 220