Adds many tests regarding default copy constructors.

Also updated other tests dealing with constructor counting.

Reviewed by Hugo Parente <hugo.lima@openbossa.org>
Reviewed by Lauro Moura <lauro.neto@openbossa.org>

5 files changed, 206 insertions, 14 deletions

diff --git a/tests/testabstractmetaclass.cpp b/tests/testabstractmetaclass.cpp
index 1248ee318..f412b19ca 100644
--- a/tests/testabstractmetaclass.cpp
+++ b/tests/testabstractmetaclass.cpp
@@ -57,14 +57,22 @@ void TestAbstractMetaClass::testClassNameUnderNamespace()
 
     // Check ctors info
     QVERIFY(classes[0]->hasConstructors());
-    QCOMPARE(classes[0]->functions().size(), 1);
+    QCOMPARE(classes[0]->functions().size(), 2); // default ctor + copy ctor
+
     AbstractMetaFunctionList ctors = classes[0]->queryFunctions(AbstractMetaClass::Constructors);
-    QCOMPARE(ctors.size(), 1);
+    QCOMPARE(ctors.size(), 2);
+    if (ctors.first()->minimalSignature() != "ClassName()")
+        ctors.swap(0, 1);
+
     QCOMPARE(ctors[0]->arguments().size(), 0);
-    QVERIFY(!classes[0]->hasPrivateDestructor());
+    QCOMPARE(ctors[0]->minimalSignature(), QString("ClassName()"));
+    QCOMPARE(ctors[1]->arguments().size(), 1);
+    QCOMPARE(ctors[1]->minimalSignature(), QString("ClassName(Namespace::ClassName)"));
 
-    QVERIFY(classes[0]->hasCloneOperator()); // implicity default copy ctor
+    QVERIFY(!classes[0]->hasPrivateDestructor());
+    QVERIFY(classes[0]->hasCloneOperator()); // implicit default copy ctor
     QVERIFY(!classes[0]->hasHashFunction());
+
     // This method is buggy and nobody wants to fix it or needs it fixed :-/
     // QVERIFY(classes[0]->hasNonPrivateConstructor());
 }
@@ -102,7 +110,7 @@ void TestAbstractMetaClass::testVirtualMethods()
     QCOMPARE(b->baseClass(), a);
     QCOMPARE(c->baseClass(), b);
 
-    QCOMPARE(a->functions().size(), 2); // implicity ctor + the pv method
+    QCOMPARE(a->functions().size(), 2); // default ctor + the pure virtual method
     QCOMPARE(b->functions().size(), 2);
     QCOMPARE(c->functions().size(), 2);
 
@@ -221,6 +229,186 @@ void TestAbstractMetaClass::testInnerClassOfAPolymorphicOne()
     QVERIFY(!classB->isPolymorphic());
 }
 
