test/test_virtual_inheritance.cpp

   1 // Copyright Daniel Wallin 2009. Use, modification and distribution is
   2 // subject to the Boost Software License, Version 1.0. (See accompanying
   3 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   4
   5 #include "test.hpp"
   6 #include <luabind/luabind.hpp>
   7
   8 // Test the following hierarchy:
   9 //
  10 //         X
  11 //        / \.
  12 //       Y   Z
  13 //        \ /
  14 //         U
  15
  16 struct X
  17 {
  18     X(int x)
  19       : value(x)
  20     {}
  21
  22     virtual ~X()
  23     {}
  24
  25     int f() const
  26     {
  27         return value;
  28     }
  29
  30     int value;
  31 };
  32
  33 struct Y : virtual X
  34 {
  35     Y(int value)
  36       : X(value)
  37     {}
  38
  39     int g() const
  40     {
  41         return 2;
  42     }
  43
  44     int dummy;
  45 };
  46
  47 struct Z : virtual X
  48 {
  49     Z(int value)
  50       : X(value)
  51     {}
  52
  53     int h() const
  54     {
  55         return 3;
  56     }
  57
  58     int dummy;
  59 };
  60
  61 struct U : Y, Z
  62 {
  63     U(int value)
  64       : X(value)
  65       , Y(value)
  66       , Z(value)
  67     {}
  68
  69     int dummy;
  70 };
  71
  72 X* upcast(U* p)
  73 {
  74     return p;
  75 }
  76
  77 // This hiearchy tries to prove that conversion and caching works for all sub
  78 // object pointers:
  79 //
  80 //
  81 //      Base  Base
  82 //       |     |
  83 //      Left  Right
  84 //        \   /
  85 //         \ /
  86 //       Derived
  87 //
  88
  89 struct Base
  90 {
  91     Base(int value)
  92       : value(value)
  93     {}
  94
  95     virtual ~Base()
  96     {}
  97
  98     int value;
  99 };
 100
 101 struct Left : Base
 102 {
 103     Left()
 104       : Base(1)
 105     {}
 106
 107     int left() const
 108     {
 109         return value;
 110     }
 111
 112     int dummy;
 113 };
 114
 115 struct Right : Base
 116 {
 117     Right()
 118       : Base(2)
 119     {}
 120
 121     int right() const
 122     {
 123         return value;
 124     }
 125
 126     int dummy;
 127 };
 128
 129 struct Derived : Left, Right
 130 {
 131     int f() const
 132     {
 133         return 3;
 134     }
 135
 136     int dummy;
 137 };
 138
 139 Base* left(Left* p)
 140 {
 141     return p;
 142 }
 143
 144 Base* right(Right* p)
 145 {
 146     return p;
 147 }
 148
 149 void test_main(lua_State* L)
 150 {
 151     using namespace luabind;
 152
 153     module(L) [
 154         class_<X>("X")
 155             .def("f", &X::f),
 156         class_<Y, X>("Y")
 157             .def("g", &Y::g),
 158         class_<Z, X>("Z")
 159             .def("h", &Z::h),
 160         class_<U, bases<Y, Z> >("U")
 161             .def(constructor<int>()),
 162         def("upcast", &upcast)
 163     ];
 164
 165     // Do everything twice to verify that caching works.
 166
 167     DOSTRING(L,
 168         "function assert2(x)\n"
 169         "    assert(x)\n"
 170         "    assert(x)\n"
 171         "end\n"
 172     );
 173
 174     DOSTRING(L,
 175         "x = U(1)\n"
 176         "assert2(x:f() == 1)\n"
 177         "assert2(x:g() == 2)\n"
 178         "assert2(x:h() == 3)\n"
 179     );
 180
 181     DOSTRING(L,
 182         "y = upcast(x)\n"
 183         "assert2(y:f() == 1)\n"
 184         "assert2(y:g() == 2)\n"
 185         "assert2(y:h() == 3)\n"
 186     );
 187
 188     module(L) [
 189         class_<Base>("Base"),
 190         class_<Left, Base>("Left")
 191             .def("left", &Left::left),
 192         class_<Right, Base>("Right")
 193             .def("right", &Right::right),
 194         class_<Derived, bases<Left, Right> >("Derived")
 195             .def(constructor<>())
 196             .def("f", &Derived::f),
 197         def("left", &left),
 198         def("right", &right)
 199     ];
 200
 201     DOSTRING(L,
 202         "x = Derived()\n"
 203         "assert2(x:left() == 1)\n"
 204         "assert2(x:right() == 2)\n"
 205         "assert2(x:f() == 3)\n"
 206     );
 207
 208     DOSTRING(L,
 209         "y = left(x)\n"
 210         "assert2(y:left() == 1)\n"
 211         "assert2(y:right() == 2)\n"
 212         "assert2(y:f() == 3)\n"
 213     );
 214
 215     DOSTRING(L,
 216         "y = right(x)\n"
 217         "assert2(y:left() == 1)\n"
 218         "assert2(y:right() == 2)\n"
 219         "assert2(y:f() == 3)\n"
 220     );
 221 }