cppbind: check if ghost is of wrong type.

- Throw an exception if converting an object
   from Nasal fails due to a wrong type (nil
   does not throw).
 - Update cppbind test cases accordingly (and
   refactor another test suite to use Boost.
   Test).

simgear/nasal/cppbind/CMakeLists.txt

@@ -34,17 +34,16 @@ set(SOURCES
 simgear_component(nasal/cppbind nasal/cppbind "${SOURCES}" "${HEADERS}")
 simgear_component(nasal/cppbind/detail nasal/cppbind/detail "" "${DETAIL_HEADERS}")
 
-if(ENABLE_TESTS)
-  add_executable(test_cppbind cppbind_test.cxx)
-  add_test(cppbind ${EXECUTABLE_OUTPUT_PATH}/test_cppbind)
-  target_link_libraries(test_cppbind ${TEST_LIBS})
-endif(ENABLE_TESTS)
-
 add_boost_test(cppbind_ghost
   SOURCES cppbind_test_ghost.cxx
   LIBRARIES ${TEST_LIBS}
 )
 
+add_boost_test(cppbind_misc
+  SOURCES cppbind_test.cxx
+  LIBRARIES ${TEST_LIBS}
+)
+
 add_boost_test(nasal_num
   SOURCES nasal_num_test.cxx
   LIBRARIES ${TEST_LIBS}

simgear/nasal/cppbind/Ghost.hxx

@@ -880,6 +880,41 @@ namespace nasal
         return strong_ref();
       }
 
+      /**
+       * Convert Nasal object to C++ object and check if it has the correct
+       * type.
+       *
+       * @see fromNasal
+       */
+      static strong_ref fromNasalChecked(naContext c, naRef me)
+      {
+        strong_ref obj = fromNasal(c, me);
+        if( obj )
+          return obj;
+        if( naIsNil(me) )
+          return strong_ref();
+
+        std::string msg = "Can not convert to '"
+                        + getSingletonPtr()->_name_strong
+                        + "': ";
+
+        naGhostType* ghost_type = naGhost_type(me);
+        if( ghost_type )
+          msg += "not a derived class (or expired weak ref): "
+                 "'" + std::string(ghost_type->name) + "'";
+        else if( naIsHash(me) )
+        {
+          if( !naIsVector(naHash_cget(me, const_cast<char*>("parents"))) )
+            msg += "missing parents vector";
+          else
+            msg += "not a derived hash";
+        }
+        else
+          msg += "not an object";
+
+        throw bad_nasal_cast(msg);
+      }
+
     private:
 
       template<class, class>
@@ -1420,7 +1455,7 @@ typename boost::enable_if<
 from_nasal_helper(naContext c, naRef ref, const T*)
 {
   typedef typename nasal::shared_ptr_traits<T>::strong_ref strong_ref;
-  return T(nasal::Ghost<strong_ref>::fromNasal(c, ref));
+  return T(nasal::Ghost<strong_ref>::fromNasalChecked(c, ref));
 }
 
 /**
@@ -1455,7 +1490,7 @@ typename boost::enable_if_c<
 from_nasal_helper(naContext c, naRef ref, const T*)
 {
   typedef SGSharedPtr<typename boost::remove_pointer<T>::type> TypeRef;
-  return T(nasal::Ghost<TypeRef>::fromNasal(c, ref));
+  return T(nasal::Ghost<TypeRef>::fromNasalChecked(c, ref));
 }
 
 /**
@@ -1482,7 +1517,7 @@ typename boost::enable_if<
 from_nasal_helper(naContext c, naRef ref, const T*)
 {
   typedef osg::ref_ptr<typename boost::remove_pointer<T>::type> TypeRef;
-  return T(nasal::Ghost<TypeRef>::fromNasal(c, ref));
+  return T(nasal::Ghost<TypeRef>::fromNasalChecked(c, ref));
 }
 
 #endif /* SG_NASAL_GHOST_HXX_ */

simgear/nasal/cppbind/cppbind_test.cxx

@@ -1,22 +1,17 @@
-#include <simgear/math/SGMath.hxx>
+#define BOOST_TEST_MODULE cppbind
+#include <BoostTestTargetConfig.h>
 
 #include "Ghost.hxx"
 #include "NasalHash.hxx"
 #include "NasalString.hxx"
+
+#include <simgear/math/SGMath.hxx>
 #include <simgear/structure/map.hxx>
 
 #include <boost/shared_ptr.hpp>
 #include <boost/weak_ptr.hpp>
 
 #include <cstring>
-#include <iostream>
-
-#define VERIFY(a) \
-  if( !(a) ) \
-  { \
-    std::cerr << "failed: line " << __LINE__ << ": " << #a << std::endl; \
-    return 1; \
-  }
 
 enum MyEnum
 {
@@ -121,7 +116,7 @@ naRef f_derivedGetX(const Derived& d, naContext c)
 }
 naRef f_freeFunction(nasal::CallContext c) { return c.requireArg<naRef>(0); }
 
-int main(int argc, char* argv[])
+BOOST_AUTO_TEST_CASE( cppbind_misc_testing )
 {
   naContext c = naNewContext();
   naRef r;
@@ -129,44 +124,36 @@ int main(int argc, char* argv[])
   using namespace nasal;
 
   r = to_nasal(c, ENUM_ANOTHER);
-  VERIFY( from_nasal<int>(c, r) == ENUM_ANOTHER );
+  BOOST_CHECK_EQUAL(from_nasal<int>(c, r), ENUM_ANOTHER);
 
   r = to_nasal(c, "Test");
-  VERIFY( strncmp("Test", naStr_data(r), naStr_len(r)) == 0 );
+  BOOST_CHECK( strncmp("Test", naStr_data(r), naStr_len(r)) == 0 );
-  VERIFY( from_nasal<std::string>(c, r) == "Test" );
+  BOOST_CHECK_EQUAL(from_nasal<std::string>(c, r), "Test");
 
   r = to_nasal(c, std::string("Test"));
-  VERIFY( strncmp("Test", naStr_data(r), naStr_len(r)) == 0 );
+  BOOST_CHECK( strncmp("Test", naStr_data(r), naStr_len(r)) == 0 );
-  VERIFY( from_nasal<std::string>(c, r) == "Test" );
+  BOOST_CHECK_EQUAL(from_nasal<std::string>(c, r), "Test");
 
   r = to_nasal(c, 42);
-  VERIFY( naNumValue(r).num == 42 );
+  BOOST_CHECK_EQUAL(naNumValue(r).num, 42);
-  VERIFY( from_nasal<int>(c, r) == 42 );
+  BOOST_CHECK_EQUAL(from_nasal<int>(c, r), 42);
 
   r = to_nasal(c, 4.2f);
-  VERIFY( naNumValue(r).num == 4.2f );
+  BOOST_CHECK_EQUAL(naNumValue(r).num, 4.2f);
-  VERIFY( from_nasal<float>(c, r) == 4.2f );
+  BOOST_CHECK_EQUAL(from_nasal<float>(c, r), 4.2f);
 
   float test_data[3] = {0, 4, 2};
   r = to_nasal(c, test_data);
 
   SGVec2f vec(0,2);
   r = to_nasal(c, vec);
-  VERIFY( from_nasal<SGVec2f>(c, r) == vec );
+  BOOST_CHECK_EQUAL(from_nasal<SGVec2f>(c, r), vec);
 
   std::vector<int> std_vec;
   r = to_nasal(c, std_vec);
 
   r = to_nasal(c, "string");
-  try
+  BOOST_CHECK_THROW(from_nasal<int>(c, r), bad_nasal_cast);
-  {
-    from_nasal<int>(c, r);
-
-    std::cerr << "failed: Expected bad_nasal_cast to be thrown" << std::endl;
-    return 1;
-  }
-  catch(nasal::bad_nasal_cast&)
-  {}
 
   Hash hash(c);
   hash.set("vec", r);
@@ -175,9 +162,10 @@ int main(int argc, char* argv[])
   hash.set("string", std::string("blub"));
   hash.set("func", &f_freeFunction);
 
-  VERIFY( hash.size() == 5 )
+  BOOST_CHECK_EQUAL(hash.size(), 5);
   for(Hash::const_iterator it = hash.begin(); it != hash.end(); ++it)
-    VERIFY( hash.get<std::string>(it->getKey()) == it->getValue<std::string>() )
+    BOOST_CHECK_EQUAL( hash.get<std::string>(it->getKey()),
+                       it->getValue<std::string>() );
 
   Hash::iterator it1, it2;
   Hash::const_iterator it3 = it1, it4(it2);
@@ -185,15 +173,15 @@ int main(int argc, char* argv[])
   it3 = it2;
 
   r = to_nasal(c, hash);
-  VERIFY( naIsHash(r) );
+  BOOST_REQUIRE( naIsHash(r) );
 
   simgear::StringMap string_map = from_nasal<simgear::StringMap>(c, r);
-  VERIFY( string_map.at("vec") == "string" )
+  BOOST_CHECK_EQUAL(string_map.at("vec"), "string");
-  VERIFY( string_map.at("name") == "my-name" )
+  BOOST_CHECK_EQUAL(string_map.at("name"), "my-name");
-  VERIFY( string_map.at("string") == "blub" )
+  BOOST_CHECK_EQUAL(string_map.at("string"), "blub");
 
-  VERIFY( hash.get<std::string>("name") == "my-name" );
+  BOOST_CHECK_EQUAL(hash.get<std::string>("name"), "my-name");
-  VERIFY( naIsString(hash.get("name")) );
+  BOOST_CHECK(naIsString(hash.get("name")));
 
   Hash mod = hash.createHash("mod");
   mod.set("parent", hash);
@@ -201,35 +189,35 @@ int main(int argc, char* argv[])
 
   // 'func' is a C++ function registered to Nasal and now converted back to C++
   boost::function<int (int)> f = hash.get<int (int)>("func");
-  VERIFY( f );
+  BOOST_REQUIRE( f );
-  VERIFY( f(3) == 3 );
+  BOOST_CHECK_EQUAL(f(3), 3);
 
   boost::function<std::string (int)> fs = hash.get<std::string (int)>("func");
-  VERIFY( fs );
+  BOOST_REQUIRE( fs );
-  VERIFY( fs(14) == "14" );
+  BOOST_CHECK_EQUAL(fs(14), "14");
 
   typedef boost::function<void (int)> FuncVoidInt;
   FuncVoidInt fvi = hash.get<FuncVoidInt>("func");
-  VERIFY( fvi );
+  BOOST_REQUIRE( fvi );
   fvi(123);
 
   typedef boost::function<std::string (const std::string&, int, float)> FuncMultiArg;
   FuncMultiArg fma = hash.get<FuncMultiArg>("func");
-  VERIFY( fma );
+  BOOST_REQUIRE( fma );
-  VERIFY( fma("test", 3, .5) == "test" );
+  BOOST_CHECK_EQUAL(fma("test", 3, .5), "test");
 
   typedef boost::function<naRef (naRef)> naRefMemFunc;
   naRefMemFunc fmem = hash.get<naRefMemFunc>("func");
-  VERIFY( fmem );
+  BOOST_REQUIRE( fmem );
   naRef ret = fmem(hash.get_naRef()),
         hash_ref = hash.get_naRef();
-  VERIFY( naIsIdentical(ret, hash_ref) );
+  BOOST_CHECK( naIsIdentical(ret, hash_ref) );
 
   // Check if nasal::Me gets passed as self/me and remaining arguments are
   // passed on to function
   typedef boost::function<int (Me, int)> MeIntFunc;
   MeIntFunc fmeint = hash.get<MeIntFunc>("func");
-  VERIFY( fmeint(naNil(), 5) == 5 );
+  BOOST_CHECK_EQUAL(fmeint(naNil(), 5), 5);
 
   //----------------------------------------------------------------------------
   // Test exposing classes to Nasal
@@ -276,78 +264,80 @@ int main(int argc, char* argv[])
   naRef nasal_ref = to_nasal(c, weak_ptr),
         nasal_ptr = to_nasal(c, weak_ptr.get());
 
-  VERIFY( naIsGhost(nasal_ref) );
+  BOOST_REQUIRE( naIsGhost(nasal_ref) );
-  VERIFY( naIsGhost(nasal_ptr) );
+  BOOST_REQUIRE( naIsGhost(nasal_ptr) );
 
   SGWeakRefBasedPtr ptr1 = from_nasal<SGWeakRefBasedPtr>(c, nasal_ref),
                     ptr2 = from_nasal<SGWeakRefBasedPtr>(c, nasal_ptr);
 
-  VERIFY( weak_ptr == ptr1 );
+  BOOST_CHECK_EQUAL(weak_ptr, ptr1);
-  VERIFY( weak_ptr == ptr2 );
+  BOOST_CHECK_EQUAL(weak_ptr, ptr2);
 
 
-  VERIFY( Ghost<BasePtr>::isInit() );
+  BOOST_REQUIRE( Ghost<BasePtr>::isInit() );
   nasal::to_nasal(c, DoubleDerived2Ptr());
 
   BasePtr d( new Derived );
   naRef derived = to_nasal(c, d);
-  VERIFY( naIsGhost(derived) );
+  BOOST_REQUIRE( naIsGhost(derived) );
-  VERIFY( std::string("DerivedPtr") == naGhost_type(derived)->name );
+  BOOST_CHECK_EQUAL( std::string("DerivedPtr"), naGhost_type(derived)->name );
 
   // Get member function from ghost...
   naRef thisGetter = naNil();
-  VERIFY( naMember_get(c, derived, to_nasal(c, "this"), &thisGetter) );
+  BOOST_CHECK( naMember_get(c, derived, to_nasal(c, "this"), &thisGetter) );
-  VERIFY( naIsFunc(thisGetter) );
+  BOOST_CHECK( naIsFunc(thisGetter) );
 
   // ...and check if it really gets passed the correct instance
   typedef boost::function<unsigned long (Me)> MemFunc;
   MemFunc fGetThis = from_nasal<MemFunc>(c, thisGetter);
-  VERIFY( fGetThis );
+  BOOST_REQUIRE( fGetThis );
-  VERIFY( fGetThis(derived) == (unsigned long)d.get() );
+  BOOST_CHECK_EQUAL( fGetThis(derived), (unsigned long)d.get() );
 
   BasePtr d2( new DoubleDerived );
   derived = to_nasal(c, d2);
-  VERIFY( naIsGhost(derived) );
+  BOOST_CHECK( naIsGhost(derived) );
-  VERIFY( std::string("DoubleDerivedPtr") ==  naGhost_type(derived)->name );
+  BOOST_CHECK_EQUAL( std::string("DoubleDerivedPtr"),
+                     naGhost_type(derived)->name );
 
   BasePtr d3( new DoubleDerived2 );
   derived = to_nasal(c, d3);
-  VERIFY( naIsGhost(derived) );
+  BOOST_CHECK( naIsGhost(derived) );
-  VERIFY( std::string("DoubleDerived2Ptr") ==  naGhost_type(derived)->name );
+  BOOST_CHECK_EQUAL( std::string("DoubleDerived2Ptr"),
+                     naGhost_type(derived)->name );
 
   SGRefBasedPtr ref_based( new SGReferenceBasedClass );
   naRef na_ref_based = to_nasal(c, ref_based.get());
-  VERIFY( naIsGhost(na_ref_based) );
+  BOOST_CHECK( naIsGhost(na_ref_based) );
-  VERIFY(    from_nasal<SGReferenceBasedClass*>(c, na_ref_based)
+  BOOST_CHECK_EQUAL( from_nasal<SGReferenceBasedClass*>(c, na_ref_based),
-          == ref_based.get() );
+                     ref_based.get() );
-  VERIFY( from_nasal<SGRefBasedPtr>(c, na_ref_based) == ref_based );
+  BOOST_CHECK_EQUAL( from_nasal<SGRefBasedPtr>(c, na_ref_based), ref_based );
 
-  VERIFY( from_nasal<BasePtr>(c, derived) == d3 );
+  BOOST_CHECK_EQUAL( from_nasal<BasePtr>(c, derived), d3 );
-  VERIFY( from_nasal<BasePtr>(c, derived) != d2 );
+  BOOST_CHECK_NE( from_nasal<BasePtr>(c, derived), d2 );
-  VERIFY(    from_nasal<DerivedPtr>(c, derived)
+  BOOST_CHECK_EQUAL( from_nasal<DerivedPtr>(c, derived),
-          == boost::dynamic_pointer_cast<Derived>(d3) );
+                     boost::dynamic_pointer_cast<Derived>(d3) );
-  VERIFY(    from_nasal<DoubleDerived2Ptr>(c, derived)
+  BOOST_CHECK_EQUAL( from_nasal<DoubleDerived2Ptr>(c, derived),
-          == boost::dynamic_pointer_cast<DoubleDerived2>(d3) );
+                     boost::dynamic_pointer_cast<DoubleDerived2>(d3) );
-  VERIFY( !from_nasal<DoubleDerivedPtr>(c, derived) );
+  BOOST_CHECK_THROW( from_nasal<DoubleDerivedPtr>(c, derived), bad_nasal_cast );
 
   std::map<std::string, BasePtr> instances;
-  VERIFY( naIsHash(to_nasal(c, instances)) );
+  BOOST_CHECK( naIsHash(to_nasal(c, instances)) );
 
   std::map<std::string, DerivedPtr> instances_d;
-  VERIFY( naIsHash(to_nasal(c, instances_d)) );
+  BOOST_CHECK( naIsHash(to_nasal(c, instances_d)) );
 
   std::map<std::string, int> int_map;
-  VERIFY( naIsHash(to_nasal(c, int_map)) );
+  BOOST_CHECK( naIsHash(to_nasal(c, int_map)) );
 
   std::map<std::string, std::vector<int> > int_vector_map;
-  VERIFY( naIsHash(to_nasal(c, int_vector_map)) );
+  BOOST_CHECK( naIsHash(to_nasal(c, int_vector_map)) );
 
   simgear::StringMap dict =
     simgear::StringMap("hello", "value")
                       ("key2", "value2");
   naRef na_dict = to_nasal(c, dict);
-  VERIFY( naIsHash(na_dict) );
+  BOOST_REQUIRE( naIsHash(na_dict) );
-  VERIFY( Hash(na_dict, c).get<std::string>("key2") == "value2" );
+  BOOST_CHECK_EQUAL( Hash(na_dict, c).get<std::string>("key2"), "value2" );
 
   // Check converting to Ghost if using Nasal hashes with actual ghost inside
   // the hashes parents vector
@@ -357,14 +347,14 @@ int main(int argc, char* argv[])
 
   Hash obj(c);
   obj.set("parents", parents);
-  VERIFY( from_nasal<BasePtr>(c, obj.get_naRef()) == d3 );
+  BOOST_CHECK_EQUAL( from_nasal<BasePtr>(c, obj.get_naRef()), d3 );
 
   // Check recursive parents (aka parent-of-parent)
   std::vector<naRef> parents2;
   parents2.push_back(obj.get_naRef());
   Hash derived_obj(c);
   derived_obj.set("parents", parents2);
-  VERIFY( from_nasal<BasePtr>(c, derived_obj.get_naRef()) == d3 );
+  BOOST_CHECK_EQUAL( from_nasal<BasePtr>(c, derived_obj.get_naRef()), d3 );
 
   std::vector<naRef> nasal_objects;
   nasal_objects.push_back( Ghost<BasePtr>::makeGhost(c, d) );
@@ -373,9 +363,9 @@ int main(int argc, char* argv[])
   naRef obj_vec = to_nasal(c, nasal_objects);
 
   std::vector<BasePtr> objects = from_nasal<std::vector<BasePtr> >(c, obj_vec);
-  VERIFY( objects[0] == d );
+  BOOST_CHECK_EQUAL( objects[0], d );
-  VERIFY( objects[1] == d2 );
+  BOOST_CHECK_EQUAL( objects[1], d2 );
-  VERIFY( objects[2] == d3 );
+  BOOST_CHECK_EQUAL( objects[2], d3 );
 
   {
     // Calling fallback setter for unset values
@@ -386,9 +376,9 @@ int main(int argc, char* argv[])
                               &errLine );
     ret = naCallMethod(code, derived, 0, 0, naNil());
 
-    VERIFY( !naGetError(c) ) // TODO real error check (this seems to always
+    BOOST_REQUIRE( !naGetError(c) ); // TODO real error check (this seems to
-                             //      return 0...
+                                     //      always return 0...
-    VERIFY( from_nasal<int>(c, ret) == 3 )
+    BOOST_CHECK_EQUAL( from_nasal<int>(c, ret), 3 );
   }
   {
     // Calling generic (fallback) getter
@@ -399,9 +389,9 @@ int main(int argc, char* argv[])
                               &errLine );
     ret = naCallMethod(code, derived, 0, 0, naNil());
 
-    VERIFY( !naGetError(c) ) // TODO real error check (this seems to always
+    BOOST_REQUIRE( !naGetError(c) ); // TODO real error check (this seems to
-                             //      return 0...
+                                     //      always return 0...
-    VERIFY( from_nasal<std::string>(c, ret) == "generic-get" );
+    BOOST_CHECK_EQUAL( from_nasal<std::string>(c, ret), "generic-get" );
   }
 
   //----------------------------------------------------------------------------
