From 53c64681f115bfecf7dbdef8de905d25aa3dc301 Mon Sep 17 00:00:00 2001 From: Marcelo Lira Date: Fri, 26 Mar 2010 20:15:50 -0300 Subject: Adds many tests regarding default copy constructors. Also updated other tests dealing with constructor counting. Reviewed by Hugo Parente Reviewed by Lauro Moura --- tests/testabstractmetaclass.cpp | 198 ++++++++++++++++++++++++++++++++++++++- tests/testabstractmetaclass.h | 4 + tests/testaddfunction.cpp | 6 +- tests/testconversionoperator.cpp | 10 +- tests/testreverseoperators.cpp | 2 +- 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 = "\ + \ + \ + \ + \ + \ + \ + \ + \ + "; + + 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 = "\ + \ + \ + \ + "; + + 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 = "\ + \ + \ + "; + + 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 = "\ + \ + \ + "; + + 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; -- cgit v1.2.3