147 lines
4.5 KiB
C++
147 lines
4.5 KiB
C++
/* ----------------------------------------------------------------------------
|
|
|
|
* GTSAM Copyright 2010, Georgia Tech Research Corporation,
|
|
* Atlanta, Georgia 30332-0415
|
|
* All Rights Reserved
|
|
* Authors: Frank Dellaert, et al. (see THANKS for the full author list)
|
|
|
|
* See LICENSE for the license information
|
|
|
|
* -------------------------------------------------------------------------- */
|
|
|
|
/**
|
|
* @file testMethod.cpp
|
|
* @brief Unit test for Method class
|
|
* @author Frank Dellaert
|
|
* @date Nov 12, 2014
|
|
**/
|
|
|
|
#include <wrap/Method.h>
|
|
#include <CppUnitLite/TestHarness.h>
|
|
#include <iostream>
|
|
|
|
using namespace std;
|
|
using namespace wrap;
|
|
|
|
/* ************************************************************************* */
|
|
// Constructor
|
|
TEST( Method, Constructor ) {
|
|
Method method;
|
|
}
|
|
|
|
/* ************************************************************************* */
|
|
// addOverload
|
|
TEST( Method, addOverload ) {
|
|
Method method;
|
|
ArgumentList args;
|
|
bool is_const = true;
|
|
const ReturnValue retVal1(ReturnType("return_type1"));
|
|
method.addOverload("myName", args, retVal1, is_const);
|
|
const ReturnValue retVal2(ReturnType("return_type2"));
|
|
method.addOverload("myName", args, retVal2, is_const);
|
|
EXPECT_LONGS_EQUAL(2, method.nrOverloads());
|
|
}
|
|
|
|
// http://boost-spirit.com/distrib/spirit_1_8_2/libs/spirit/doc/grammar.html
|
|
struct method_grammar: public classic::grammar<method_grammar> {
|
|
|
|
wrap::Method& result_; ///< successful parse will be placed in here
|
|
|
|
ArgumentList args;
|
|
Argument arg0, arg;
|
|
TypeGrammar argument_type_g;
|
|
|
|
ReturnType retType0, retType;
|
|
TypeGrammar returntype_g;
|
|
|
|
ReturnValue retVal0, retVal;
|
|
|
|
/// Construct type grammar and specify where result is placed
|
|
method_grammar(wrap::Method& result) :
|
|
result_(result), argument_type_g(arg.type), returntype_g(retType) {
|
|
}
|
|
|
|
/// Definition of type grammar
|
|
template<typename ScannerT>
|
|
struct definition: basic_rules<ScannerT> {
|
|
|
|
typedef classic::rule<ScannerT> Rule;
|
|
|
|
Rule templateArgValue_p, templateArgValues_p, argument_p, argumentList_p,
|
|
returnType1_p, returnType2_p, pair_p, returnValue_p, methodName_p,
|
|
method_p;
|
|
|
|
definition(method_grammar const& self) {
|
|
|
|
using namespace wrap;
|
|
using namespace classic;
|
|
|
|
// Rule templateArgValue_p = type_grammar(self.templateArgValue);
|
|
//
|
|
// // template<CALIBRATION = {gtsam::Cal3DS2}>
|
|
// Rule templateArgValues_p = (str_p("template") >> '<' >> name_p >> '='
|
|
// >> '{' >> !(templateArgValue_p >> *(',' >> templateArgValue_p)) >> '}'
|
|
// >> '>');
|
|
//
|
|
// NOTE: allows for pointers to all types
|
|
// Slightly more permissive than before on basis/eigen type qualification
|
|
argument_p = //
|
|
!str_p("const")[assign_a(self.arg.is_const, true)] //
|
|
>> self.argument_type_g //
|
|
>> (!ch_p('&')[assign_a(self.arg.is_ref, true)]
|
|
| !ch_p('*')[assign_a(self.arg.is_ptr, true)]) //
|
|
[push_back_a(self.args, self.arg)] //
|
|
[assign_a(self.arg, self.arg0)];
|
|
|
|
argumentList_p = !argument_p >> *(',' >> argument_p);
|
|
//
|
|
returnType1_p = self.returntype_g //
|
|
[assign_a(self.retVal.type1, retType)] //
|
|
[assign_a(self.retType, self.retType0)];
|
|
|
|
returnType2_p = self.returntype_g //
|
|
[assign_a(self.retVal.type2, retType)] //
|
|
[assign_a(self.retType, self.retType0)];
|
|
|
|
pair_p = (str_p("pair") >> '<' >> returnType1_p >> ',' >> returnType2_p
|
|
>> '>')[assign_a(self.retVal.isPair, true)];
|
|
|
|
returnValue_p = pair_p | returnType1_p;
|
|
|
|
methodName_p = lexeme_d[(upper_p | lower_p) >> *(alnum_p | '_')];
|
|
|
|
// gtsam::Values retract(const gtsam::VectorValues& delta) const;
|
|
method_p =
|
|
// !templateArgValues_p >>
|
|
(returnValue_p >> methodName_p >> '(' >> argumentList_p >> ')'
|
|
>> !str_p("const") >> ';' >> *basic_rules<ScannerT>::comments_p);
|
|
}
|
|
|
|
Rule const& start() const {
|
|
return method_p;
|
|
}
|
|
|
|
};
|
|
};
|
|
// method_grammar
|
|
|
|
//******************************************************************************
|
|
TEST( Method, grammar ) {
|
|
|
|
using classic::space_p;
|
|
|
|
// Create type grammar that will place result in actual
|
|
Method actual;
|
|
method_grammar method_g(actual);
|
|
|
|
// a class type with namespaces
|
|
EXPECT(parse("double x() const;", method_g, space_p).full);
|
|
}
|
|
|
|
/* ************************************************************************* */
|
|
int main() {
|
|
TestResult tr;
|
|
return TestRegistry::runAllTests(tr);
|
|
}
|
|
/* ************************************************************************* */
|