simgear/nasal/cppbind/cppbind_test.cxx

   1 #include "Ghost.hxx"
   2 #include "NasalHash.hxx"
   3
   4 #include <boost/shared_ptr.hpp>
   5
   6 #include <cstring>
   7 #include <iostream>
   8
   9 #define VERIFY(a) \
  10   if( !(a) ) \
  11   { \
  12     std::cerr << "failed: line " << __LINE__ << ": " << #a << std::endl; \
  13     return 1; \
  14   }
  15
  16 struct Base
  17 {
  18   naRef member(const nasal::CallContext&) { return naNil(); }
  19   virtual ~Base(){};
  20
  21   std::string getString() const { return ""; }
  22   void setString(const std::string&) {}
  23 };
  24 struct Derived:
  25   public Base
  26 {
  27   int _x;
  28   int getX() const { return _x; }
  29   void setX(int x) { _x = x; }
  30 };
  31 struct DoubleDerived:
  32   public Derived
  33 {
  34
  35 };
  36 struct DoubleDerived2:
  37   public Derived
  38 {
  39
  40 };
  41
  42 typedef boost::shared_ptr<Base> BasePtr;
  43 typedef boost::shared_ptr<Derived> DerivedPtr;
  44 typedef boost::shared_ptr<DoubleDerived> DoubleDerivedPtr;
  45 typedef boost::shared_ptr<DoubleDerived2> DoubleDerived2Ptr;
  46
  47 naRef member(Derived&, const nasal::CallContext&) { return naNil(); }
  48
  49 int main(int argc, char* argv[])
  50 {
  51   naContext c = naNewContext();
  52   naRef r;
  53
  54   using namespace nasal;
  55
  56   r = to_nasal(c, "Test");
  57   VERIFY( strncmp("Test", naStr_data(r), naStr_len(r)) == 0 );
  58   VERIFY( from_nasal<std::string>(c, r) == "Test" );
  59
  60   r = to_nasal(c, std::string("Test"));
  61   VERIFY( strncmp("Test", naStr_data(r), naStr_len(r)) == 0 );
  62   VERIFY( from_nasal<std::string>(c, r) == "Test" );
  63
  64   r = to_nasal(c, 42);
  65   VERIFY( naNumValue(r).num == 42 );
  66   VERIFY( from_nasal<int>(c, r) == 42 );
  67
  68   r = to_nasal(c, 4.2f);
  69   VERIFY( naNumValue(r).num == 4.2f );
  70   VERIFY( from_nasal<float>(c, r) == 4.2f );
  71
  72   std::vector<int> vec;
  73   r = to_nasal(c, vec);
  74
  75   r = to_nasal(c, "string");
  76   try
  77   {
  78     from_nasal<int>(c, r);
  79
  80     std::cerr << "failed: Expected bad_nasal_cast to be thrown" << std::endl;
  81     return 1;
  82   }
  83   catch(nasal::bad_nasal_cast&)
  84   {}
  85
  86   Hash hash(c);
  87   hash.set("vec", r);
  88   hash.set("vec2", vec);
  89   hash.set("name", "my-name");
  90   hash.set("string", std::string("blub"));
  91
  92   r = to_nasal(c, hash);
  93   VERIFY( naIsHash(r) );
  94
  95   VERIFY( hash.get<std::string>("name") == "my-name" );
  96   VERIFY( naIsString(hash.get("name")) );
  97
  98   Hash mod = hash.createHash("mod");
  99   mod.set("parent", hash);
 100
 101   Ghost<Base>::init("Base")
 102     .method<&Base::member>("member")
 103     .member("str", &Base::getString, &Base::setString);
 104   Ghost<Derived>::init("Derived")
 105     .bases<Base>()
 106     .member("x", &Derived::getX, &Derived::setX)
 107     .method_func<&member>("free_member");
 108
 109   naRef derived = Ghost<Derived>::create(c);
 110   VERIFY( naIsGhost(derived) );
 111   VERIFY( std::string("Derived") ==  naGhost_type(derived)->name );
 112
 113   Ghost<BasePtr>::init("BasePtr");
 114   Ghost<DerivedPtr>::init("DerivedPtr")
 115     .bases<BasePtr>()
 116     .member("x", &Derived::getX, &Derived::setX)
 117     .method_func<&member>("free_member");
 118   Ghost<DoubleDerivedPtr>::init("DoubleDerivedPtr")
 119     .bases<DerivedPtr>();
 120   Ghost<DoubleDerived2Ptr>::init("DoubleDerived2Ptr")
 121     .bases<DerivedPtr>();
 122
 123   BasePtr d( new Derived );
 124   derived = Ghost<BasePtr>::create(c, d);
 125   VERIFY( naIsGhost(derived) );
 126   VERIFY( std::string("DerivedPtr") == naGhost_type(derived)->name );
 127
 128   BasePtr d2( new DoubleDerived );
 129   derived = Ghost<BasePtr>::create(c, d2);
 130   VERIFY( naIsGhost(derived) );
 131   VERIFY( std::string("DoubleDerivedPtr") ==  naGhost_type(derived)->name );
 132
 133   BasePtr d3( new DoubleDerived2 );
 134   derived = Ghost<BasePtr>::create(c, d3);
 135   VERIFY( naIsGhost(derived) );
 136   VERIFY( std::string("DoubleDerived2Ptr") ==  naGhost_type(derived)->name );
 137
 138   VERIFY( Ghost<BasePtr>::isBaseOf(derived) );
 139   VERIFY( Ghost<DerivedPtr>::isBaseOf(derived) );
 140   VERIFY( Ghost<DoubleDerived2Ptr>::isBaseOf(derived) );
 141
 142   VERIFY( Ghost<BasePtr>::fromNasal(c, derived) == d3 );
 143   VERIFY( Ghost<BasePtr>::fromNasal(c, derived) != d2 );
 144   VERIFY(    Ghost<DerivedPtr>::fromNasal(c, derived)
 145           == boost::dynamic_pointer_cast<Derived>(d3) );
 146   VERIFY(    Ghost<DoubleDerived2Ptr>::fromNasal(c, derived)
 147           == boost::dynamic_pointer_cast<DoubleDerived2>(d3) );
 148   VERIFY( !Ghost<DoubleDerivedPtr>::fromNasal(c, derived) );
 149
 150   // Check converting to Ghost if using Nasal hashes with actual ghost inside
 151   // the hashes parents vector
 152   std::vector<naRef> parents;
 153   parents.push_back(hash.get_naRef());
 154   parents.push_back(derived);
 155
 156   Hash obj(c);
 157   obj.set("parents", parents);
 158   VERIFY( Ghost<BasePtr>::fromNasal(c, obj.get_naRef()) == d3 );
 159
 160   // Check recursive parents (aka parent-of-parent)
 161   std::vector<naRef> parents2;
 162   parents2.push_back(obj.get_naRef());
 163   Hash derived_obj(c);
 164   derived_obj.set("parents", parents2);
 165   VERIFY( Ghost<BasePtr>::fromNasal(c, derived_obj.get_naRef()) == d3 );
 166
 167   naRef args[] = {
 168     to_nasal(c, std::string("test-arg"))
 169   };
 170   CallContext cc(c, sizeof(args)/sizeof(args[0]), args);
 171   VERIFY( cc.requireArg<std::string>(0) == "test-arg" );
 172   VERIFY( cc.getArg<std::string>(0) == "test-arg" );
 173   VERIFY( cc.getArg<std::string>(1) == "" );
 174
 175   // TODO actually do something with the ghosts...
 176
 177   naFreeContext(c);
 178
 179   return 0;
 180 }