test/test_operators.cpp

   1 #include "test.h"
   2 #include <iostream>
   3
   4 extern "C"
   5 {
   6         #include "lualib.h"
   7 }
   8
   9
  10 namespace
  11 {
  12         LUABIND_ANONYMOUS_FIX int feedback = 0;
  13
  14         struct operator_tester
  15         {
  16                 int operator+(int) const
  17                 {
  18                         feedback = 1;
  19                         return 4;
  20                 }
  21
  22                 float operator-() const
  23                 {
  24                         feedback = 2;
  25                         return 4.6f;
  26                 }
  27
  28                 float operator()() const
  29                 {
  30                         feedback = 3;
  31                         return 3.5f;
  32                 }
  33
  34                 float operator()(int a) const
  35                 {
  36                         feedback = 4;
  37                         return 3.5f + a;;
  38                 }
  39
  40                 float operator()(int a)
  41                 {
  42                         feedback = 7;
  43                         return 3.5f + a;;
  44                 }
  45
  46         };
  47
  48         int operator+(int, const operator_tester&)
  49         {
  50                 feedback = 5;
  51                 return 2;
  52         }
  53
  54         struct operator_tester2
  55         {
  56         };
  57
  58         float operator+(const operator_tester&, const operator_tester2&)
  59         {
  60                 feedback = 6;
  61                 return 6.3f;
  62         }
  63
  64         struct operator_tester3: public operator_tester {};
  65
  66         const operator_tester* make_const_test()
  67         {
  68                 static operator_tester o;
  69                 return &o;
  70         }
  71
  72         std::ostream& operator<<(std::ostream& os, const operator_tester&)
  73         {
  74                 os << "operator_tester"; feedback = 63; return os;
  75         }
  76
  77         operator_tester* clone(const operator_tester* p) { return new operator_tester(*p); }
  78
  79 } // anonymous namespace
  80
  81 bool test_operators()
  82 {
  83         using namespace luabind;
  84
  85         lua_State* L = lua_open();
  86         lua_closer c(L);
  87         lua_baselibopen(L);
  88
  89         int top = lua_gettop(L);
  90
  91         open(L);
  92
  93         if (feedback != 0) return false;
  94
  95         module(L)
  96         [
  97                 class_<operator_tester>("operator_tester")
  98                         .def(constructor<>())
  99                         .def(tostring(const_self))
 100                         .def(self + int())
 101                         .def(other<int>() + self)
 102                         .def(-self)
 103                         .def(self())
 104                         .def(const_self(int()))
 105                         .def(self(int())),
 106 //                      .def("clone", &clone, adopt(return_value)),
 107
 108                 class_<operator_tester2>("operator_tester2")
 109                         .def(constructor<>())
 110                         .def(other<const operator_tester&>() + self),
 111
 112                 class_<operator_tester3, bases<operator_tester> >("operator_tester3")
 113                         .def(constructor<>()),
 114
 115                 def("make_const_test", &make_const_test)
 116         ];
 117
 118         if (feedback != 0) return false;
 119
 120         if (dostring(L, "test = operator_tester()")) return false;
 121         if (dostring(L, "test2 = operator_tester2()")) return false;
 122         if (dostring(L, "test3 = operator_tester3()")) return false;
 123
 124         if (dostring(L, "test()")) return false;
 125         if (feedback != 3) return false;
 126         if (dostring(L, "test(5)")) return false;
 127         if (feedback != 7) return false;
 128
 129         dostring(L, "const_test = make_const_test()");
 130         if (dostring(L, "const_test(5)")) return false;
 131         if (feedback != 4) return false;
 132
 133         if (dostring(L, "a = -test")) return false;
 134         if (feedback != 2) return false;
 135
 136         if (dostring(L, "a = test + test2")) return false;
 137         if (feedback != 6) return false;
 138
 139         if (dostring(L, "a = 2 + test")) return false;
 140         if (feedback != 5) return false;
 141
 142         if (dostring(L, "a = test + 2")) return false;
 143         if (feedback != 1) return false;
 144
 145         if (dostring(L, "a = test3 + 6")) return false;
 146         if (feedback != 1) return false;
 147
 148         if (dostring(L, "a = test3 + test2")) return false;
 149         if (feedback != 6) return false;
 150
 151         if (dostring(L, "a = tostring(test)")) return false;
 152         if (feedback != 63) return false;
 153
 154 //      if (dostring(L, "t = test:clone()")) return false;
 155
 156         const char* prog =
 157                 "class 'my_class'\n"
 158                 "function my_class:__add(lhs)\n"
 159                 "       return my_class(self.val + lhs.val)\n"
 160                 "end\n"
 161                 "function my_class:__init(a)\n"
 162                 "       self.val = a\n"
 163                 "end\n"
 164                 "function my_class:__sub(v)\n"
 165                 "       if (type(self) == 'number') then\n"
 166                 "               return my_class(self - v.val)\n"
 167                 "       elseif (type(v) == 'number') then\n"
 168                 "               return my_class(self.val - v)\n"
 169                 "       else\n"
 170                 "               return my_class(self.val - v.val)\n"
 171                 "       end\n"
 172                 "end\n"
 173                 "a = my_class(3)\n"
 174                 "b = my_class(7)\n"
 175                 "c = a + b\n"
 176                 "d = a - 2\n"
 177                 "d = 10 - d\n"
 178                 "d = d - b\n";
 179
 180         if (dostring(L, prog)) return false;
 181         object var_c = get_globals(L)["c"];
 182         if (object_cast<int>(var_c["val"]) != 10) return false;
 183
 184         object var_d = get_globals(L)["d"];
 185         if (object_cast<int>(var_d["val"]) != 2) return false;
 186
 187         if (top != lua_gettop(L)) return false;
 188
 189         return true;
 190 }