void TestAbstractMetaType::testCharType()
{
const char* cppCode ="char justAtest(); class A {};";
const char* xmlCode = "<typesystem package=\"Foo\">\
<primitive-type name='char'/>\
<value-type name='A' />\
<function signature='justAtest()' />\
</typesystem>";
TestUtil t(cppCode, xmlCode);
AbstractMetaClassList classes = t.builder()->classes();
QCOMPARE(classes.size(), 1);
QCOMPARE(classes.first()->package(), QString("Foo"));
AbstractMetaFunctionList functions = t.builder()->globalFunctions();
QCOMPARE(functions.size(), 1);
AbstractMetaFunction* func = functions.first();
AbstractMetaType* rtype = func->type();
// Test properties of const char*
QVERIFY(rtype);
QCOMPARE(rtype->package(), QString("Foo"));
QCOMPARE(rtype->name(), QString("char"));
QVERIFY(!rtype->isConstant());
QVERIFY(!rtype->isArray());
QVERIFY(!rtype->isContainer());
QVERIFY(!rtype->isObject());
QVERIFY(rtype->isPrimitive());
QVERIFY(!rtype->isNativePointer());
QVERIFY(!rtype->isQObject());
QVERIFY(!rtype->isReference());
QVERIFY(!rtype->isValue());
QVERIFY(!rtype->isValuePointer());
}
void TestTypeRevision::testRevisionAttr()
{
const char* cppCode = "class Rev_0 {};"
"class Rev_1 {};"
"class Rev_2 { public: enum Rev_3 { X }; enum Rev_5 { Y }; };";
const char* xmlCode = "<typesystem package=\"Foo\">"
"<value-type name=\"Rev_0\"/>"
"<value-type name=\"Rev_1\" revision=\"1\"/>"
"<object-type name=\"Rev_2\" revision=\"2\">"
" <enum-type name=\"Rev_3\" revision=\"3\" flags=\"Flag_4\" flags-revision=\"4\" />"
" <enum-type name=\"Rev_5\" revision=\"5\" flags=\"Flag_5\" />"
"</object-type>"
"</typesystem>";
TestUtil t(cppCode, xmlCode);
AbstractMetaClassList classes = t.builder()->classes();
AbstractMetaClass* rev0 = classes.findClass("Rev_0");
QCOMPARE(getTypeRevision(rev0->typeEntry()), 0);
AbstractMetaClass* rev1 = classes.findClass("Rev_1");
QCOMPARE(getTypeRevision(rev1->typeEntry()), 1);
AbstractMetaClass* rev2 = classes.findClass("Rev_2");
QCOMPARE(getTypeRevision(rev2->typeEntry()), 2);
AbstractMetaEnum* rev3 = rev2->findEnum("Rev_3");
QCOMPARE(getTypeRevision(rev3->typeEntry()), 3);
FlagsTypeEntry* rev4 = rev3->typeEntry()->flags();
QCOMPARE(getTypeRevision(rev4), 4);
AbstractMetaEnum* rev5 = rev2->findEnum("Rev_5");
QCOMPARE(getTypeRevision(rev5->typeEntry()), 5);
QCOMPARE(getTypeRevision(rev5->typeEntry()->flags()), 5);
}
void TestValueTypeDefaultCtorTag::testValueTypeDefaultCtorTagArgument()
{
const char* cppCode ="\
struct A {\
A(int,int);\
};\
struct B {};\
";
const char* xmlCode = "\
<typesystem package='Foo'>\
<primitive-type name='int' />\
<value-type name='A' default-constructor='A(0, 0)' />\
<value-type name='B' />\
</typesystem>";
TestUtil t(cppCode, xmlCode, false);
AbstractMetaClassList classes = t.builder()->classes();
AbstractMetaClass* classA = classes.findClass("A");
QVERIFY(classA);
QVERIFY(classA->typeEntry()->hasDefaultConstructor());
QCOMPARE(classA->typeEntry()->defaultConstructor(), QString("A(0, 0)"));
AbstractMetaClass* classB = classes.findClass("B");
QVERIFY(classB);
QVERIFY(!classB->typeEntry()->hasDefaultConstructor());
}
void TestAbstractMetaType::testApiVersionNotSupported()
{
const char* cppCode ="class object {};";
const char* xmlCode = "<typesystem package='Foo'>\
<value-type name='object' since='0.1'/>\
</typesystem>";
TestUtil t(cppCode, xmlCode, true, "0.1");
AbstractMetaClassList classes = t.builder()->classes();
QCOMPARE(classes.size(), 1);
}
void TestAbstractMetaType::testTypedef()
{
const char* cppCode ="\
struct A {\
void someMethod();\
};\
typedef A B;\
typedef B C;";
const char* xmlCode = "<typesystem package=\"Foo\">\
<value-type name='C' />\
</typesystem>";
TestUtil t(cppCode, xmlCode);
AbstractMetaClassList classes = t.builder()->classes();
QCOMPARE(classes.size(), 1);
AbstractMetaClass* c = classes.findClass("C");
QVERIFY(c);
QVERIFY(c->isTypeAlias());
}
void TestAbstractMetaType::testApiVersionSupported()
{
const char* cppCode ="class foo {}; class foo2 {};\
void justAtest(); void justAtest3();";
const char* xmlCode = "<typesystem package='Foo'>\
<value-type name='foo' since='0.1'/>\
<value-type name='foo2' since='1.0'/>\
<value-type name='foo3' since='1.1'/>\
<function signature='justAtest()' since='0.1'/>\
<function signature='justAtest2()' since='1.1'/>\
<function signature='justAtest3()'/>\
</typesystem>";
TestUtil t(cppCode, xmlCode, false, "1.0");
AbstractMetaClassList classes = t.builder()->classes();
QCOMPARE(classes.size(), 2);
AbstractMetaFunctionList functions = t.builder()->globalFunctions();
QCOMPARE(functions.size(), 2);
}
void TestPrimitiveTypeTag::testPrimitiveTypeDefaultConstructor()
{
const char* cppCode ="\
struct A {};\
struct B {};\
";
const char* xmlCode = "\
<typesystem package=\"Foo\"> \
<primitive-type name='A' default-constructor='A()'/> \
<object-type name='B' /> \
</typesystem>";
TestUtil t(cppCode, xmlCode, false);
AbstractMetaClassList classes = t.builder()->classes();
QCOMPARE(classes.count(), 1);
AbstractMetaClass* classB = classes.findClass("B");
QVERIFY(classB);
PrimitiveTypeEntry* typeEntry = TypeDatabase::instance()->findPrimitiveType("A");
QVERIFY(typeEntry);
QVERIFY(typeEntry->hasDefaultConstructor());
QCOMPARE(typeEntry->defaultConstructor(), QString("A()"));
}
void ClassListGenerator::generate()
{
QFile f(fileName());
if (f.open(QFile::WriteOnly)) {
QTextStream s(&f);
s << "/****************************************************************************" << endl
<< "**" << endl
<< "** This is a generated file, please don't touch." << endl
<< "**" << endl
<< "****************************************************************************/" << endl << endl;
s << "/*!" << endl
<< "\\page qtjambi-classes.html" << endl << endl
<< "\\title Qt Jambi's classes" << endl << endl
<< "This is a list of all Qt Jambi classes." << endl << endl
<< "\\table 100%" << endl;
AbstractMetaClassList classes = Generator::classes();
qSort(classes.begin(), classes.end(), class_sorter);
int numColumns = 4;
int numRows = (classes.size() + numColumns - 1) / numColumns;
for (int i = 0; i < numRows; ++i) {
s << endl << "\\row ";
for (int j=0; j<numColumns; ++j) {
if (classes.value(i + j * numRows)) {
s << "\\o \\l{" << classes.value(i + j * numRows)->qualifiedCppName()
<< "}{" << classes.value(i + j * numRows)->name() << "} ";
}
}
}
s << endl << "\\endtable" << endl
<< "*/" << endl;
}
}
template<typename T>\
class A {};\
\
class B {};\
typedef A<B> C;\
\
void func(C c);\
";
const char* xmlCode = "<typesystem package=\"Foo\">\
<container-type name='A' type='list'/>\
<value-type name='B' />\
<function signature='func(A<B>)' />\
</typesystem>";
TestUtil t(cppCode, xmlCode);
AbstractMetaClassList classes = t.builder()->classes();
QCOMPARE(classes.size(), 1);
AbstractMetaFunctionList functions = t.builder()->globalFunctions();
QCOMPARE(functions.count(), 1);
AbstractMetaFunction* function = functions.first();
AbstractMetaArgumentList args = function->arguments();
QCOMPARE(args.count(), 1);
AbstractMetaArgument* arg = args.first();
AbstractMetaType* metaType = arg->type();
QCOMPARE(metaType->cppSignature(), QString("A<B >"));
}
void TestAbstractMetaType::testObjectTypeUsedAsValue()
{
const char* cppCode ="\
void TestInsertTemplate::testInsertTemplateOnClassInjectCode()
{
const char* cppCode ="struct A{};";
const char* xmlCode = "\
<typesystem package='Foo'>\
<template name='code_template'>\
code template content\
</template>\
<value-type name='A'>\
<inject-code class='native'>\
<insert-template name='code_template'/>\
</inject-code>\
</value-type>\
</typesystem>";
TestUtil t(cppCode, xmlCode, false);
AbstractMetaClassList classes = t.builder()->classes();
QCOMPARE(classes.count(), 1);
AbstractMetaClass* classA = classes.findClass("A");
QVERIFY(classA);
QCOMPARE(classA->typeEntry()->codeSnips().count(), 1);
QString code = classA->typeEntry()->codeSnips().first().code();
QVERIFY(code.contains("code template content"));
}
void TestInsertTemplate::testInsertTemplateOnModuleInjectCode()
{
const char* cppCode ="";
const char* xmlCode = "\
<typesystem package='Foo'>\
<template name='code_template'>\
code template content\
