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
   9 #include <cstring>
  10 #include <iostream>
  11
  12 #define VERIFY(a) \
  13   if( !(a) ) \
  14   { \
  15     std::cerr << "failed: line " << __LINE__ << ": " << #a << std::endl; \
  16     return 1; \
  17   }
  18
  19 struct Base
  20 {
  21   naRef member(const nasal::CallContext&) { return naNil(); }
  22   virtual ~Base(){};
  23
  24   std::string getString() const { return ""; }
  25   void setString(const std::string&) {}
  26   void constVoidFunc() const {}
  27
  28   std::string var;
  29   const std::string& getVar() const { return var; }
  30   void setVar(const std::string v) { var = v; }
  31 };
  32
  33 void baseVoidFunc(Base& b) {}
  34 void baseConstVoidFunc(const Base& b) {}
  35
  36 struct Derived:
  37   public Base
  38 {
  39   int _x;
  40   int getX() const { return _x; }
  41   void setX(int x) { _x = x; }
  42 };
  43 struct DoubleDerived:
  44   public Derived
  45 {
  46
  47 };
  48 struct DoubleDerived2:
  49   public Derived
  50 {
  51
  52 };
  53
  54 typedef boost::shared_ptr<Base> BasePtr;
  55 typedef boost::shared_ptr<Derived> DerivedPtr;
  56 typedef boost::shared_ptr<DoubleDerived> DoubleDerivedPtr;
  57 typedef boost::shared_ptr<DoubleDerived2> DoubleDerived2Ptr;
  58
  59 naRef to_nasal(naContext c, const BasePtr& base)
  60 {
  61   return nasal::Ghost<BasePtr>::create(c, base);
  62 }
  63
  64 naRef member(Derived&, const nasal::CallContext&) { return naNil(); }
  65 naRef f_derivedGetX(naContext c, const Derived& d)
  66 {
  67   return nasal::to_nasal(c, d.getX());
  68 }
  69
  70 int main(int argc, char* argv[])
  71 {
  72   naContext c = naNewContext();
  73   naRef r;
  74
  75   using namespace nasal;
  76
  77   r = to_nasal(c, "Test");
  78   VERIFY( strncmp("Test", naStr_data(r), naStr_len(r)) == 0 );
  79   VERIFY( from_nasal<std::string>(c, r) == "Test" );
  80
  81   r = to_nasal(c, std::string("Test"));
  82   VERIFY( strncmp("Test", naStr_data(r), naStr_len(r)) == 0 );
  83   VERIFY( from_nasal<std::string>(c, r) == "Test" );
  84
  85   r = to_nasal(c, 42);
  86   VERIFY( naNumValue(r).num == 42 );
  87   VERIFY( from_nasal<int>(c, r) == 42 );
  88
  89   r = to_nasal(c, 4.2f);
  90   VERIFY( naNumValue(r).num == 4.2f );
  91   VERIFY( from_nasal<float>(c, r) == 4.2f );
  92
  93   float test_data[3] = {0, 4, 2};
  94   r = to_nasal(c, test_data);
  95
  96   SGVec2f vec(0,2);
  97   r = to_nasal(c, vec);
  98   VERIFY( from_nasal<SGVec2f>(c, r) == vec );
  99
 100   std::vector<int> std_vec;
 101   r = to_nasal(c, std_vec);
 102
 103   r = to_nasal(c, "string");
 104   try
 105   {
 106     from_nasal<int>(c, r);
 107
 108     std::cerr << "failed: Expected bad_nasal_cast to be thrown" << std::endl;
 109     return 1;
 110   }
 111   catch(nasal::bad_nasal_cast&)
 112   {}
 113
 114   Hash hash(c);
 115   hash.set("vec", r);
 116   hash.set("vec2", vec);
 117   hash.set("name", "my-name");
 118   hash.set("string", std::string("blub"));
 119
 120   r = to_nasal(c, hash);
 121   VERIFY( naIsHash(r) );
 122
 123   VERIFY( hash.get<std::string>("name") == "my-name" );
 124   VERIFY( naIsString(hash.get("name")) );
 125
 126   Hash mod = hash.createHash("mod");
 127   mod.set("parent", hash);
 128
 129   String string( to_nasal(c, "Test") );
 130   VERIFY( from_nasal<std::string>(c, string.get_naRef()) == "Test" );
 131   VERIFY( string.c_str() == std::string("Test") );
 132   VERIFY( string.starts_with(string) );
 133   VERIFY( string.starts_with(String(c, "T")) );
 134   VERIFY( string.starts_with(String(c, "Te")) );
 135   VERIFY( string.starts_with(String(c, "Tes")) );
 136   VERIFY( string.starts_with(String(c, "Test")) );
 137   VERIFY( !string.starts_with(String(c, "Test1")) );
 138   VERIFY( !string.starts_with(String(c, "bb")) );
 139   VERIFY( !string.starts_with(String(c, "bbasdasdafasd")) );
 140   VERIFY( string.find('e') == 1 );
 141   VERIFY( string.find('9') == String::npos );
 142   VERIFY( string.find_first_of(String(c, "st")) == 2 );
 143   VERIFY( string.find_first_of(String(c, "st"), 3) == 3 );
 144   VERIFY( string.find_first_of(String(c, "xyz")) == String::npos );
 145   VERIFY( string.find_first_not_of(String(c, "Tst")) == 1 );
 146   VERIFY( string.find_first_not_of(String(c, "Tse"), 2) == 3 );
 147   VERIFY( string.find_first_not_of(String(c, "abc")) == 0 );
 148   VERIFY( string.find_first_not_of(String(c, "abc"), 20) == String::npos );
 149
 150   Ghost<BasePtr>::init("BasePtr")
 151     .method<&Base::member>("member")
 152     .member("str", &Base::getString, &Base::setString)
 153     .method("str_m", &Base::getString)
 154     .method("void", &Base::constVoidFunc)
 155     .member("var_r", &Base::getVar)
 156     .member("var_w", &Base::setVar)
 157     .member("var", &Base::getVar, &Base::setVar)
 158     /*.method("void", &baseVoidFunc)*/;
 159   Ghost<DerivedPtr>::init("DerivedPtr")
 160     .bases<BasePtr>()
 161     .member("x", &Derived::getX, &Derived::setX)
 162     .member("x_alternate", &f_derivedGetX)
 163     .method_func<&member>("free_member");
 164   Ghost<DoubleDerivedPtr>::init("DoubleDerivedPtr")
 165     .bases<DerivedPtr>();
 166   Ghost<DoubleDerived2Ptr>::init("DoubleDerived2Ptr")
 167     .bases< Ghost<DerivedPtr> >();
 168
 169   BasePtr d( new Derived );
 170   naRef derived = Ghost<BasePtr>::create(c, d);
 171   VERIFY( naIsGhost(derived) );
 172   VERIFY( std::string("DerivedPtr") == naGhost_type(derived)->name );
 173
 174   BasePtr d2( new DoubleDerived );
 175   derived = Ghost<BasePtr>::create(c, d2);
 176   VERIFY( naIsGhost(derived) );
 177   VERIFY( std::string("DoubleDerivedPtr") ==  naGhost_type(derived)->name );
 178
 179   BasePtr d3( new DoubleDerived2 );
 180   derived = Ghost<BasePtr>::create(c, d3);
 181   VERIFY( naIsGhost(derived) );
 182   VERIFY( std::string("DoubleDerived2Ptr") ==  naGhost_type(derived)->name );
 183
 184   VERIFY( Ghost<BasePtr>::isBaseOf(derived) );
 185   VERIFY( Ghost<DerivedPtr>::isBaseOf(derived) );
 186   VERIFY( Ghost<DoubleDerived2Ptr>::isBaseOf(derived) );
 187
 188   VERIFY( Ghost<BasePtr>::fromNasal(c, derived) == d3 );
 189   VERIFY( Ghost<BasePtr>::fromNasal(c, derived) != d2 );
 190   VERIFY(    Ghost<DerivedPtr>::fromNasal(c, derived)
 191           == boost::dynamic_pointer_cast<Derived>(d3) );
 192   VERIFY(    Ghost<DoubleDerived2Ptr>::fromNasal(c, derived)
 193           == boost::dynamic_pointer_cast<DoubleDerived2>(d3) );
 194   VERIFY( !Ghost<DoubleDerivedPtr>::fromNasal(c, derived) );
 195
 196   std::map<std::string, BasePtr> instances;
 197   VERIFY( naIsHash(to_nasal(c, instances)) );
 198
 199   std::map<std::string, DerivedPtr> instances_d;
 200   VERIFY( naIsHash(to_nasal(c, instances_d)) );
 201
 202   std::map<std::string, int> int_map;
 203   VERIFY( naIsHash(to_nasal(c, int_map)) );
 204
 205   std::map<std::string, std::vector<int> > int_vector_map;
 206   VERIFY( naIsHash(to_nasal(c, int_vector_map)) );
 207
 208   // Check converting to Ghost if using Nasal hashes with actual ghost inside
 209   // the hashes parents vector
 210   std::vector<naRef> parents;
 211   parents.push_back(hash.get_naRef());
 212   parents.push_back(derived);
 213
 214   Hash obj(c);
 215   obj.set("parents", parents);
 216   VERIFY( Ghost<BasePtr>::fromNasal(c, obj.get_naRef()) == d3 );
 217
 218   // Check recursive parents (aka parent-of-parent)
 219   std::vector<naRef> parents2;
 220   parents2.push_back(obj.get_naRef());
 221   Hash derived_obj(c);
 222   derived_obj.set("parents", parents2);
 223   VERIFY( Ghost<BasePtr>::fromNasal(c, derived_obj.get_naRef()) == d3 );
 224
 225   naRef args[] = {
 226     to_nasal(c, std::string("test-arg"))
 227   };
 228   CallContext cc(c, sizeof(args)/sizeof(args[0]), args);
 229   VERIFY( cc.requireArg<std::string>(0) == "test-arg" );
 230   VERIFY( cc.getArg<std::string>(0) == "test-arg" );
 231   VERIFY( cc.getArg<std::string>(1) == "" );
 232
 233   naRef args_vec = nasal::to_nasal(c, args);
 234   VERIFY( naIsVector(args_vec) );
 235
 236   // TODO actually do something with the ghosts...
 237
 238   naFreeContext(c);
 239
 240   return 0;
 241 }