+void TestAbstractMetaClass::testClassDefaultConstructors()
+{
+    const char* cppCode ="\
+    struct A {};\
+    \
+    struct B {\
+        B();\
+    private: \
+        B(const B&);\
+    };\
+    \
+    struct C {\
+        C(const C&);\
+    };\
+    \
+    struct D {\
+    private: \
+        D(const D&);\
+    };\
+    \
+    struct E {\
+    private: \
+        ~E();\
+    };\
+    \
+    struct F {\
+        F(int, int);\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <primitive-type name='int' />\
+        <value-type name='A' /> \
+        <object-type name='B' /> \
+        <value-type name='C' /> \
+        <object-type name='D' /> \
+        <object-type name='E' /> \
+        <value-type name='F' /> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 6);
+
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+    QCOMPARE(classA->functions().size(), 2);
+
+    AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
+    QCOMPARE(ctors.size(), 2);
+    if (ctors.first()->minimalSignature() != "A()")
+        ctors.swap(0, 1);
+
+    QCOMPARE(ctors[0]->arguments().size(), 0);
+    QCOMPARE(ctors[0]->minimalSignature(), QString("A()"));
+    QCOMPARE(ctors[1]->arguments().size(), 1);
+    QCOMPARE(ctors[1]->minimalSignature(), QString("A(A)"));
+
+    AbstractMetaClass* classB = classes.findClass("B");
+    QVERIFY(classB);
+    QCOMPARE(classB->functions().size(), 2);
+    QCOMPARE(classB->functions().first()->minimalSignature(), QString("B()"));
+
+    AbstractMetaClass* classC = classes.findClass("C");
+    QVERIFY(classC);
+    QCOMPARE(classC->functions().size(), 1);
+    QCOMPARE(classC->functions().first()->minimalSignature(), QString("C(C)"));
+
+    AbstractMetaClass* classD = classes.findClass("D");
+    QVERIFY(classD);
+    QCOMPARE(classD->functions().size(), 1);
+    QCOMPARE(classD->functions().first()->minimalSignature(), QString("D(D)"));
+    QVERIFY(classD->functions().first()->isPrivate());
+
+    AbstractMetaClass* classE = classes.findClass("E");
+    QVERIFY(classE);
+    QVERIFY(classE->hasPrivateDestructor());
+    QCOMPARE(classE->functions().size(), 0);
+
+    AbstractMetaClass* classF = classes.findClass("F");
+    QVERIFY(classF);
+
+    ctors = classF->queryFunctions(AbstractMetaClass::Constructors);
+    QCOMPARE(ctors.size(), 2);
+    if (ctors.first()->minimalSignature() != "F(int,int)")
+        ctors.swap(0, 1);
+
+    QCOMPARE(ctors[0]->arguments().size(), 2);
+    QCOMPARE(ctors[0]->minimalSignature(), QString("F(int,int)"));
+    QCOMPARE(ctors[1]->arguments().size(), 1);
+    QCOMPARE(ctors[1]->minimalSignature(), QString("F(F)"));
+}
+
+void TestAbstractMetaClass::testClassInheritedDefaultConstructors()
+{
+    const char* cppCode ="\
+    struct A {\
+        A();\
+    private: \
+        A(const A&);\
+    };\
+    struct B : public A {};\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <object-type name='A' /> \
+        <object-type name='B' /> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 2);
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+
+    AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
+    QCOMPARE(ctors.size(), 2);
+    if (ctors.first()->minimalSignature() != "A()")
+        ctors.swap(0, 1);
+
+    QCOMPARE(ctors[0]->arguments().size(), 0);
+    QCOMPARE(ctors[0]->minimalSignature(), QString("A()"));
+    QCOMPARE(ctors[1]->arguments().size(), 1);
+    QCOMPARE(ctors[1]->minimalSignature(), QString("A(A)"));
+    QVERIFY(ctors[1]->isPrivate());
+
+    AbstractMetaClass* classB = classes.findClass("B");
+    QVERIFY(classB);
+
+    ctors = classB->queryFunctions(AbstractMetaClass::Constructors);
+    QCOMPARE(ctors.size(), 1);
+    QCOMPARE(ctors.first()->arguments().size(), 0);
+    QCOMPARE(ctors.first()->minimalSignature(), QString("B()"));
+}
+
+void TestAbstractMetaClass::testAbstractClassDefaultConstructors()
+{
+    const char* cppCode ="\
+    struct A {\
+        virtual method() = 0;\
+    };\
+    ";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <object-type name='A' /> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 1);
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+
+    AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
+    QCOMPARE(ctors.size(), 1);
+    QCOMPARE(ctors.first()->arguments().size(), 0);
+    QCOMPARE(ctors.first()->minimalSignature(), QString("A()"));
+}
+
+void TestAbstractMetaClass::testObjectTypesMustNotHaveCopyConstructors()
+{
+    const char* cppCode ="struct A {};";
+    const char* xmlCode = "\
+    <typesystem package='Foo'> \
+        <object-type name='A' /> \
+    </typesystem>";
+
+    TestUtil t(cppCode, xmlCode);
+    AbstractMetaClassList classes = t.builder()->classes();
+    QCOMPARE(classes.count(), 1);
+    AbstractMetaClass* classA = classes.findClass("A");
+    QVERIFY(classA);
+
+    AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
+    QCOMPARE(ctors.size(), 1);
+    QCOMPARE(ctors.first()->arguments().size(), 0);
+    QCOMPARE(ctors.first()->minimalSignature(), QString("A()"));
+}
+
+
 QTEST_APPLESS_MAIN(TestAbstractMetaClass)
 
 #include "testabstractmetaclass.moc"
diff --git a/tests/testabstractmetaclass.h b/tests/testabstractmetaclass.h
index ef41c2fce..03b5721a3 100644
--- a/tests/testabstractmetaclass.h
+++ b/tests/testabstractmetaclass.h
@@ -38,6 +38,10 @@ private slots:
     void testDefaultValues();
     void testModifiedDefaultValues();
     void testInnerClassOfAPolymorphicOne();
