1 files changed, 62 insertions, 29 deletions

diff --git a/sources/shiboken2/ApiExtractor/tests/testabstractmetaclass.cpp b/sources/shiboken2/ApiExtractor/tests/testabstractmetaclass.cpp
index 028522159..9acbba675 100644
--- a/sources/shiboken2/ApiExtractor/tests/testabstractmetaclass.cpp
+++ b/sources/shiboken2/ApiExtractor/tests/testabstractmetaclass.cpp
@@ -57,7 +57,7 @@ void TestAbstractMetaClass::testClassNameUnderNamespace()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.count(), 2); // 1 namespace + 1 class
     if (classes.first()->name() != QLatin1String("ClassName"))
-        classes.swap(0, 1);
+        qSwap(classes[0], classes[1]);
 
     QCOMPARE(classes[0]->name(), QLatin1String("ClassName"));
     QCOMPARE(classes[0]->qualifiedCppName(), QLatin1String("Namespace::ClassName"));
@@ -71,7 +71,7 @@ void TestAbstractMetaClass::testClassNameUnderNamespace()
     AbstractMetaFunctionList ctors = classes[0]->queryFunctions(AbstractMetaClass::Constructors);
     QCOMPARE(ctors.size(), 2);
     if (ctors.first()->minimalSignature() != QLatin1String("ClassName()"))
-        ctors.swap(0, 1);
+        qSwap(ctors[0], ctors[1]);
 
     QCOMPARE(ctors[0]->arguments().size(), 0);
     QCOMPARE(ctors[0]->minimalSignature(), QLatin1String("ClassName()"));
@@ -86,42 +86,66 @@ void TestAbstractMetaClass::testClassNameUnderNamespace()
     // QVERIFY(classes[0]->hasNonPrivateConstructor());
 }
 
+static AbstractMetaFunctionList virtualFunctions(const AbstractMetaClass *c)
+{
+    AbstractMetaFunctionList result;
+    const AbstractMetaFunctionList &functions = c->functions();
+    for (AbstractMetaFunction *f : functions) {
+        if (f->isVirtual())
+            result.append(f);
+    }
+    return result;
+}
+
 void TestAbstractMetaClass::testVirtualMethods()
 {
-    const char* cppCode ="\
-    class A {\n\
-    public:\n\
-        virtual int pureVirtual() const = 0;\n\
-    };\n\
-    class B : public A {};\n\
-    class C : public B {\n\
-    public:\n\
-        int pureVirtual() const { return 0; }\n\
-    };\n";
-    const char* xmlCode = "\
-    <typesystem package=\"Foo\">\n\
-        <primitive-type name='int'/>\n\
-        <object-type name='A'/>\n\
-        <object-type name='B'/>\n\
-        <object-type name='C'/>\n\
-    </typesystem>\n";
+    const char cppCode[] =R"CPP(
+class A {
+public:
+    virtual int pureVirtual() const = 0;
+};
+class B : public A {};
+class C : public B {
+public:
+    int pureVirtual() const override { return 0; }
+};
+class F final : public C {
+public:
+    int pureVirtual() const final { return 1; }
+};
+)CPP";
+
+    const char xmlCode[] = R"XML(
+<typesystem package="Foo">
+    <primitive-type name='int'/>
+    <object-type name='A'/>
+    <object-type name='B'/>
+    <object-type name='C'/>
+    <object-type name='F'/>
+</typesystem>
+)XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(!builder.isNull());
     AbstractMetaClassList classes = builder->classes();
-    QCOMPARE(classes.count(), 3);
+    QCOMPARE(classes.count(), 4);
     AbstractMetaClass* a = AbstractMetaClass::findClass(classes, QLatin1String("A"));
     AbstractMetaClass* b = AbstractMetaClass::findClass(classes, QLatin1String("B"));
     AbstractMetaClass* c = AbstractMetaClass::findClass(classes, QLatin1String("C"));
+    const AbstractMetaClass *f = AbstractMetaClass::findClass(classes, QLatin1String("F"));
+    QVERIFY(f);
 
     AbstractMetaClass* no_class = 0;
 
     QCOMPARE(a->baseClass(), no_class);
     QCOMPARE(b->baseClass(), a);
     QCOMPARE(c->baseClass(), b);
