test/test_lua_classes.cpp

   1 // Copyright (c) 2004 Daniel Wallin and Arvid Norberg
   2
   3 // Permission is hereby granted, free of charge, to any person obtaining a
   4 // copy of this software and associated documentation files (the "Software"),
   5 // to deal in the Software without restriction, including without limitation
   6 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   7 // and/or sell copies of the Software, and to permit persons to whom the
   8 // Software is furnished to do so, subject to the following conditions:
   9
  10 // The above copyright notice and this permission notice shall be included
  11 // in all copies or substantial portions of the Software.
  12
  13 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
  14 // ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  15 // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  16 // PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
  17 // SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
  18 // ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  19 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
  21 // OR OTHER DEALINGS IN THE SOFTWARE.
  22
  23 #include "test.hpp"
  24 #include <luabind/luabind.hpp>
  25
  26 using namespace luabind;
  27
  28 namespace {
  29
  30 struct base : counted_type<base>
  31 {
  32     virtual ~base() {}
  33
  34     virtual std::string f()
  35     {
  36         return "base:f()";
  37     }
  38 };
  39
  40 struct base_wrap : base
  41 {
  42     weak_ref self;
  43     base_wrap(weak_ref self_): self(self_) {}
  44
  45     static std::string f_static(base* obj)
  46     {
  47         return obj->base::f();
  48     }
  49
  50     virtual std::string f()
  51     {
  52         return call_member<std::string>(self, "f");
  53     }
  54 };
  55
  56 struct simple_class : counted_type<simple_class>
  57 {
  58     static int feedback;
  59
  60     void f()
  61     {
  62         feedback = 1;
  63     }
  64
  65     void f(int, int) {}
  66     void f(std::string a)
  67     {
  68         const char str[] = "foo\0bar";
  69         if (a == std::string(str, sizeof(str)-1))
  70             feedback = 2;
  71     }
  72
  73     std::string g()
  74     {
  75         const char str[] = "foo\0bar";
  76         return std::string(str, sizeof(str)-1);
  77     }
  78 };
  79
  80 int simple_class::feedback = 0;
  81
  82 } // namespace unnamed
  83
  84 #include <iostream>
  85
  86 void test_lua_classes()
  87 {
  88     COUNTER_GUARD(base);
  89         COUNTER_GUARD(simple_class);
  90
  91         lua_state L;
  92
  93     module(L)
  94     [
  95         class_<base, base_wrap>("base")
  96             .def(constructor<>())
  97             .def("f", &base_wrap::f_static)
  98     ];
  99
 100         DOSTRING(L,
 101                 "function base:fun()\n"
 102                 "  test = 4\n"
 103                 "end\n"
 104                 "a = base()\n"
 105                 "a:fun()\n"
 106                 "assert(test == 4)\n");
 107
 108     DOSTRING(L,
 109         "class 'derived' (base)\n"
 110         "  function derived:__init() super() end\n"
 111         "  function derived:f()\n"
 112         "    return 'derived:f() : ' .. base.f(self)\n"
 113         "  end\n"
 114
 115         "function make_derived()\n"
 116         "  return derived()\n"
 117         "end\n");
 118
 119     base* ptr;
 120
 121     BOOST_CHECK_NO_THROW(
 122         ptr = call_function<base*>(L, "make_derived")
 123     );
 124
 125     BOOST_CHECK_NO_THROW(
 126         ptr = call_function<base*>(L, "derived")
 127     );
 128
 129     BOOST_CHECK_NO_THROW(
 130         BOOST_CHECK(ptr->f() == "derived:f() : base:f()")
 131     );
 132
 133         typedef void(simple_class::*f_overload1)();
 134         typedef void(simple_class::*f_overload2)(int, int);
 135         typedef void(simple_class::*f_overload3)(std::string);
 136
 137     module(L)
 138     [
 139         class_<simple_class>("simple")
 140             .def(constructor<>())
 141                         .def("f", (f_overload1)&simple_class::f)
 142                         .def("f", (f_overload2)&simple_class::f)
 143                         .def("f", (f_overload3)&simple_class::f)
 144                         .def("g", &simple_class::g)
 145     ];
 146
 147     DOSTRING(L,
 148         "class 'simple_derived' (simple)\n"
 149         "  function simple_derived:__init() super() end\n"
 150         "a = simple_derived()\n"
 151         "a:f()\n");
 152     BOOST_CHECK(simple_class::feedback == 1);
 153
 154     DOSTRING(L, "a:f('foo\\0bar')");
 155     BOOST_CHECK(simple_class::feedback == 2);
 156
 157     simple_class::feedback = 0;
 158
 159     DOSTRING_EXPECTED(L, "a:f('incorrect', 'parameters')",
 160         "no overload of  'simple:f' matched the arguments "
 161         "(string, string)\ncandidates are:\n"
 162         "simple:f()\nsimple:f(number, number)\nsimple:f(string)\n");
 163
 164     DOSTRING(L, "if a:g() == \"foo\\0bar\" then a:f() end");
 165     BOOST_CHECK(simple_class::feedback == 1);
 166 }
 167