FGFS-4.1/simgear
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cppbind: check if ghost is of wrong type.

Browse Source 
- 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).
This commit is contained in:
Thomas Geymayer
2014-09-15 23:42:12 +02:00
parent 85090180d0
commit 36fd005bb9
5 changed files with 169 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
simgear/nasal/cppbind/CMakeLists.txt
View File

@@ -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}

41
simgear/nasal/cppbind/Ghost.hxx
View File

@@ -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_ */

248
simgear/nasal/cppbind/cppbind_test.cxx
View File

@@ -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 );
VERIFY( from_nasal<std::string>(c, r) == "Test" );
BOOST_CHECK( strncmp("Test", naStr_data(r), naStr_len(r)) == 0 );
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 );
VERIFY( from_nasal<std::string>(c, r) == "Test" );
BOOST_CHECK( strncmp("Test", naStr_data(r), naStr_len(r)) == 0 );
BOOST_CHECK_EQUAL(from_nasal<std::string>(c, r), "Test");
r = to_nasal(c, 42);
VERIFY( naNumValue(r).num == 42 );
VERIFY( from_nasal<int>(c, r) == 42 );
BOOST_CHECK_EQUAL(naNumValue(r).num, 42);
BOOST_CHECK_EQUAL(from_nasal<int>(c, r), 42);
r = to_nasal(c, 4.2f);
VERIFY( naNumValue(r).num == 4.2f );
VERIFY( from_nasal<float>(c, r) == 4.2f );
BOOST_CHECK_EQUAL(naNumValue(r).num, 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
{
from_nasal<int>(c, r);
std::cerr << "failed: Expected bad_nasal_cast to be thrown" << std::endl;
return 1;
}
catch(nasal::bad_nasal_cast&)
{}
BOOST_CHECK_THROW(from_nasal<int>(c, r), 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" )
VERIFY( string_map.at("name") == "my-name" )
VERIFY( string_map.at("string") == "blub" )
BOOST_CHECK_EQUAL(string_map.at("vec"), "string");
BOOST_CHECK_EQUAL(string_map.at("name"), "my-name");
BOOST_CHECK_EQUAL(string_map.at("string"), "blub");
VERIFY( hash.get<std::string>("name") == "my-name" );
VERIFY( naIsString(hash.get("name")) );
BOOST_CHECK_EQUAL(hash.get<std::string>("name"), "my-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 );
VERIFY( f(3) == 3 );
BOOST_REQUIRE( f );
BOOST_CHECK_EQUAL(f(3), 3);
boost::function<std::string (int)> fs = hash.get<std::string (int)>("func");
VERIFY( fs );
VERIFY( fs(14) == "14" );
BOOST_REQUIRE( fs );
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 );
VERIFY( fma("test", 3, .5) == "test" );
BOOST_REQUIRE( fma );
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) );
VERIFY( naIsGhost(nasal_ptr) );
BOOST_REQUIRE( naIsGhost(nasal_ref) );
BOOST_REQUIRE( naIsGhost(nasal_ptr) );
SGWeakRefBasedPtr ptr1 = from_nasal<SGWeakRefBasedPtr>(c, nasal_ref),
ptr2 = from_nasal<SGWeakRefBasedPtr>(c, nasal_ptr);
VERIFY( weak_ptr == ptr1 );
VERIFY( weak_ptr == ptr2 );
BOOST_CHECK_EQUAL(weak_ptr, ptr1);
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) );
VERIFY( std::string("DerivedPtr") == naGhost_type(derived)->name );
BOOST_REQUIRE( naIsGhost(derived) );
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) );
VERIFY( naIsFunc(thisGetter) );
BOOST_CHECK( naMember_get(c, derived, to_nasal(c, "this"), &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 );
VERIFY( fGetThis(derived) == (unsigned long)d.get() );
BOOST_REQUIRE( fGetThis );
BOOST_CHECK_EQUAL( fGetThis(derived), (unsigned long)d.get() );
BasePtr d2( new DoubleDerived );
derived = to_nasal(c, d2);
VERIFY( naIsGhost(derived) );
VERIFY( std::string("DoubleDerivedPtr") == naGhost_type(derived)->name );
BOOST_CHECK( naIsGhost(derived) );
BOOST_CHECK_EQUAL( std::string("DoubleDerivedPtr"),
naGhost_type(derived)->name );
BasePtr d3( new DoubleDerived2 );
derived = to_nasal(c, d3);
VERIFY( naIsGhost(derived) );
VERIFY( std::string("DoubleDerived2Ptr") == naGhost_type(derived)->name );
BOOST_CHECK( naIsGhost(derived) );
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) );
VERIFY( from_nasal<SGReferenceBasedClass*>(c, na_ref_based)
== ref_based.get() );
VERIFY( from_nasal<SGRefBasedPtr>(c, na_ref_based) == ref_based );
BOOST_CHECK( naIsGhost(na_ref_based) );
BOOST_CHECK_EQUAL( from_nasal<SGReferenceBasedClass*>(c, na_ref_based),
ref_based.get() );
BOOST_CHECK_EQUAL( from_nasal<SGRefBasedPtr>(c, na_ref_based), ref_based );
VERIFY( from_nasal<BasePtr>(c, derived) == d3 );
VERIFY( from_nasal<BasePtr>(c, derived) != d2 );
VERIFY( from_nasal<DerivedPtr>(c, derived)
== boost::dynamic_pointer_cast<Derived>(d3) );
VERIFY( from_nasal<DoubleDerived2Ptr>(c, derived)
== boost::dynamic_pointer_cast<DoubleDerived2>(d3) );
VERIFY( !from_nasal<DoubleDerivedPtr>(c, derived) );
BOOST_CHECK_EQUAL( from_nasal<BasePtr>(c, derived), d3 );
BOOST_CHECK_NE( from_nasal<BasePtr>(c, derived), d2 );
BOOST_CHECK_EQUAL( from_nasal<DerivedPtr>(c, derived),
boost::dynamic_pointer_cast<Derived>(d3) );
BOOST_CHECK_EQUAL( from_nasal<DoubleDerived2Ptr>(c, derived),
boost::dynamic_pointer_cast<DoubleDerived2>(d3) );
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) );
VERIFY( Hash(na_dict, c).get<std::string>("key2") == "value2" );
BOOST_REQUIRE( naIsHash(na_dict) );
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 );
VERIFY( objects[1] == d2 );
VERIFY( objects[2] == d3 );
BOOST_CHECK_EQUAL( objects[0], d );
BOOST_CHECK_EQUAL( objects[1], d2 );
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
// return 0...
VERIFY( from_nasal<int>(c, ret) == 3 )
BOOST_REQUIRE( !naGetError(c) ); // TODO real error check (this seems to
// always return 0...
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
// return 0...
VERIFY( from_nasal<std::string>(c, ret) == "generic-get" );
BOOST_REQUIRE( !naGetError(c) ); // TODO real error check (this seems to
// always return 0...
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" );
VERIFY( cc.getArg<std::string>(0) == "test-arg" );
VERIFY( cc.getArg<std::string>(10) == "" );
VERIFY( cc.isString(0) );
VERIFY( !cc.isNumeric(0) );
VERIFY( !cc.isVector(0) );
VERIFY( !cc.isHash(0) );
VERIFY( !cc.isGhost(0) );
VERIFY( cc.isNumeric(1) );
VERIFY( cc.isVector(2) );
VERIFY( cc.isHash(3) );
BOOST_CHECK_EQUAL( cc.requireArg<std::string>(0), "test-arg" );
BOOST_CHECK_EQUAL( cc.getArg<std::string>(0), "test-arg" );
BOOST_CHECK_EQUAL( cc.getArg<std::string>(10), "" );
BOOST_CHECK( cc.isString(0) );
BOOST_CHECK( !cc.isNumeric(0) );
BOOST_CHECK( !cc.isVector(0) );
BOOST_CHECK( !cc.isHash(0) );
BOOST_CHECK( !cc.isGhost(0) );
BOOST_CHECK( cc.isNumeric(1) );
BOOST_CHECK( cc.isVector(2) );
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" );
VERIFY( string.c_str() == std::string("Test") );
VERIFY( string.starts_with(string) );
VERIFY( string.starts_with(String(c, "T")) );
VERIFY( string.starts_with(String(c, "Te")) );
VERIFY( string.starts_with(String(c, "Tes")) );
VERIFY( string.starts_with(String(c, "Test")) );
VERIFY( !string.starts_with(String(c, "Test1")) );
VERIFY( !string.starts_with(String(c, "bb")) );
VERIFY( !string.starts_with(String(c, "bbasdasdafasd")) );
VERIFY( string.ends_with(String(c, "t")) );
VERIFY( string.ends_with(String(c, "st")) );
VERIFY( string.ends_with(String(c, "est")) );
VERIFY( string.ends_with(String(c, "Test")) );
VERIFY( !string.ends_with(String(c, "1Test")) );
VERIFY( !string.ends_with(String(c, "abc")) );
VERIFY( !string.ends_with(String(c, "estasdasd")) );
VERIFY( string.find('e') == 1 );
VERIFY( string.find('9') == String::npos );
VERIFY( string.find_first_of(String(c, "st")) == 2 );
VERIFY( string.find_first_of(String(c, "st"), 3) == 3 );
VERIFY( string.find_first_of(String(c, "xyz")) == String::npos );
VERIFY( string.find_first_not_of(String(c, "Tst")) == 1 );
VERIFY( string.find_first_not_of(String(c, "Tse"), 2) == 3 );
VERIFY( string.find_first_not_of(String(c, "abc")) == 0 );
VERIFY( string.find_first_not_of(String(c, "abc"), 20) == String::npos );
BOOST_CHECK_EQUAL( from_nasal<std::string>(c, string.get_naRef()), "Test" );
BOOST_CHECK_EQUAL( string.c_str(), std::string("Test") );
BOOST_CHECK( string.starts_with(string) );
BOOST_CHECK( string.starts_with(String(c, "T")) );
BOOST_CHECK( string.starts_with(String(c, "Te")) );
BOOST_CHECK( string.starts_with(String(c, "Tes")) );
BOOST_CHECK( string.starts_with(String(c, "Test")) );
BOOST_CHECK( !string.starts_with(String(c, "Test1")) );
BOOST_CHECK( !string.starts_with(String(c, "bb")) );
BOOST_CHECK( !string.starts_with(String(c, "bbasdasdafasd")) );
BOOST_CHECK( string.ends_with(String(c, "t")) );
BOOST_CHECK( string.ends_with(String(c, "st")) );
BOOST_CHECK( string.ends_with(String(c, "est")) );
BOOST_CHECK( string.ends_with(String(c, "Test")) );
BOOST_CHECK( !string.ends_with(String(c, "1Test")) );
BOOST_CHECK( !string.ends_with(String(c, "abc")) );
BOOST_CHECK( !string.ends_with(String(c, "estasdasd")) );
BOOST_CHECK_EQUAL( string.find('e'), 1 );
BOOST_CHECK_EQUAL( string.find('9'), String::npos );
BOOST_CHECK_EQUAL( string.find_first_of(String(c, "st")), 2 );
BOOST_CHECK_EQUAL( string.find_first_of(String(c, "st"), 3), 3 );
BOOST_CHECK_EQUAL( string.find_first_of(String(c, "xyz")), String::npos );
BOOST_CHECK_EQUAL( string.find_first_not_of(String(c, "Tst")), 1 );
BOOST_CHECK_EQUAL( string.find_first_not_of(String(c, "Tse"), 2), 3 );
BOOST_CHECK_EQUAL( string.find_first_not_of(String(c, "abc")), 0 );
BOOST_CHECK_EQUAL( string.find_first_not_of(String(c, "abc"), 20), String::npos );
naFreeContext(c);
return 0;
}

7
simgear/nasal/cppbind/cppbind_test_ghost.cxx
View File

@@ -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(!nasal::from_nasal<Derived*>(c, na_b1));
BOOST_CHECK_THROW(nasal::from_nasal<Base2*>(c, na_b1), nasal::bad_nasal_cast);
BOOST_CHECK_THROW(nasal::from_nasal<Derived*>(c, na_b1), nasal::bad_nasal_cast);
}
//------------------------------------------------------------------------------

5
simgear/nasal/cppbind/from_nasal.hxx
View File

@@ -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)
{