12345qiupeng
/
gtsam
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

test virtual, cleaned up other test

release/4.3a0
dellaert 2014-12-19 15:40:21 +01:00
parent aaba18c61d
commit 9f2e6562c2
1 changed files with 51 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

87
wrap/tests/testClass.cpp
View File

@ -160,7 +160,6 @@ TEST( Class, Grammar ) {
EXPECT_LONGS_EQUAL(ReturnType::EIGEN, rv4.type1.category); EXPECT_LONGS_EQUAL(ReturnType::EIGEN, rv4.type1.category);
} }
//****************************************************************************** //******************************************************************************
TEST( Class, TemplateSubstition ) { TEST( Class, TemplateSubstition ) {
@ -171,10 +170,10 @@ TEST( Class, TemplateSubstition ) {
Template t; Template t;
ClassGrammar g(cls, t); ClassGrammar g(cls, t);
string markup( string markup(string("template<T = {void, double, Matrix, Point3}>"
string("template<T = {void, double, Matrix, Point3}> class Point2 { \n") "class Point2 {"
+ string(" T myMethod(const T& t) const; \n") " T myMethod(const T& t) const;"
+ string("};")); "};"));
EXPECT(parse(markup.c_str(), g, space_p).full); EXPECT(parse(markup.c_str(), g, space_p).full);
@ -190,58 +189,74 @@ TEST( Class, TemplateSubstition ) {
EXPECT(assert_equal("T", rv2.type1.name())); EXPECT(assert_equal("T", rv2.type1.name()));
EXPECT_LONGS_EQUAL(ReturnType::CLASS, rv2.type1.category); EXPECT_LONGS_EQUAL(ReturnType::CLASS, rv2.type1.category);
// Generate some expected values for qualified types
Qualified q_void("void", Qualified::VOID);
Qualified q_double("double", Qualified::BASIS);
Qualified q_Matrix("Matrix", Qualified::EIGEN);
Qualified q_Point3("Point3", Qualified::CLASS);
EXPECT_LONGS_EQUAL(4, t.nrValues()); EXPECT_LONGS_EQUAL(4, t.nrValues());
EXPECT(t.argName()=="T"); EXPECT(t.argName()=="T");
EXPECT(t[0]==Qualified("void",Qualified::VOID)); EXPECT(t[0]==q_void);
EXPECT(t[1]==Qualified("double",Qualified::BASIS)); EXPECT(t[1]==q_double);
EXPECT(t[2]==Qualified("Matrix",Qualified::EIGEN)); EXPECT(t[2]==q_Matrix);
EXPECT(t[3]==Qualified("Point3",Qualified::CLASS)); EXPECT(t[3]==q_Point3);
vector<Class> classes = cls.expandTemplate(t.argName(), vector<Class> classes = cls.expandTemplate(t.argName(), t.argValues());
t.argValues());
// check the number of new classes is four // check the number of new classes is four
EXPECT_LONGS_EQUAL(4, classes.size()); EXPECT_LONGS_EQUAL(4, classes.size());
// check return types // check return types
EXPECT(classes[0].method("myMethod").returnValue(0).type1 == Qualified("void",Qualified::VOID)); EXPECT( classes[0].method("myMethod").returnValue(0).type1 == q_void);
EXPECT(classes[1].method("myMethod").returnValue(0).type1 == Qualified("double",Qualified::BASIS)); EXPECT( classes[1].method("myMethod").returnValue(0).type1 == q_double);
EXPECT(classes[2].method("myMethod").returnValue(0).type1 == Qualified("Matrix",Qualified::EIGEN)); EXPECT( classes[2].method("myMethod").returnValue(0).type1 == q_Matrix);
EXPECT(classes[3].method("myMethod").returnValue(0).type1 == Qualified("Point3",Qualified::CLASS)); EXPECT( classes[3].method("myMethod").returnValue(0).type1 == q_Point3);
// check the argument types // check the argument types
EXPECT(classes[0].method("myMethod").argumentList(0)[0].type == Qualified("void",Qualified::VOID)); EXPECT( classes[0].method("myMethod").argumentList(0)[0].type == q_void);
EXPECT(classes[1].method("myMethod").argumentList(0)[0].type == Qualified("double",Qualified::BASIS)); EXPECT( classes[1].method("myMethod").argumentList(0)[0].type == q_double);
EXPECT(classes[2].method("myMethod").argumentList(0)[0].type == Qualified("Matrix",Qualified::EIGEN)); EXPECT( classes[2].method("myMethod").argumentList(0)[0].type == q_Matrix);
EXPECT(classes[3].method("myMethod").argumentList(0)[0].type == Qualified("Point3",Qualified::CLASS)); EXPECT( classes[3].method("myMethod").argumentList(0)[0].type == q_Point3);
} }
//******************************************************************************
TEST(Class, Template) { TEST(Class, Template) {
using classic::space_p;
using classic::space_p; // Create type grammar that will place result in cls
Class cls;
Template t;
ClassGrammar g(cls, t);
// Create type grammar that will place result in cls string markup(
Class cls; string(
Template t; "template<T = {Vector, Matrix}>"
ClassGrammar g(cls, t); " virtual class PriorFactor : gtsam::NoiseModelFactor {"
" PriorFactor(size_t key, const T& prior, const gtsam::noiseModel::Base* noiseModel); "
" T prior() const; "
" void serialize() const; "
"};"));
string markup( EXPECT(parse(markup.c_str(), g, space_p).full);
string("template<T = {Vector, Matrix}>"
" virtual class PriorFactor : gtsam::NoiseModelFactor {"
" PriorFactor(size_t key, const T& prior, const gtsam::noiseModel::Base* noiseModel); "
" T prior() const; "
" void serialize() const; "
"};" ));
EXPECT(parse(markup.c_str(), g, space_p).full);
} }
/* ************************************************************************* */ //******************************************************************************
TEST( Class, Virtualness ) {
using classic::space_p;
Class cls;
Template t;
ClassGrammar g(cls, t);
string markup("virtual class Point3 {};");
EXPECT(parse(markup.c_str(), g, space_p).full);
EXPECT(cls.isVirtual);
}
//******************************************************************************
int main() { int main() {
TestResult tr; TestResult tr;
return TestRegistry::runAllTests(tr); return TestRegistry::runAllTests(tr);
} }
/* ************************************************************************* */ //******************************************************************************