@@ -418,54 +408,52 @@ int main(int argc, char* argv[])
     to_nasal(c, map)
   };
   CallContext cc(c, naNil(), sizeof(args)/sizeof(args[0]), args);
-  VERIFY( cc.requireArg<std::string>(0) == "test-arg" );
+  BOOST_CHECK_EQUAL( cc.requireArg<std::string>(0), "test-arg" );
-  VERIFY( cc.getArg<std::string>(0) == "test-arg" );
+  BOOST_CHECK_EQUAL( cc.getArg<std::string>(0), "test-arg" );
-  VERIFY( cc.getArg<std::string>(10) == "" );
+  BOOST_CHECK_EQUAL( cc.getArg<std::string>(10), "" );
-  VERIFY( cc.isString(0) );
+  BOOST_CHECK( cc.isString(0) );
-  VERIFY( !cc.isNumeric(0) );
+  BOOST_CHECK( !cc.isNumeric(0) );
-  VERIFY( !cc.isVector(0) );
+  BOOST_CHECK( !cc.isVector(0) );
-  VERIFY( !cc.isHash(0) );
+  BOOST_CHECK( !cc.isHash(0) );
-  VERIFY( !cc.isGhost(0) );
+  BOOST_CHECK( !cc.isGhost(0) );
-  VERIFY( cc.isNumeric(1) );
+  BOOST_CHECK( cc.isNumeric(1) );
-  VERIFY( cc.isVector(2) );
+  BOOST_CHECK( cc.isVector(2) );
-  VERIFY( cc.isHash(3) );
+  BOOST_CHECK( cc.isHash(3) );
 
   naRef args_vec = nasal::to_nasal(c, args);