+    QCOMPARE(f->baseClass(), c);
 
     QCOMPARE(a->functions().size(), 2); // default ctor + the pure virtual method
     QCOMPARE(b->functions().size(), 2);
     QCOMPARE(c->functions().size(), 2);
+    QCOMPARE(f->functions().size(), 2);
+    QVERIFY(f->attributes() & AbstractMetaAttributes::FinalCppClass);
 
     // implementing class, ownclass, declaringclass
     AbstractMetaFunction* ctorA = a->queryFunctions(AbstractMetaClass::Constructors).first();
@@ -137,17 +161,26 @@ void TestAbstractMetaClass::testVirtualMethods()
     QCOMPARE(ctorA->ownerClass(), a);
     QCOMPARE(ctorA->declaringClass(), a);
 
-    QCOMPARE(a->virtualFunctions().size(), 1); // Add a pureVirtualMethods method !?
-    QCOMPARE(b->virtualFunctions().size(), 1);
-    QCOMPARE(c->virtualFunctions().size(), 1);
+    const AbstractMetaFunctionList virtualFunctionsA = virtualFunctions(a);
+    const AbstractMetaFunctionList virtualFunctionsB = virtualFunctions(b);
+    const AbstractMetaFunctionList virtualFunctionsC = virtualFunctions(c);
+    const AbstractMetaFunctionList virtualFunctionsF = virtualFunctions(f);
+    QCOMPARE(virtualFunctionsA.size(), 1); // Add a pureVirtualMethods method !?
+    QCOMPARE(virtualFunctionsB.size(), 1);
+    QCOMPARE(virtualFunctionsC.size(), 1);
+    QCOMPARE(virtualFunctionsF.size(), 1);
 
-    AbstractMetaFunction* funcA = a->virtualFunctions().first();
-    AbstractMetaFunction* funcB = b->virtualFunctions().first();
-    AbstractMetaFunction* funcC = c->virtualFunctions().first();
+    const AbstractMetaFunction* funcA = virtualFunctionsA.constFirst();
+    const AbstractMetaFunction* funcB = virtualFunctionsB.constFirst();
+    const AbstractMetaFunction* funcC = virtualFunctionsC.constFirst();
+    const AbstractMetaFunction* funcF = virtualFunctionsF.constFirst();
 
     QCOMPARE(funcA->ownerClass(), a);
+    QVERIFY(funcC->attributes() & AbstractMetaAttributes::VirtualCppMethod);
     QCOMPARE(funcB->ownerClass(), b);
     QCOMPARE(funcC->ownerClass(), c);
+    QVERIFY(funcC->attributes() & AbstractMetaAttributes::OverriddenCppMethod);
+    QVERIFY(funcF->attributes() & AbstractMetaAttributes::FinalCppMethod);
 
     QCOMPARE(funcA->declaringClass(), a);
     QCOMPARE(funcB->declaringClass(), a);
@@ -361,7 +394,7 @@ void TestAbstractMetaClass::testClassDefaultConstructors()
     AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
     QCOMPARE(ctors.size(), 2);
     if (ctors.first()->minimalSignature() != QLatin1String("A()"))
-        ctors.swap(0, 1);
+        qSwap(ctors[0], ctors[1]);
 
     QCOMPARE(ctors[0]->arguments().size(), 0);
     QCOMPARE(ctors[0]->minimalSignature(), QLatin1String("A()"));
@@ -395,7 +428,7 @@ void TestAbstractMetaClass::testClassDefaultConstructors()
     ctors = classF->queryFunctions(AbstractMetaClass::Constructors);
     QCOMPARE(ctors.size(), 2);
     if (ctors.first()->minimalSignature() != QLatin1String("F(int,int)"))
-        ctors.swap(0, 1);
+        qSwap(ctors[0], ctors[1]);
 
     QCOMPARE(ctors[0]->arguments().size(), 2);
     QCOMPARE(ctors[0]->minimalSignature(), QLatin1String("F(int,int)"));
@@ -428,7 +461,7 @@ void TestAbstractMetaClass::testClassInheritedDefaultConstructors()
     AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors);
     QCOMPARE(ctors.size(), 2);
     if (ctors.first()->minimalSignature() != QLatin1String("A()"))
-        ctors.swap(0, 1);
+        qSwap(ctors[0], ctors[1]);
 
     QCOMPARE(ctors[0]->arguments().size(), 0);
     QCOMPARE(ctors[0]->minimalSignature(), QLatin1String("A()"));