test/main.cpp

   1 #include "test.h"
   2
   3 extern "C"
   4 {
   5         #include "lauxlib.h"
   6         #include "lualib.h"
   7         #include "lua.h"
   8 }
   9
  10 #include <iostream>
  11 #include <algorithm>
  12
  13 #include <luabind/luabind.hpp>
  14 #include <luabind/scope.hpp>
  15
  16 bool dostring(lua_State* L, const char* str)
  17 {
  18         if (luaL_loadbuffer(L, str, std::strlen(str), str) || lua_pcall(L, 0, 0, 0))
  19         {
  20                 const char* a = lua_tostring(L, -1);
  21                 std::cout << a << "\n";
  22                 lua_pop(L, 1);
  23                 return true;
  24         }
  25         return false;
  26 }
  27
  28 int dostring2(lua_State* L, const char* str)
  29 {
  30         if (luaL_loadbuffer(L, str, std::strlen(str), str) || lua_pcall(L, 0, 0, 0))
  31         {
  32                 return 1;
  33         }
  34         return 0;
  35 }
  36
  37 bool report_success(bool result, const char* name)
  38 {
  39         std::cout << name;
  40 #ifdef BOOST_MSVC
  41         if (result) std::cout << ": passed\n";
  42         else std::cout << ": failed\n";
  43 #else
  44         if (result) std::cout << ": \033[32mpassed\033[0m\n";
  45         else std::cout << ": \033[31mfailed\033[0m\n";
  46 #endif
  47         return result;
  48 }
  49
  50 #if 0
  51
  52 #include <luabind/runtime_converters.hpp>
  53
  54 namespace
  55 {
  56         using namespace luabind::rt_converter;
  57
  58         struct my_type
  59         {
  60                 my_type()
  61                 { std::cout << "constructed\n"; }
  62
  63                 my_type(const my_type&)
  64                 { std::cout << "copied\n"; }
  65
  66                 ~my_type()
  67                 { std::cout << "destructed\n"; }
  68         };
  69
  70         void int_from_lua(lua_State* L, int index, rvalue_data* data)
  71         {
  72                 data->result = new (data->data) int(lua_tonumber(L, index));
  73         }
  74
  75         void float_from_lua(lua_State* L, int index, rvalue_data* data)
  76         {
  77                 data->result = new (data->data) float(lua_tonumber(L, index));
  78         }
  79
  80         void string_from_lua(lua_State* L, int index, rvalue_data* data)
  81         {
  82                 data->result = new (data->data) std::string(lua_tostring(L, index));
  83         }
  84
  85         void my_type_from_lua(lua_State* L, int index, rvalue_data* data)
  86         {
  87                 data->result = new (data->data) my_type;
  88         }
  89
  90         void f(int a, float b, const std::vector<float>& s)
  91         {
  92                 int c = a + b;
  93         }
  94
  95         template<class Source, class Target>
  96         struct implicit_conversion
  97         {
  98                 typedef typename boost::add_reference<
  99                         typename boost::add_const<Target>::type
 100                 >::type target_t;
 101
 102                 typedef typename boost::add_reference<Source>::type source_t;
 103
 104                 implicit_conversion()
 105                 {
 106                         insert_converter(&convert, typeid(target_t));
 107                 };
 108
 109                 static void convert(lua_State* L, int index, rvalue_data* data)
 110                 {
 111                         typename boost::python::detail::referent_storage<source_t>::type storage;
 112
 113                         rvalue_data tmp;
 114                         tmp.data = storage.bytes;
 115
 116                         rvalue_convert(L, index, &tmp, registered<Source>::converters);
 117
 118                         new (data->data) Target(void_ptr_to_reference(tmp.result, (source_t(*)())0));
 119                         data->result = data->data;
 120
 121                         if (tmp.result == tmp.data)
 122                                 boost::python::detail::destroy_referent(tmp.result, (source_t(*)())0);
 123                 }
 124         };
 125
 126         struct A
 127         { int n; virtual void f() {} };
 128
 129         struct B : A
 130         { float e; virtual void f() {} };
 131
 132         void test_runtime()
 133         {
 134                 lua_State* L = lua_open();
 135
 136                 using namespace luabind;
 137                 open(L);
 138
 139                 insert_converter(&int_from_lua, typeid(const int&));
 140                 insert_converter(&float_from_lua, typeid(const float&));
 141 //              insert_converter(&string_from_lua, typeid(const std::string&));
 142                 insert_converter(&my_type_from_lua, typeid(const my_type&));
 143
 144                 implicit_conversion<int, std::vector<float> >();
 145
 146                 module(L)
 147                 [
 148                         def("f", &f, runtime(_1) + runtime(_2) + runtime(_3))
 149                 ];
 150
 151                 lua_close(L);
 152         }
 153 }
 154
 155 #endif
 156
 157 /*
 158 int main()
 159 {
 160         bool passed = true;
 161
 162 //      test_runtime();
 163
 164         passed &= report_success(test_construction(), "construction");
 165         passed &= report_success(test_attributes(), "attributes");
 166         passed &= report_success(test_operators(), "operators");
 167         passed &= report_success(test_implicit_cast(), "implicit cast");
 168         passed &= report_success(test_const(), "const");
 169 #ifndef LUABIND_NO_EXCEPTIONS
 170         passed &= report_success(test_exceptions(), "exceptions");
 171 #else
 172         std::cout << "exceptions: skipped \n";
 173 #endif
 174         passed &= report_success(test_null_pointer(), "null pointer");
 175         passed &= report_success(test_policies(), "policies");
 176         passed &= report_success(test_lua_classes(), "lua classes");
 177         passed &= report_success(test_free_functions(), "free functions");
 178         passed &= report_success(test_object(), "object");
 179         passed &= report_success(test_held_type(), "held type");
 180         passed &= report_success(test_iterator(), "iterator");
 181         passed &= report_success(test_scope(), "scopes");
 182         passed &= report_success(test_yield(), "yield");
 183
 184         if (passed) std::cout << "\n\nall tests passed\n";
 185         else std::cout << "\n\nsome tests failed\n";
 186
 187         return 0;
 188 }
 189 */