-  VERIFY( naIsVector(args_vec) );
+  BOOST_CHECK( naIsVector(args_vec) );
 
   //----------------------------------------------------------------------------
   // Test nasal::String
   //----------------------------------------------------------------------------
 
   String string( to_nasal(c, "Test") );
-  VERIFY( from_nasal<std::string>(c, string.get_naRef()) == "Test" );
+  BOOST_CHECK_EQUAL( from_nasal<std::string>(c, string.get_naRef()), "Test" );
-  VERIFY( string.c_str() == std::string("Test") );
+  BOOST_CHECK_EQUAL( string.c_str(), std::string("Test") );
-  VERIFY( string.starts_with(string) );
+  BOOST_CHECK( string.starts_with(string) );
-  VERIFY( string.starts_with(String(c, "T")) );
+  BOOST_CHECK( string.starts_with(String(c, "T")) );
-  VERIFY( string.starts_with(String(c, "Te")) );
+  BOOST_CHECK( string.starts_with(String(c, "Te")) );
-  VERIFY( string.starts_with(String(c, "Tes")) );
+  BOOST_CHECK( string.starts_with(String(c, "Tes")) );
-  VERIFY( string.starts_with(String(c, "Test")) );
+  BOOST_CHECK( string.starts_with(String(c, "Test")) );
-  VERIFY( !string.starts_with(String(c, "Test1")) );
+  BOOST_CHECK( !string.starts_with(String(c, "Test1")) );
-  VERIFY( !string.starts_with(String(c, "bb")) );
+  BOOST_CHECK( !string.starts_with(String(c, "bb")) );
-  VERIFY( !string.starts_with(String(c, "bbasdasdafasd")) );
+  BOOST_CHECK( !string.starts_with(String(c, "bbasdasdafasd")) );
-  VERIFY( string.ends_with(String(c, "t")) );
+  BOOST_CHECK( string.ends_with(String(c, "t")) );
-  VERIFY( string.ends_with(String(c, "st")) );
+  BOOST_CHECK( string.ends_with(String(c, "st")) );
-  VERIFY( string.ends_with(String(c, "est")) );
+  BOOST_CHECK( string.ends_with(String(c, "est")) );
-  VERIFY( string.ends_with(String(c, "Test")) );
+  BOOST_CHECK( string.ends_with(String(c, "Test")) );
-  VERIFY( !string.ends_with(String(c, "1Test")) );
+  BOOST_CHECK( !string.ends_with(String(c, "1Test")) );
-  VERIFY( !string.ends_with(String(c, "abc")) );
+  BOOST_CHECK( !string.ends_with(String(c, "abc")) );
-  VERIFY( !string.ends_with(String(c, "estasdasd")) );
+  BOOST_CHECK( !string.ends_with(String(c, "estasdasd")) );
-  VERIFY( string.find('e') == 1 );
+  BOOST_CHECK_EQUAL( string.find('e'), 1 );
-  VERIFY( string.find('9') == String::npos );
+  BOOST_CHECK_EQUAL( string.find('9'), String::npos );
-  VERIFY( string.find_first_of(String(c, "st")) == 2 );
+  BOOST_CHECK_EQUAL( string.find_first_of(String(c, "st")), 2 );
-  VERIFY( string.find_first_of(String(c, "st"), 3) == 3 );
+  BOOST_CHECK_EQUAL( string.find_first_of(String(c, "st"), 3), 3 );
-  VERIFY( string.find_first_of(String(c, "xyz")) == String::npos );
+  BOOST_CHECK_EQUAL( string.find_first_of(String(c, "xyz")), String::npos );
-  VERIFY( string.find_first_not_of(String(c, "Tst")) == 1 );
+  BOOST_CHECK_EQUAL( string.find_first_not_of(String(c, "Tst")), 1 );
-  VERIFY( string.find_first_not_of(String(c, "Tse"), 2) == 3 );
+  BOOST_CHECK_EQUAL( string.find_first_not_of(String(c, "Tse"), 2), 3 );
-  VERIFY( string.find_first_not_of(String(c, "abc")) == 0 );
+  BOOST_CHECK_EQUAL( string.find_first_not_of(String(c, "abc")), 0 );
-  VERIFY( string.find_first_not_of(String(c, "abc"), 20) == String::npos );
+  BOOST_CHECK_EQUAL( string.find_first_not_of(String(c, "abc"), 20), String::npos );
 
   naFreeContext(c);
