void ClassTestSuite::testMethodSearch()
{
Class test = Class::lookup("ClassTest::Test1");
auto retDouble = test.findAllMethods([&](const Method& m) {
return m.returnSpelling() == "double";
});
TS_ASSERT_EQUALS(retDouble.size(), 3);
auto retDoubleStrict = test.findAllMethods([&](const Method& m) {
return m.returnSpelling() == "double" && m.getClass() == test; //filter out inherited methods
});
TS_ASSERT_EQUALS(retDoubleStrict.size(), 2);
auto constMethods = test.findAllMethods([&](const Method& m) {
return m.isConst();
});
TS_ASSERT_EQUALS(constMethods.size(), 2);
Method m = test.findMethod([&](const Method& m) {
return m.name() == "method1";
});
TS_ASSERT(m.isValid());
TS_ASSERT(m.isConst());
TS_ASSERT_EQUALS(m.returnSpelling(), "std::string");
Method m30 = test.findMethod([&](const Method& m) {
return m.name() == "method30";
});
TS_ASSERT(!m30.isValid());
TS_ASSERT_THROWS_ANYTHING(m30.isConst());
}
void SmokeClassFiles::generateMethod(QTextStream& out, const QString& className, const QString& smokeClassName,
const Method& meth, int index, QSet<QString>& includes)
{
out << " ";
if ((meth.flags() & Method::Static) || meth.isConstructor())
out << "static ";
out << QString("void x_%1(Smoke::Stack x) {\n").arg(index);
out << " // " << meth.toString() << "\n";
out << " ";
if (meth.isConstructor()) {
out << smokeClassName << "* xret = new " << smokeClassName << "(";
} else {
const Function* func = Util::globalFunctionMap[&meth];
if (func)
includes.insert(func->fileName());
if (meth.type()->getClass())
includes.insert(meth.type()->getClass()->fileName());
if (meth.type()->isFunctionPointer() || meth.type()->isArray())
out << meth.type()->toString("xret") << " = ";
else if (meth.type() != Type::Void)
out << meth.type()->toString() << " xret = ";
if (!(meth.flags() & Method::Static)) {
if (meth.isConst()) {
out << "((const " << smokeClassName << "*)this)->";
} else {
out << "this->";
}
}
if (!(meth.flags() & Method::PureVirtual) && !func) {
// dynamic dispatch for virtuals
out << className << "::";
} else if (func) {
if (!func->nameSpace().isEmpty())
out << func->nameSpace() << "::";
}
out << meth.name() << "(";
}
for (int j = 0; j < meth.parameters().count(); j++) {
const Parameter& param = meth.parameters()[j];
if (param.type()->getClass())
includes.insert(param.type()->getClass()->fileName());
if (j > 0) out << ",";
QString field = Util::stackItemField(param.type());
QString typeName = param.type()->toString();
if (param.type()->isArray()) {
Type t = *param.type();
t.setPointerDepth(t.pointerDepth() + 1);
t.setIsRef(false);
typeName = t.toString();
out << '*';
} else if (field == "s_class" && (param.type()->pointerDepth() == 0 || param.type()->isRef()) && !param.type()->isFunctionPointer()) {
// references and classes are passed in s_class
typeName.append('*');
out << '*';
}
// casting to a reference doesn't make sense in this case
if (param.type()->isRef() && !param.type()->isFunctionPointer()) typeName.replace('&', "");
out << "(" << typeName << ")" << "x[" << j + 1 << "]." << field;
}
// if the method has any other default parameters, append them here as values, so
if (!meth.remainingDefaultValues().isEmpty()) {
const QStringList& defaultParams = meth.remainingDefaultValues();
if (meth.parameters().count() > 0)
out << "," ;
out << defaultParams.join(",");
}
out << ");\n";
if (meth.type() != Type::Void) {
out << " x[0]." << Util::stackItemField(meth.type()) << " = " << Util::assignmentString(meth.type(), "xret") << ";\n";
} else {
out << " (void)x; // noop (for compiler warning)\n";
}
out << " }\n";
// If the constructor was generated from another one with default parameteres, we don't need to explicitly create
// it here again. The x_* call will append the default parameters at the end and thus choose the right constructor.
if (meth.isConstructor() && meth.remainingDefaultValues().isEmpty()) {
out << " explicit " << smokeClassName << '(';
QStringList x_list;
for (int i = 0; i < meth.parameters().count(); i++) {
if (i > 0) out << ", ";
out << meth.parameters()[i].type()->toString() << " x" << QString::number(i + 1);
x_list << "x" + QString::number(i + 1);
}
out << ") : " << meth.getClass()->name() << '(' << x_list.join(", ") << ") {}\n";
}
}
void SmokeClassFiles::generateVirtualMethod(QTextStream& out, const Method& meth, QSet<QString>& includes)
{
QString x_params, x_list;
QString type = meth.type()->toString();
if (meth.type()->getClass())
includes.insert(meth.type()->getClass()->fileName());
out << " virtual " << type << " " << meth.name() << "(";
for (int i = 0; i < meth.parameters().count(); i++) {
if (i > 0) { out << ", "; x_list.append(", "); }
const Parameter& param = meth.parameters()[i];
if (param.type()->getClass())
includes.insert(param.type()->getClass()->fileName());
out << param.type()->toString() << " x" << i + 1;
x_params += QString(" x[%1].%2 = %3;\n")
.arg(QString::number(i + 1)).arg(Util::stackItemField(param.type()))
.arg(Util::assignmentString(param.type(), "x" + QString::number(i + 1)));
x_list += "x" + QString::number(i + 1);
}
out << ") ";
if (meth.isConst())
out << "const ";
if (meth.hasExceptionSpec()) {
out << "throw(";
for (int i = 0; i < meth.exceptionTypes().count(); i++) {
if (i > 0) out << ", ";
out << meth.exceptionTypes()[i].toString();
}
out << ") ";
}
out << "{\n";
out << QString(" Smoke::StackItem x[%1];\n").arg(meth.parameters().count() + 1);
out << x_params;
if (meth.flags() & Method::PureVirtual) {
out << QString(" this->_binding->callMethod(%1, (void*)this, x, true /*pure virtual*/);\n").arg(m_smokeData->methodIdx[&meth]);
if (meth.type() != Type::Void) {
QString field = Util::stackItemField(meth.type());
if (meth.type()->pointerDepth() == 0 && field == "s_class") {
QString tmpType = type;
if (meth.type()->isRef()) tmpType.replace('&', "");
tmpType.append('*');
out << " " << tmpType << " xptr = (" << tmpType << ")x[0].s_class;\n";
out << " " << type << " xret(*xptr);\n";
out << " delete xptr;\n";
out << " return xret;\n";
} else {
out << QString(" return (%1)x[0].%2;\n").arg(type, Util::stackItemField(meth.type()));
}
}
} else {
out << QString(" if (this->_binding->callMethod(%1, (void*)this, x)) ").arg(m_smokeData->methodIdx[&meth]);
if (meth.type() == Type::Void) {
out << "return;\n";
} else {
QString field = Util::stackItemField(meth.type());
if (meth.type()->pointerDepth() == 0 && field == "s_class") {
QString tmpType = type;
if (meth.type()->isRef()) tmpType.replace('&', "");
tmpType.append('*');
out << "{\n";
out << " " << tmpType << " xptr = (" << tmpType << ")x[0].s_class;\n";
out << " " << type << " xret(*xptr);\n";
out << " delete xptr;\n";
out << " return xret;\n";
out << " }\n";
} else {
out << QString("return (%1)x[0].%2;\n").arg(type, Util::stackItemField(meth.type()));
}
}
out << " ";
if (meth.type() != Type::Void)
out << "return ";
out << QString("this->%1::%2(%3);\n").arg(meth.getClass()->toString()).arg(meth.name()).arg(x_list);
}
out << " }\n";
}
QString SmokeClassFiles::generateMethodBody(const QString& indent, const QString& className, const QString& smokeClassName, const Method& meth,
int index, bool dynamicDispatch, QSet<QString>& includes)
{
QString methodBody;
QTextStream out(&methodBody);
out << indent;
if (meth.isConstructor()) {
out << smokeClassName << "* xret = new " << smokeClassName << "(";
} else {
const Function* func = Util::globalFunctionMap[&meth];
if (func)
includes.insert(func->fileName());
if (meth.type()->getClass())
includes.insert(meth.type()->getClass()->fileName());
if (meth.type()->isFunctionPointer() || meth.type()->isArray())
out << meth.type()->toString("xret") << " = ";
else if (meth.type() != Type::Void)
out << meth.type()->toString() << " xret = ";
if (!(meth.flags() & Method::Static)) {
if (meth.isConst()) {
out << "((const " << smokeClassName << "*)this)->";
} else {
out << "this->";
}
}
if (!dynamicDispatch && !func) {
// dynamic dispatch not wanted, call with 'this->Foo::method()'
out << className << "::";
} else if (func) {
if (!func->nameSpace().isEmpty())
out << func->nameSpace() << "::";
}
out << meth.name() << "(";
}
for (int j = 0; j < meth.parameters().count(); j++) {
const Parameter& param = meth.parameters()[j];
if (param.type()->getClass())
includes.insert(param.type()->getClass()->fileName());
if (j > 0) out << ",";
QString field = Util::stackItemField(param.type());
QString typeName = param.type()->toString();
if (param.type()->isArray()) {
Type t = *param.type();
t.setPointerDepth(t.pointerDepth() + 1);
t.setIsRef(false);
typeName = t.toString();
out << '*';
} else if (field == "s_class" && (param.type()->pointerDepth() == 0 || param.type()->isRef()) && !param.type()->isFunctionPointer()) {
// references and classes are passed in s_class
typeName.append('*');
out << '*';
}
// casting to a reference doesn't make sense in this case
if (param.type()->isRef() && !param.type()->isFunctionPointer()) typeName.replace('&', "");
out << "(" << typeName << ")" << "x[" << j + 1 << "]." << field;
}
// if the method has any other default parameters, append them here as values
if (!meth.remainingDefaultValues().isEmpty()) {
const QStringList& defaultParams = meth.remainingDefaultValues();
if (meth.parameters().count() > 0)
out << "," ;
out << defaultParams.join(",");
}
out << ");\n";
if (meth.type() != Type::Void) {
out << indent << "x[0]." << Util::stackItemField(meth.type()) << " = " << Util::assignmentString(meth.type(), "xret") << ";\n";
} else {
out << indent << "(void)x; // noop (for compiler warning)\n";
}
return methodBody;
}
void ClassTestSuite::testClass()
{
//Class test = ClassOf<Test1>();
Class test = Class::lookup("ClassTest::Test1");
TS_ASSERT_EQUALS(test.simpleName(), "Test1");
#ifndef NO_RTTI
TS_ASSERT(test.describes<ClassTest::Test1>())
Class test2 = Class::lookup(typeid(ClassTest::Test1));
TS_ASSERT_EQUALS(test2.simpleName(), "Test1");
TS_ASSERT_EQUALS(test, test2);
#endif
Class::ClassList superClasses = test.superclasses();
TS_ASSERT_EQUALS(superClasses.size(), 2);
Class base1;
Class base2;
TS_ASSERT_THROWS(base1.simpleName(), std::runtime_error); // uninitialized handle
for(const Class& c: superClasses) {
if (c.fullyQualifiedName() == "ClassTest::TestBase1") {
base1 = c;
} else if (c.fullyQualifiedName() == "ClassTest::TestBase2") {
base2 = c;
}
}
TS_ASSERT_EQUALS(base1.fullyQualifiedName(), "ClassTest::TestBase1");
TS_ASSERT_EQUALS(base1.simpleName(), "TestBase1");
TS_ASSERT_EQUALS(base2.fullyQualifiedName(), "ClassTest::TestBase2");
TS_ASSERT_EQUALS(base2.simpleName(), "TestBase2");
TS_ASSERT(inheritanceRelation(test, base1));
TS_ASSERT(inherits(test, base1));
TS_ASSERT(inheritedBy(base1, test));
TS_ASSERT(inheritanceRelation(test, base2));
TS_ASSERT(inherits(test, base2));
TS_ASSERT(inheritedBy(base2, test));
TS_ASSERT(!inheritanceRelation(base1, base2));
Class::ConstructorList base1Constructors = base1.constructors();
TS_ASSERT_EQUALS(base1.constructors().size(), 1);
Constructor base1Constructor = base1Constructors.front();
TS_ASSERT_EQUALS(base1Constructor.numberOfArguments(), 0);
TS_ASSERT_THROWS(base1Constructor.call(), std::runtime_error); // abstract class
Class::ConstructorList base2Constructors = base2.constructors();
TS_ASSERT_EQUALS(base2.constructors().size(), 1);
Constructor base2Constructor = base2Constructors.front();
TS_ASSERT_EQUALS(base2Constructor.numberOfArguments(), 0);
VariantValue b2Inst = base2Constructor.call();
TS_ASSERT(b2Inst.isValid());
TS_ASSERT_EQUALS(base2.attributes().size(), 0);
Class::MethodList base2Methods = base2.methods();
TS_ASSERT_EQUALS(base2Methods.size(), 1);
Method base2Method1 = base2Methods.front();
TS_ASSERT_EQUALS(base2Method1.name(), "base2Method1");
TS_ASSERT(base2Method1.isConst());
TS_ASSERT(!base2Method1.isVolatile());
TS_ASSERT(!base2Method1.isStatic());
TS_ASSERT_EQUALS(base2Method1.numberOfArguments(), 0);
TS_ASSERT_EQUALS(base2Method1.call(b2Inst).value<int>(), 6);
Class::ConstructorList testConstructors = test.constructors();
Class::AttributeList attributes = test.attributes();
TS_ASSERT_EQUALS(attributes.size(), 2);
Attribute attr = attributes.front();
WITH_RTTI(TS_ASSERT(attr.type() == typeid(int)));
TS_ASSERT_EQUALS(testConstructors.size(), 3);
Constructor defaultConstr;
Constructor intConstr;
TS_ASSERT_THROWS(defaultConstr.argumentSpellings(), std::runtime_error);
for (const Constructor& c: testConstructors) {
if (c.numberOfArguments() == 0) {
defaultConstr = c;
} else if (c.numberOfArguments() == 1 && c.argumentSpellings()[0] == "int"){
intConstr = c;
}
}
TS_ASSERT_EQUALS(defaultConstr.numberOfArguments(), 0);
TS_ASSERT_EQUALS(intConstr.numberOfArguments(), 1);
VariantValue testInst1 = defaultConstr.call();
TS_ASSERT(testInst1.isA<Test1>());
#ifndef NO_RTTI
Class test3 = Class::lookup(testInst1.typeId());
TS_ASSERT_EQUALS(test3.simpleName(), "Test1");
TS_ASSERT_EQUALS(test, test3);
#endif
TS_ASSERT_EQUALS(attr.get(testInst1).value<const int&>(), 3);
VariantValue testInst2 = intConstr.call(77);
TS_ASSERT(testInst2.isA<Test1>());
TS_ASSERT_EQUALS(attr.get(testInst2).value<const int&>(), 77);
Class::MethodList methods = test.methods();
TS_ASSERT_EQUALS(methods.size(), 9);
Method base1Method1;
Method method1;
Method method2;
Method staticMethod;
for (const Method& m: methods) {
if (m.name() == "base1Method1") {
base1Method1 = m;
} else if (m.name() == "base2Method1") {
base2Method1 = m;
} else if (m.name() == "method1") {
method1 = m;
} else if (m.name() == "method2") {
method2 = m;
} else if (m.name() == "staticMethod") {
staticMethod = m;
}
}
TS_ASSERT_EQUALS(base1Method1.name(), "base1Method1");
TS_ASSERT(!base1Method1.isConst());
TS_ASSERT(!base1Method1.isStatic());
TS_ASSERT(!base1Method1.isVolatile());
WITH_RTTI(TS_ASSERT(base1Method1.returnType() == typeid(int)));
TS_ASSERT_EQUALS(base1Method1.numberOfArguments(), 0);
TS_ASSERT_EQUALS(base1Method1.call(testInst2).value<int>(), 5);
TS_ASSERT_EQUALS(base2Method1.name(), "base2Method1");
TS_ASSERT(base2Method1.isConst());
TS_ASSERT(!base2Method1.isStatic());
TS_ASSERT(!base2Method1.isVolatile());
WITH_RTTI(TS_ASSERT(base2Method1.returnType() == typeid(int)));
TS_ASSERT_EQUALS(base2Method1.numberOfArguments(), 0);
TS_ASSERT_EQUALS(base2Method1.call(testInst2).value<int>(), 6);
TS_ASSERT_EQUALS(method2.name(), "method2");
TS_ASSERT(!method2.isConst());
TS_ASSERT(!method2.isStatic());
TS_ASSERT(!method2.isVolatile());
WITH_RTTI(TS_ASSERT(method2.returnType() == typeid(double)));
TS_ASSERT_EQUALS(method2.numberOfArguments(), 1);
WITH_RTTI(TS_ASSERT(*method2.argumentTypes()[0] == typeid(double)));
TS_ASSERT_EQUALS(method2.call(testInst2, 2).value<double>(), 6.28);
TS_ASSERT_EQUALS(staticMethod.name(), "staticMethod");
TS_ASSERT(!staticMethod.isConst());
TS_ASSERT(staticMethod.isStatic());
TS_ASSERT(!staticMethod.isVolatile());
WITH_RTTI(TS_ASSERT(staticMethod.returnType() == typeid(double)));
TS_ASSERT_EQUALS(staticMethod.numberOfArguments(), 0);
TS_ASSERT_EQUALS(staticMethod.call().value<double>(), 3.14);
ClassTest::Test1 t(666);
VariantValue inst3;
inst3.construct<ClassTest::TestBase1&>(t);
TS_ASSERT_THROWS_ANYTHING(method1.call(inst3).value<string>());
VariantValue inst4 = test.castUp(inst3, base1);
TS_ASSERT(inst4.isValid());
bool success = false;
ClassTest::Test1& derivedRef = inst4.convertTo<ClassTest::Test1&>(&success);
TS_ASSERT(success);
TS_ASSERT_EQUALS(derivedRef.attribute1, 666);
TS_ASSERT_EQUALS(method1.call(inst4).value<string>(), "this is a test");
Class test_3 = Class::lookup("ClassTest::Test3");
ClassTest::Test3 t2(666);
TS_ASSERT_EQUALS(t2.attribute1, 333);
TS_ASSERT_EQUALS(t2.attribute3, 666);
VariantValue inst5;
inst5.construct<ClassTest::TestBase1&>(t2);
VariantValue inst6 = test_3.castUp(inst5, base1);
TS_ASSERT(inst6.isValid());
success = false;
ClassTest::Test3& derivedRef2 = inst6.convertTo<ClassTest::Test3&>(&success);
TS_ASSERT(success);
TS_ASSERT_EQUALS(derivedRef2.attribute1, 333);
TS_ASSERT_EQUALS(derivedRef2.attribute3, 666);
t2.attribute1 = 787;
t2.attribute3 = 13;
TS_ASSERT_EQUALS(derivedRef2.attribute1, 787);
TS_ASSERT_EQUALS(derivedRef2.attribute3, 13);
ClassTest::Test1 t3(666);
VariantValue inst7;
inst7.construct<ClassTest::TestBase1&>(t3);
VariantValue inst8 = test_3.castUp(inst7, base1);
TS_ASSERT(!inst8.isValid());
Class test_2 = Class::lookup("ClassTest::Test2");
VariantValue inst9 = test_2.castUp(inst7, base1);
TS_ASSERT(!inst9.isValid());
}
void ClassTestSuite::testClass()
{
//Class test = ClassOf<Test1>();
Class test = Class::lookup("ClassTest::Test1");
TS_ASSERT_EQUALS(test.simpleName(), "Test1");
Class::ClassList superClasses = test.superclasses();
TS_ASSERT_EQUALS(superClasses.size(), 2);
Class base1;
Class base2;
TS_ASSERT_THROWS(base1.simpleName(), std::runtime_error); // uninitialized handle
for(const Class& c: superClasses) {
if (c.fullyQualifiedName() == "ClassTest::TestBase1") {
base1 = c;
} else if (c.fullyQualifiedName() == "ClassTest::TestBase2") {
base2 = c;
}
}
TS_ASSERT_EQUALS(base1.fullyQualifiedName(), "ClassTest::TestBase1");
TS_ASSERT_EQUALS(base1.simpleName(), "TestBase1");
TS_ASSERT_EQUALS(base2.fullyQualifiedName(), "ClassTest::TestBase2");
TS_ASSERT_EQUALS(base2.simpleName(), "TestBase2");
Class::ConstructorList base1Constructors = base1.constructors();
TS_ASSERT_EQUALS(base1.constructors().size(), 1);
Constructor base1Constructor = base1Constructors.front();
TS_ASSERT_EQUALS(base1Constructor.numberOfArguments(), 0);
TS_ASSERT_THROWS(base1Constructor.call(), std::runtime_error); // abstract class
Class::ConstructorList base2Constructors = base2.constructors();
TS_ASSERT_EQUALS(base2.constructors().size(), 1);
Constructor base2Constructor = base2Constructors.front();
TS_ASSERT_EQUALS(base2Constructor.numberOfArguments(), 0);
VariantValue b2Inst = base2Constructor.call();
TS_ASSERT(b2Inst.isValid());
TS_ASSERT_EQUALS(base2.attributes().size(), 0);
Class::MethodList base2Methods = base2.methods();
TS_ASSERT_EQUALS(base2Methods.size(), 1);
Method base2Method1 = base2Methods.front();
TS_ASSERT_EQUALS(base2Method1.name(), "base2Method1");
TS_ASSERT(base2Method1.isConst());
TS_ASSERT(!base2Method1.isVolatile());
TS_ASSERT(!base2Method1.isStatic());
TS_ASSERT_EQUALS(base2Method1.numberOfArguments(), 0);
TS_ASSERT_EQUALS(base2Method1.call(b2Inst).value<int>(), 6);
Class::ConstructorList testConstructors = test.constructors();
Class::AttributeList attributes = test.attributes();
TS_ASSERT_EQUALS(attributes.size(), 2);
Attribute attr = attributes.front();
WITH_RTTI(TS_ASSERT(attr.type() == typeid(int)));
TS_ASSERT_EQUALS(testConstructors.size(), 3);
Constructor defaultConstr;
Constructor intConstr;
TS_ASSERT_THROWS(defaultConstr.argumentSpellings(), std::runtime_error);
for (const Constructor& c: testConstructors) {
if (c.numberOfArguments() == 0) {
defaultConstr = c;
} else if (c.numberOfArguments() == 1 && c.argumentSpellings()[0] == "int") {
intConstr = c;
}
}
TS_ASSERT_EQUALS(defaultConstr.numberOfArguments(), 0);
TS_ASSERT_EQUALS(intConstr.numberOfArguments(), 1);
VariantValue testInst1 = defaultConstr.call();
TS_ASSERT(testInst1.isA<Test1>());
TS_ASSERT_EQUALS(attr.get(testInst1).value<int>(), 3);
VariantValue testInst2 = intConstr.call(77);
TS_ASSERT(testInst2.isA<Test1>());
TS_ASSERT_EQUALS(attr.get(testInst2).value<int>(), 77);
Class::MethodList methods = test.methods();
TS_ASSERT_EQUALS(methods.size(), 7);
Method base1Method1;
Method method1;
Method method2;
Method staticMethod;
for (const Method& m: methods) {
if (m.name() == "base1Method1") {
base1Method1 = m;
} else if (m.name() == "base2Method1") {
base2Method1 = m;
} else if (m.name() == "method1") {
method1 = m;
} else if (m.name() == "method2") {
method2 = m;
} else if (m.name() == "staticMethod") {
staticMethod = m;
}
}
TS_ASSERT_EQUALS(base1Method1.name(), "base1Method1");
TS_ASSERT(!base1Method1.isConst());
TS_ASSERT(!base1Method1.isStatic());
TS_ASSERT(!base1Method1.isVolatile());
WITH_RTTI(TS_ASSERT(base1Method1.returnType() == typeid(int)));
TS_ASSERT_EQUALS(base1Method1.numberOfArguments(), 0);
TS_ASSERT_EQUALS(base1Method1.call(testInst2).value<int>(), 5);
TS_ASSERT_EQUALS(base2Method1.name(), "base2Method1");
TS_ASSERT(base2Method1.isConst());
TS_ASSERT(!base2Method1.isStatic());
TS_ASSERT(!base2Method1.isVolatile());
WITH_RTTI(TS_ASSERT(base2Method1.returnType() == typeid(int)));
TS_ASSERT_EQUALS(base2Method1.numberOfArguments(), 0);
TS_ASSERT_EQUALS(base2Method1.call(testInst2).value<int>(), 6);
TS_ASSERT_EQUALS(method2.name(), "method2");
TS_ASSERT(!method2.isConst());
TS_ASSERT(!method2.isStatic());
TS_ASSERT(!method2.isVolatile());
WITH_RTTI(TS_ASSERT(method2.returnType() == typeid(double)));
TS_ASSERT_EQUALS(method2.numberOfArguments(), 1);
WITH_RTTI(TS_ASSERT(*method2.argumentTypes()[0] == typeid(double)));
TS_ASSERT_EQUALS(method2.call(testInst2, 2).value<double>(), 6.28);
TS_ASSERT_EQUALS(staticMethod.name(), "staticMethod");
TS_ASSERT(!staticMethod.isConst());
TS_ASSERT(staticMethod.isStatic());
TS_ASSERT(!staticMethod.isVolatile());
WITH_RTTI(TS_ASSERT(staticMethod.returnType() == typeid(double)));
TS_ASSERT_EQUALS(staticMethod.numberOfArguments(), 0);
TS_ASSERT_EQUALS(staticMethod.call().value<double>(), 3.14);
}
