Added support for add-function tag into typesystem.

2 files changed, 82 insertions, 15 deletions

diff --git a/tests/testaddfunction.cpp b/tests/testaddfunction.cpp
index a47cd28af..d36411cc8 100644
--- a/tests/testaddfunction.cpp
+++ b/tests/testaddfunction.cpp
@@ -28,53 +28,118 @@
 
 void TestAddFunction::testParsingFuncNameAndConstness()
 {
+    // generic test...
     const char sig1[] = "func(type1, const type2, const type3* const)";
     AddedFunction f1(sig1, "void");
     QCOMPARE(f1.name(), QString("func"));
+    QCOMPARE(f1.arguments().count(), 3);
     AddedFunction::TypeInfo retval = f1.returnType();
     QCOMPARE(retval.name, QString("void"));
     QCOMPARE(retval.indirections, 0);
-    QCOMPARE(retval.isConst, false);
-    QCOMPARE(retval.isRef, false);
+    QCOMPARE(retval.isConstant, false);
+    QCOMPARE(retval.isReference, false);
 
+    // test with a ugly template as argument and other ugly stuff
     const char sig2[] = "    _fu__nc_       (  type1, const type2, const Abc<int& , C<char*> *   >  * *, const type3* const    )   const ";
     AddedFunction f2(sig2, "const Abc<int& , C<char*> *   >  * *");
     QCOMPARE(f2.name(), QString("_fu__nc_"));
+    QList< AddedFunction::TypeInfo > args = f2.arguments();
+    QCOMPARE(args.count(), 4);
     retval = f2.returnType();
     QCOMPARE(retval.name, QString("Abc<int& , C<char*> *   >"));
     QCOMPARE(retval.indirections, 2);
-    QCOMPARE(retval.isConst, true);
-    QCOMPARE(retval.isRef, false);
-    QList< AddedFunction::TypeInfo > args = f2.arguments();
-    QCOMPARE(args.count(), 4);
+    QCOMPARE(retval.isConstant, true);
+    QCOMPARE(retval.isReference, false);
     retval = args[2];
     QCOMPARE(retval.name, QString("Abc<int& , C<char*> *   >"));
     QCOMPARE(retval.indirections, 2);
-    QCOMPARE(retval.isConst, true);
-    QCOMPARE(retval.isRef, false);
-
+    QCOMPARE(retval.isConstant, true);
+    QCOMPARE(retval.isReference, false);
 
+    // function with no args.
+    const char sig3[] = "func()";
+    AddedFunction f3(sig3, "void");
+    QCOMPARE(f3.name(), QString("func"));
+    QCOMPARE(f3.arguments().count(), 0);
 }
 
 void TestAddFunction::testAddFunction()
 {
-#if 0
-    const char cppCode[] = "struct A { void a(); };";
+    const char cppCode[] = "struct B {}; struct A { void a(int); };";
     const char xmlCode[] = "\
-    <typesystem package=\"Foo\"> \
-        <value-type name='A'> \
-            <add-function signature='b(int, float)' return-type='int' acess='protected'>\
+    <typesystem package=\"Foo\">\
+        <primitive-type name='int' />\
+        <primitive-type name='float' />\
+        <value-type name='B' />\
+        <value-type name='A'>\
+            <add-function signature='b(int, float = 4.6, const B&amp;)' return-type='int' access='protected'>\
             </add-function>\
         </value-type>\
     </typesystem>";
     TestUtil t(cppCode, xmlCode);
+    TypeDatabase* typeDb = TypeDatabase::instance();
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QCOMPARE(classA->functions().count(), 3); // default ctor, func a() and the added function
+
+    AbstractMetaFunction* addedFunc = classA->functions().last();
+    QCOMPARE(addedFunc->visibility(), uint(AbstractMetaFunction::Protected));
+    QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::UserAddedFunction);
+    QCOMPARE(addedFunc->ownerClass(), classA);
+    QCOMPARE(addedFunc->implementingClass(), classA);
+    QCOMPARE(addedFunc->declaringClass(), classA);
+    AbstractMetaType* returnType = addedFunc->type();
+    QCOMPARE(returnType->typeEntry(), typeDb->findPrimitiveType("int"));
+    AbstractMetaArgumentList args = addedFunc->arguments();
+    QCOMPARE(args.count(), 3);
+    QCOMPARE(args[0]->type()->typeEntry(), returnType->typeEntry());
+    QCOMPARE(args[1]->defaultValueExpression(), QString("4.6"));
+    QCOMPARE(args[2]->type()->typeEntry(), typeDb->findType("B"));
+}
+
+void TestAddFunction::testAddFunctionTagDefaultValues()
+{
+    const char cppCode[] = "struct A {};";
+    const char xmlCode[] = "\
+    <typesystem package=\"Foo\">\
+        <value-type name='A'>\
+            <add-function signature='func()' />\
+        </value-type>\
+    </typesystem>";
+    TestUtil t(cppCode, xmlCode, false);
     AbstractMetaClassList classes = t.builder()->classes();
     AbstractMetaClass* classA = classes.findClass("A");
     QVERIFY(classA);
     QCOMPARE(classA->functions().count(), 2); // default ctor and the added function
-#endif
+    AbstractMetaFunction* addedFunc = classA->functions().last();
+    QCOMPARE(addedFunc->visibility(), uint(AbstractMetaFunction::Public));
+    QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::UserAddedFunction);
+    QVERIFY(!addedFunc->type());
+}
+
+
+void TestAddFunction::testAddFunctionCodeSnippets()
+{
+    const char cppCode[] = "struct A {};";
+    const char xmlCode[] = "\
+    <typesystem package=\"Foo\">\
+        <value-type name='A'>\
+            <add-function signature='func()'>\
+                <inject-code class='target' position='end'>Hi!, I am the code.</inject-code>\
+            </add-function>\
+        </value-type>\
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode, false);
+    AbstractMetaClassList classes = t.builder()->classes();
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    AbstractMetaFunction* addedFunc = classA->functions().last();
+    QVERIFY(addedFunc->hasInjectedCode());
 }
 
+
 QTEST_APPLESS_MAIN(TestAddFunction)
 
 #include "testaddfunction.moc"
diff --git a/tests/testaddfunction.h b/tests/testaddfunction.h
index 7fe07d6a4..45a562d4b 100644
--- a/tests/testaddfunction.h
+++ b/tests/testaddfunction.h
@@ -31,6 +31,8 @@ class TestAddFunction : public QObject
 private slots:
     void testParsingFuncNameAndConstness();
     void testAddFunction();
+    void testAddFunctionTagDefaultValues();
+    void testAddFunctionCodeSnippets();
 };
 
 #endif
\ No newline at end of file