test/test_object.cpp

   1 #include "test.h"
   2 #include <iostream>
   3 #include <string>
   4
   5 extern "C"
   6 {
   7         #include "lauxlib.h"
   8 }
   9
  10 namespace
  11 {
  12         using namespace luabind;
  13         LUABIND_ANONYMOUS_FIX int feedback1 = 0;
  14         LUABIND_ANONYMOUS_FIX int feedback2 = 0;
  15         LUABIND_ANONYMOUS_FIX int feedback3 = 0;
  16         LUABIND_ANONYMOUS_FIX int feedback4 = 0;
  17         LUABIND_ANONYMOUS_FIX int feedback5 = 0;
  18
  19         void test_object_param(const object& table)
  20         {
  21                 object current_object;
  22                 current_object = table;
  23
  24                 if (table.type() == LUA_TTABLE)
  25                 {
  26                         feedback1 = 1;
  27
  28                         feedback2 = object_cast<int>(table["oh"]);
  29
  30                         feedback3 = 0;
  31                         for (object::array_iterator i = table.abegin(); i != table.aend(); ++i)
  32                         {
  33                                 feedback3 += object_cast<int>(*i);
  34                         }
  35
  36                         feedback4 = 0;
  37                         for (object::iterator j = table.begin(); j != table.end(); ++j)
  38                         {
  39                                 feedback4 += object_cast<int>(*j);
  40                         }
  41
  42                         feedback5 = 0;
  43                         for (object::raw_iterator j = table.raw_begin(); j != table.raw_end(); ++j)
  44                         {
  45                                 feedback5 += object_cast<int>(*j);
  46                         }
  47
  48                         table["blurp"] = 5;
  49
  50                 }
  51                 else
  52                 {
  53                         feedback1 = 2;
  54
  55                         if (table.type() != LUA_TNIL)
  56                         {
  57                                 feedback2 = 1;
  58                         }
  59                         else
  60                         {
  61                                 feedback2 = 2;
  62                         }
  63                 }
  64         }
  65
  66         int test_fun()
  67         {
  68                 feedback1 = 3;
  69                 return 42;
  70         }
  71
  72         struct test_param
  73         {
  74                 virtual ~test_param() { feedback1 = 30; }
  75                 virtual void foo()
  76                 {
  77                         feedback1 = 1;
  78                 }
  79         };
  80
  81         struct test_param2 : public test_param
  82         {
  83                 virtual ~test_param2() { feedback1 = 20; }
  84                 virtual void foo()
  85                 {
  86                         feedback1 = 2;
  87                 }
  88                 virtual void foo( bool b )
  89                 {
  90                         feedback2 = 2;
  91                 }
  92         };
  93
  94         void test_match(const luabind::object& o)
  95         {
  96                 feedback1 = 28;
  97         }
  98
  99         void test_match(int i)
 100         {
 101                 feedback1 = 27;
 102         }
 103
 104 /*******************************************/
 105 // Evan's diabolical test case
 106         class Message {};
 107
 108         class IMessageClient
 109         {
 110         public:
 111                 virtual bool    OnMessage( Message* pMessage )          = 0;
 112         };
 113
 114         class IState
 115         {
 116         public:
 117                 virtual bool                    OnMessage( Message* pMessage )          = 0;
 118                 virtual const char *    getName()                                                       = 0;
 119         };
 120         class StateImpl : public IState
 121         {
 122         public:
 123                 virtual bool                    OnMessage( Message* pMessage )          { return false; }
 124                 virtual const char *    getName()                                                       { return NULL; }
 125         };
 126         class FSM
 127                 : public IMessageClient, public StateImpl
 128         {
 129         protected:
 130                 IState* m_pCurrentState;
 131                 IState* m_pNewState;
 132                 IState* m_pGlobalState;
 133                 IState* m_pPreviousState;
 134                 bool    m_bForceStateTransition;
 135         public:
 136                 FSM() {}
 137                 virtual ~FSM() {}
 138                 IState * getCurrentState()                                                      { return m_pCurrentState; }
 139                 IState * getNewState()                                                          { return m_pNewState; }
 140                 IState * getPreviousState()                                                     { return m_pPreviousState; }
 141                 IState * getGlobalState()                                                       { return m_pGlobalState; }
 142
 143                 virtual const char * getName()                                          { return NULL; }
 144                 virtual void    Update( float fDeltaTime )                      {}
 145
 146                 virtual bool    OnMessage( Message* pMessage )          { return true; }
 147
 148                 virtual void addState( IState * state )                         {}
 149                 virtual void addState( IState * state, const std::string & stateName ) {}
 150         };
 151
 152
 153         class ActorBrain  : public IMessageClient
 154         {
 155         public:
 156                 ActorBrain()                    {}
 157                 virtual ~ActorBrain()   {}
 158                 virtual void setActorParent(void* pParent)                      { m_p= pParent; }
 159                 void*   getParentActor()                                                        { return m_p; }
 160                 virtual void Update(float fDeltaTime) = 0;
 161         protected:
 162                 void* m_p;
 163         };
 164         class AgentBrain
 165                 : public ActorBrain, public FSM
 166         {
 167         public:
 168                 AgentBrain()    {}
 169                 virtual bool OnMessage(Message * pMessage ) { return true; }
 170                 virtual void    Update( float fDeltaTime )      {}
 171         };
 172
 173 } // anonymous namespace
 174
 175
 176
 177 bool test_object()
 178 {
 179         using namespace luabind;
 180
 181         lua_State* L = lua_open();
 182         luaopen_base( L );
 183
 184         int top = lua_gettop(L);
 185         {
 186                 open(L);
 187
 188                 module(L)
 189                 [
 190                         def("test_object_param", &test_object_param),
 191                         def("test_fun", &test_fun),
 192                         def("test_match", (void(*)(const luabind::object&))&test_match),
 193                         def("test_match", (void(*)(int))&test_match),
 194
 195                         class_<test_param>("test_param")
 196                                 .def(constructor<>())
 197                                 .def("foo",&test_param::foo ),
 198                         class_<test_param2, test_param>("test_param2")
 199                                 .def(constructor<>())
 200                                 .def("foo",(void(test_param2::*)(bool))&test_param2::foo ),
 201
 202                         // Evan's diabolical test
 203                         class_<IMessageClient>( "IMessageClient" )
 204                                 .def( "onMessage",                      &IMessageClient::OnMessage )
 205                         ,
 206                         class_<IState>( "State" )
 207                         ,
 208
 209                         class_<FSM, IState>( "FSM" )
 210                                 .def( constructor<>() )
 211                                 .def( "addState", (void(FSM::*)(IState*))&FSM::addState )//, adopt(_1) )
 212                                 .def( "addState", (void(FSM::*)(IState*,const std::string &))&FSM::addState )//, adopt(_1) )
 213                         ,
 214                         class_<ActorBrain>( "ActorBrain" )
 215                         ,
 216                         class_<AgentBrain, bases<ActorBrain, FSM> >( "AgentBrain" )
 217                                 .def( constructor<>() )
 218                 ];
 219
 220                 // Evan's diabolical test
 221                 int nResult = lua_dofile( L, "ew_test.lua" );
 222
 223                 dostring(L, "t = test_param();");
 224                 dostring(L, "t:foo();");
 225                 if (feedback1 != 1) return false;
 226
 227                 dostring(L, "t = test_param2();");
 228                 dostring(L, "t:foo();");
 229                 dostring(L, "t:foo(true);");
 230                 if (feedback1 != 2) return false;
 231                 if (feedback2 != 2) return false;
 232
 233                 dostring(L, "t = 2");
 234                 dostring(L, "test_object_param(t)");
 235                 if (feedback1 != 2) return false;
 236                 if (feedback2 != 1) return false;
 237
 238                 dostring(L, "test_object_param(nil)");
 239                 if (feedback1 != 2) return false;
 240                 if (feedback2 != 2) return false;
 241
 242                 dostring(L, "t = { ['oh'] = 4, 3, 5, 7, 13 }");
 243                 dostring(L, "test_object_param(t)");
 244                 if (feedback1 != 1) return false;
 245                 if (feedback2 != 4) return false;
 246                 if (feedback3 != 28) return false;
 247                 if (feedback4 != 32) return false;
 248                 if (feedback5 != 32) return false;
 249
 250                 object g = get_globals(L);
 251
 252                 object t = g["t"];
 253                 if (t.type() != LUA_TTABLE) return false;
 254
 255                 object blurp = t["blurp"];
 256                 if (object_cast<int>(blurp) != 5) return false;
 257
 258                 object fun = g["test_fun"];
 259                 object ret = fun();
 260                 if (object_cast<int>(ret) != 42) return false;
 261                 if (feedback1 != 3) return false;
 262
 263                 dostring(L, "function test_param_policies(x, y) end");
 264                 object test_param_policies = g["test_param_policies"];
 265                 int a = test_param_policies.type();
 266                 if (a != LUA_TFUNCTION) return false;
 267                 // call the function and tell lua to adopt the pointer passed as first argument
 268                 test_param_policies(5, new test_param())[adopt(_2)];
 269
 270                 dostring(L, "test_match(7)");
 271                 if (feedback1 != 27) return false;
 272                 dostring(L, "test_match('oo')");
 273                 if (feedback1 != 28) return false;
 274
 275                 dostring(L, "function test_object_policies(a) glob = a\nreturn 6\nend");
 276                 object test_object_policies = g["test_object_policies"];
 277                 object ret_val = test_object_policies("teststring")[detail::null_type()];
 278                 if (object_cast<int>(ret_val) != 6) return false;
 279                 if (object_cast<std::string>(g["glob"]) != "teststring") return false;
 280                 if (object_cast<std::string>(g.at("glob")) != "teststring") return false;
 281                 if (object_cast<std::string>(g.raw_at("glob")) != "teststring") return false;
 282         }
 283
 284         if (top != lua_gettop(L)) return false;
 285
 286         lua_close(L);
 287
 288         // make sure lua adopted the pointer by checking that it has been deleted
 289         if (feedback1 != 30) return false;
 290
 291         return true;
 292 }