+    void testClassDefaultConstructors();
+    void testClassInheritedDefaultConstructors();
+    void testAbstractClassDefaultConstructors();
+    void testObjectTypesMustNotHaveCopyConstructors();
 };
 
 #endif // TESTABSTRACTMETACLASS_H
diff --git a/tests/testaddfunction.cpp b/tests/testaddfunction.cpp
index 91380b073..ed14d7b3b 100644
--- a/tests/testaddfunction.cpp
+++ b/tests/testaddfunction.cpp
@@ -81,7 +81,7 @@ void TestAddFunction::testAddFunction()
     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
+    QCOMPARE(classA->functions().count(), 4); // default ctor, default copy ctor, func a() and the added function
 
     AbstractMetaFunction* addedFunc = classA->functions().last();
     QCOMPARE(addedFunc->visibility(), uint(AbstractMetaFunction::Protected));
@@ -117,7 +117,7 @@ void TestAddFunction::testAddFunctionConstructor()
     AbstractMetaClassList classes = t.builder()->classes();
     AbstractMetaClass* classA = classes.findClass("A");
     QVERIFY(classA);
-    QCOMPARE(classA->functions().count(), 2); // default and added ctors
+    QCOMPARE(classA->functions().count(), 3); // default and added ctors
     AbstractMetaFunction* addedFunc = classA->functions().last();
     QCOMPARE(addedFunc->visibility(), uint(AbstractMetaFunction::Public));
     QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::ConstructorFunction);
@@ -139,7 +139,7 @@ void TestAddFunction::testAddFunctionTagDefaultValues()
     AbstractMetaClassList classes = t.builder()->classes();
     AbstractMetaClass* classA = classes.findClass("A");
     QVERIFY(classA);
-    QCOMPARE(classA->functions().count(), 2); // default ctor and the added function
+    QCOMPARE(classA->functions().count(), 3); // default ctor, default copy ctor and the added function
     AbstractMetaFunction* addedFunc = classA->functions().last();
     QCOMPARE(addedFunc->visibility(), uint(AbstractMetaFunction::Public));
     QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::NormalFunction);
diff --git a/tests/testconversionoperator.cpp b/tests/testconversionoperator.cpp
index ab682db61..b6d1ccf54 100644
--- a/tests/testconversionoperator.cpp
+++ b/tests/testconversionoperator.cpp
@@ -52,9 +52,9 @@ void TestConversionOperator::testConversionOperator()
     QVERIFY(classA);
     QVERIFY(classB);
     QVERIFY(classC);
-    QCOMPARE(classA->functions().count(), 1);
-    QCOMPARE(classB->functions().count(), 2);
-    QCOMPARE(classC->functions().count(), 2);
+    QCOMPARE(classA->functions().count(), 2);
+    QCOMPARE(classB->functions().count(), 3);
+    QCOMPARE(classC->functions().count(), 3);
     QCOMPARE(classA->externalConversionOperators().count(), 2);
 
     AbstractMetaFunction* convOp = 0;
@@ -110,8 +110,8 @@ void TestConversionOperator::testRemovedConversionOperator()
     AbstractMetaClass* classB = classes.findClass("B");
     QVERIFY(classA);
     QVERIFY(classB);
-    QCOMPARE(classA->functions().count(), 1);
-    QCOMPARE(classB->functions().count(), 2);
+    QCOMPARE(classA->functions().count(), 2);
+    QCOMPARE(classB->functions().count(), 3);
     QCOMPARE(classA->externalConversionOperators().count(), 0);
     QCOMPARE(classA->implicitConversions().count(), 0);
 }
diff --git a/tests/testreverseoperators.cpp b/tests/testreverseoperators.cpp
index 70ca8d264..5c7f66671 100644
--- a/tests/testreverseoperators.cpp
+++ b/tests/testreverseoperators.cpp
@@ -42,7 +42,7 @@ void TestReverseOperators::testReverseSum()
     AbstractMetaClassList classes = t.builder()->classes();
     AbstractMetaClass* classA = classes.findClass("A");
     QVERIFY(classA);
-    QCOMPARE(classA->functions().count(), 3);
+    QCOMPARE(classA->functions().count(), 4);
 
     const AbstractMetaFunction* reverseOp = 0;
     const AbstractMetaFunction* normalOp = 0;