-
-  return 0;
 }

simgear/nasal/cppbind/cppbind_test_ghost.cxx

@@ -77,7 +77,8 @@ BOOST_AUTO_TEST_CASE( ghost_weak_strong_nasal_conversion )
   BOOST_CHECK_EQUAL( nasal::from_nasal<DerivedPtr>(c, na_d), d );
 
   d.reset();
-  BOOST_REQUIRE( !nasal::from_nasal<DerivedPtr>(c, na_d) );
+  BOOST_REQUIRE_THROW( nasal::from_nasal<DerivedPtr>(c, na_d),
+                       nasal::bad_nasal_cast );
 
   // store strong pointer and extract weak pointer
   d.reset(new Derived);
@@ -132,8 +133,8 @@ BOOST_AUTO_TEST_CASE( ghost_casting_storage )
   na_b1 = nasal::to_nasal(c, b1_ref);
 
   BOOST_CHECK_EQUAL(nasal::from_nasal<Base1*>(c, na_b1), b1_ref.get());
-  BOOST_CHECK(!nasal::from_nasal<Base2*>(c, na_b1));
+  BOOST_CHECK_THROW(nasal::from_nasal<Base2*>(c, na_b1), nasal::bad_nasal_cast);
-  BOOST_CHECK(!nasal::from_nasal<Derived*>(c, na_b1));
+  BOOST_CHECK_THROW(nasal::from_nasal<Derived*>(c, na_b1), nasal::bad_nasal_cast);
 }
 
 //------------------------------------------------------------------------------

simgear/nasal/cppbind/from_nasal.hxx

@@ -47,7 +47,7 @@ namespace nasal
 
   /**
    * Get pointer to specific version of from_nasal, converting to a type
-   * compatible to Var.
+   * compatible to \a Var.
    */
   template<class Var>
   struct from_nasal_ptr
@@ -63,6 +63,9 @@ namespace nasal
     }
   };
 
+  /**
+   * Get member of hash, ghost (also searching in parent objects).
+   */
   template<class T>
   T get_member(naContext c, naRef obj, const std::string& name)
   {