simgear/nasal/cppbind/cppbind_test.cxx

   1 #include <simgear/math/SGMath.hxx>
   2
   3 #include "Ghost.hxx"
   4 #include "NasalHash.hxx"
   5 #include "NasalString.hxx"
   6
   7 #include <boost/shared_ptr.hpp>
   8 #include <boost/weak_ptr.hpp>
   9
  10 #include <cstring>
  11 #include <iostream>
  12
  13 #define VERIFY(a) \
  14   if( !(a) ) \
  15   { \
  16     std::cerr << "failed: line " << __LINE__ << ": " << #a << std::endl; \
  17     return 1; \
  18   }
  19
  20 enum MyEnum
  21 {
  22   ENUM_FIRST,
  23   ENUM_ANOTHER,
  24   ENUM_LAST
  25 };
  26 struct Base
  27 {
  28   naRef member(const nasal::CallContext&) { return naNil(); }
  29   virtual ~Base(){};
  30
  31   std::string getString() const { return ""; }
  32   void setString(const std::string&) {}
  33   void constVoidFunc() const {}
  34   size_t test1Arg(const std::string& str) const { return str.length(); }
  35   bool test2Args(const std::string& s, bool c) { return c && s.empty(); }
  36
  37   std::string var;
  38   const std::string& getVar() const { return var; }
  39   void setVar(const std::string v) { var = v; }
  40 };
  41
  42 void baseVoidFunc(Base& b) {}
  43 void baseConstVoidFunc(const Base& b) {}
  44 size_t baseFunc2Args(Base& b, int x, const std::string& s) { return x + s.size(); }
  45 std::string testPtr(Base& b) { return b.getString(); }
  46 void baseFuncCallContext(const Base&, const nasal::CallContext&) {}
  47
  48 struct Derived:
  49   public Base
  50 {
  51   int _x;
  52   int getX() const { return _x; }
  53   void setX(int x) { _x = x; }
  54 };
  55 struct DoubleDerived:
  56   public Derived
  57 {
  58
  59 };
  60
  61 typedef boost::shared_ptr<Base> BasePtr;
  62 typedef std::vector<BasePtr> BaseVec;
  63
  64 struct DoubleDerived2:
  65   public Derived
  66 {
  67   const BasePtr& getBase() const{return _base;}
  68   BasePtr _base;
  69   BaseVec doSomeBaseWork(const BaseVec& v) { return v; }
  70 };
  71
  72 class SGReferenceBasedClass:
  73   public SGReferenced
  74 {
  75
  76 };
  77
  78 typedef boost::shared_ptr<Derived> DerivedPtr;
  79 typedef boost::shared_ptr<DoubleDerived> DoubleDerivedPtr;
  80 typedef boost::shared_ptr<DoubleDerived2> DoubleDerived2Ptr;
  81 typedef SGSharedPtr<SGReferenceBasedClass> SGRefBasedPtr;
  82
  83 typedef boost::weak_ptr<Derived> DerivedWeakPtr;
  84
  85 naRef derivedFreeMember(Derived&, const nasal::CallContext&) { return naNil(); }
  86 naRef f_derivedGetX(naContext c, const Derived& d)
  87 {
  88   return nasal::to_nasal(c, d.getX());
  89 }
  90 naRef f_freeFunction(nasal::CallContext c) { return c.requireArg<naRef>(0); }
  91
  92 int main(int argc, char* argv[])
  93 {
  94   naContext c = naNewContext();
  95   naRef r;
  96
  97   using namespace nasal;
  98
  99   r = to_nasal(c, ENUM_ANOTHER);
 100   VERIFY( from_nasal<int>(c, r) == ENUM_ANOTHER );
 101
 102   r = to_nasal(c, "Test");
 103   VERIFY( strncmp("Test", naStr_data(r), naStr_len(r)) == 0 );
 104   VERIFY( from_nasal<std::string>(c, r) == "Test" );
 105
 106   r = to_nasal(c, std::string("Test"));
 107   VERIFY( strncmp("Test", naStr_data(r), naStr_len(r)) == 0 );
 108   VERIFY( from_nasal<std::string>(c, r) == "Test" );
 109
 110   r = to_nasal(c, 42);
 111   VERIFY( naNumValue(r).num == 42 );
 112   VERIFY( from_nasal<int>(c, r) == 42 );
 113
 114   r = to_nasal(c, 4.2f);
 115   VERIFY( naNumValue(r).num == 4.2f );
 116   VERIFY( from_nasal<float>(c, r) == 4.2f );
 117
 118   float test_data[3] = {0, 4, 2};
 119   r = to_nasal(c, test_data);
 120
 121   SGVec2f vec(0,2);
 122   r = to_nasal(c, vec);
 123   VERIFY( from_nasal<SGVec2f>(c, r) == vec );
 124
 125   std::vector<int> std_vec;
 126   r = to_nasal(c, std_vec);
 127
 128   r = to_nasal(c, "string");
 129   try
 130   {
 131     from_nasal<int>(c, r);
 132
 133     std::cerr << "failed: Expected bad_nasal_cast to be thrown" << std::endl;
 134     return 1;
 135   }
 136   catch(nasal::bad_nasal_cast&)
 137   {}
 138
 139   Hash hash(c);
 140   hash.set("vec", r);
 141   hash.set("vec2", vec);
 142   hash.set("name", "my-name");
 143   hash.set("string", std::string("blub"));
 144   hash.set("func", &f_freeFunction);
 145
 146   r = to_nasal(c, hash);
 147   VERIFY( naIsHash(r) );
 148
 149   VERIFY( hash.get<std::string>("name") == "my-name" );
 150   VERIFY( naIsString(hash.get("name")) );
 151
 152   Hash mod = hash.createHash("mod");
 153   mod.set("parent", hash);
 154
 155
 156   // 'func' is a C++ function registered to Nasal and now converted back to C++
 157   boost::function<int (int)> f = hash.get<int (int)>("func");
 158   VERIFY( f );
 159   VERIFY( f(3) == 3 );
 160
 161   boost::function<std::string (int)> fs = hash.get<std::string (int)>("func");
 162   VERIFY( fs );
 163   VERIFY( fs(14) == "14" );
 164
 165   typedef boost::function<void (int)> FuncVoidInt;
 166   FuncVoidInt fvi = hash.get<FuncVoidInt>("func");
 167   VERIFY( fvi );
 168   fvi(123);
 169
 170   typedef boost::function<std::string (const std::string&, int, float)> FuncMultiArg;
 171   FuncMultiArg fma = hash.get<FuncMultiArg>("func");
 172   VERIFY( fma );
 173   VERIFY( fma("test", 3, .5) == "test" );
 174
 175   //----------------------------------------------------------------------------
 176   // Test exposing classes to Nasal
 177   //----------------------------------------------------------------------------
 178
 179   Ghost<BasePtr>::init("BasePtr")
 180     .method("member", &Base::member)
 181     .method("strlen", &Base::test1Arg)
 182     .member("str", &Base::getString, &Base::setString)
 183     .method("str_m", &Base::getString)
 184     .method("void", &Base::constVoidFunc)
 185     .member("var_r", &Base::getVar)
 186     .member("var_w", &Base::setVar)
 187     .member("var", &Base::getVar, &Base::setVar)
 188     .method("void", &baseVoidFunc)
 189     .method("void_c", &baseConstVoidFunc)
 190     .method("int2args", &baseFunc2Args)
 191     .method("bool2args", &Base::test2Args)
 192     .method("str_ptr", &testPtr);
 193   Ghost<DerivedPtr>::init("DerivedPtr")
 194     .bases<BasePtr>()
 195     .member("x", &Derived::getX, &Derived::setX)
 196     .member("x_alternate", &f_derivedGetX)
 197     .method("free_fn", &derivedFreeMember)
 198     .method("free_member", &derivedFreeMember)
 199     .method("baseDoIt", &baseFuncCallContext);
 200   Ghost<DoubleDerivedPtr>::init("DoubleDerivedPtr")
 201     .bases<DerivedPtr>();
 202   Ghost<DoubleDerived2Ptr>::init("DoubleDerived2Ptr")
 203     .bases< Ghost<DerivedPtr> >()
 204     .member("base", &DoubleDerived2::getBase)
 205     .method("doIt", &DoubleDerived2::doSomeBaseWork);
 206
 207   Ghost<DerivedWeakPtr>::init("DerivedWeakPtr");
 208   Ghost<SGRefBasedPtr>::init("SGRefBasedPtr");
 209
 210   VERIFY( Ghost<BasePtr>::isInit() );
 211   nasal::to_nasal(c, DoubleDerived2Ptr());
 212
 213   BasePtr d( new Derived );
 214   naRef derived = to_nasal(c, d);
 215   VERIFY( naIsGhost(derived) );
 216   VERIFY( std::string("DerivedPtr") == naGhost_type(derived)->name );
 217
 218   BasePtr d2( new DoubleDerived );
 219   derived = to_nasal(c, d2);
 220   VERIFY( naIsGhost(derived) );
 221   VERIFY( std::string("DoubleDerivedPtr") ==  naGhost_type(derived)->name );
 222
 223   BasePtr d3( new DoubleDerived2 );
 224   derived = to_nasal(c, d3);
 225   VERIFY( naIsGhost(derived) );
 226   VERIFY( std::string("DoubleDerived2Ptr") ==  naGhost_type(derived)->name );
 227
 228   SGRefBasedPtr ref_based( new SGReferenceBasedClass );
 229   naRef na_ref_based = to_nasal(c, ref_based.get());
 230   VERIFY( naIsGhost(na_ref_based) );
 231   VERIFY(    from_nasal<SGReferenceBasedClass*>(c, na_ref_based)
 232           == ref_based.get() );
 233   VERIFY( from_nasal<SGRefBasedPtr>(c, na_ref_based) == ref_based );
 234
 235   VERIFY( Ghost<BasePtr>::isBaseOf(derived) );
 236   VERIFY( Ghost<DerivedPtr>::isBaseOf(derived) );
 237   VERIFY( Ghost<DoubleDerived2Ptr>::isBaseOf(derived) );
 238
 239   VERIFY( from_nasal<BasePtr>(c, derived) == d3 );
 240   VERIFY( from_nasal<BasePtr>(c, derived) != d2 );
 241   VERIFY(    from_nasal<DerivedPtr>(c, derived)
 242           == boost::dynamic_pointer_cast<Derived>(d3) );
 243   VERIFY(    from_nasal<DoubleDerived2Ptr>(c, derived)
 244           == boost::dynamic_pointer_cast<DoubleDerived2>(d3) );
 245   VERIFY( !from_nasal<DoubleDerivedPtr>(c, derived) );
 246
 247   std::map<std::string, BasePtr> instances;
 248   VERIFY( naIsHash(to_nasal(c, instances)) );
 249
 250   std::map<std::string, DerivedPtr> instances_d;
 251   VERIFY( naIsHash(to_nasal(c, instances_d)) );
 252
 253   std::map<std::string, int> int_map;
 254   VERIFY( naIsHash(to_nasal(c, int_map)) );
 255
 256   std::map<std::string, std::vector<int> > int_vector_map;
 257   VERIFY( naIsHash(to_nasal(c, int_vector_map)) );
 258
 259   // Check converting to Ghost if using Nasal hashes with actual ghost inside
 260   // the hashes parents vector
 261   std::vector<naRef> parents;
 262   parents.push_back(hash.get_naRef());
 263   parents.push_back(derived);
 264
 265   Hash obj(c);
 266   obj.set("parents", parents);
 267   VERIFY( from_nasal<BasePtr>(c, obj.get_naRef()) == d3 );
 268
 269   // Check recursive parents (aka parent-of-parent)
 270   std::vector<naRef> parents2;
 271   parents2.push_back(obj.get_naRef());
 272   Hash derived_obj(c);
 273   derived_obj.set("parents", parents2);
 274   VERIFY( from_nasal<BasePtr>(c, derived_obj.get_naRef()) == d3 );
 275
 276   std::vector<naRef> nasal_objects;
 277   nasal_objects.push_back( Ghost<BasePtr>::create(c, d) );
 278   nasal_objects.push_back( Ghost<BasePtr>::create(c, d2) );
 279   nasal_objects.push_back( Ghost<BasePtr>::create(c, d3) );
 280   naRef obj_vec = to_nasal(c, nasal_objects);
 281
 282   std::vector<BasePtr> objects = from_nasal<std::vector<BasePtr> >(c, obj_vec);
 283   VERIFY( objects[0] == d );
 284   VERIFY( objects[1] == d2 );
 285   VERIFY( objects[2] == d3 );
 286
 287   // TODO actually do something with the ghosts...
 288
 289   //----------------------------------------------------------------------------
 290   // Test nasal::CallContext
 291   //----------------------------------------------------------------------------
 292
 293
 294   int int_vec[] = {1,2,3};
 295   std::map<std::string, std::string> map;
 296   naRef args[] = {
 297     to_nasal(c, std::string("test-arg")),
 298     to_nasal(c, 4),
 299     to_nasal(c, int_vec),
 300     to_nasal(c, map)
 301   };
 302   CallContext cc(c, sizeof(args)/sizeof(args[0]), args);
 303   VERIFY( cc.requireArg<std::string>(0) == "test-arg" );
 304   VERIFY( cc.getArg<std::string>(0) == "test-arg" );
 305   VERIFY( cc.getArg<std::string>(10) == "" );
 306   VERIFY( cc.isString(0) );
 307   VERIFY( !cc.isNumeric(0) );
 308   VERIFY( !cc.isVector(0) );
 309   VERIFY( !cc.isHash(0) );
 310   VERIFY( !cc.isGhost(0) );
 311   VERIFY( cc.isNumeric(1) );
 312   VERIFY( cc.isVector(2) );
 313   VERIFY( cc.isHash(3) );
 314
 315   naRef args_vec = nasal::to_nasal(c, args);
 316   VERIFY( naIsVector(args_vec) );
 317
 318   //----------------------------------------------------------------------------
 319   // Test nasal::String
 320   //----------------------------------------------------------------------------
 321
 322   String string( to_nasal(c, "Test") );
 323   VERIFY( from_nasal<std::string>(c, string.get_naRef()) == "Test" );
 324   VERIFY( string.c_str() == std::string("Test") );
 325   VERIFY( string.starts_with(string) );
 326   VERIFY( string.starts_with(String(c, "T")) );
 327   VERIFY( string.starts_with(String(c, "Te")) );
 328   VERIFY( string.starts_with(String(c, "Tes")) );
 329   VERIFY( string.starts_with(String(c, "Test")) );
 330   VERIFY( !string.starts_with(String(c, "Test1")) );
 331   VERIFY( !string.starts_with(String(c, "bb")) );
 332   VERIFY( !string.starts_with(String(c, "bbasdasdafasd")) );
 333   VERIFY( string.ends_with(String(c, "t")) );
 334   VERIFY( string.ends_with(String(c, "st")) );
 335   VERIFY( string.ends_with(String(c, "est")) );
 336   VERIFY( string.ends_with(String(c, "Test")) );
 337   VERIFY( !string.ends_with(String(c, "1Test")) );
 338   VERIFY( !string.ends_with(String(c, "abc")) );
 339   VERIFY( !string.ends_with(String(c, "estasdasd")) );
 340   VERIFY( string.find('e') == 1 );
 341   VERIFY( string.find('9') == String::npos );
 342   VERIFY( string.find_first_of(String(c, "st")) == 2 );
 343   VERIFY( string.find_first_of(String(c, "st"), 3) == 3 );
 344   VERIFY( string.find_first_of(String(c, "xyz")) == String::npos );
 345   VERIFY( string.find_first_not_of(String(c, "Tst")) == 1 );
 346   VERIFY( string.find_first_not_of(String(c, "Tse"), 2) == 3 );
 347   VERIFY( string.find_first_not_of(String(c, "abc")) == 0 );
 348   VERIFY( string.find_first_not_of(String(c, "abc"), 20) == String::npos );
 349
 350   naFreeContext(c);
 351
 352   return 0;
 353 }