shiboken6: Port from QSharedPointer to std::shared_ptr

Task-number: QTBUG-109570
Change-Id: Iabdafb0a5ab211e32c1bbf7face78fd5102a49b9
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Cristian Maureira-Fredes <cristian.maureira-fredes@qt.io>

34 files changed, 323 insertions, 323 deletions

diff --git a/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp b/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
index 6f96f6de5..a1940b762 100644
--- a/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
@@ -23,7 +23,7 @@ void TestAbstractMetaClass::testClassName()
     <value-type name="ClassName"/>
 </typesystem>)";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
     QCOMPARE(classes[0]->name(), u"ClassName");
@@ -39,7 +39,7 @@ void TestAbstractMetaClass::testClassNameUnderNamespace()
         </namespace-type>
     </typesystem>)XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2); // 1 namespace + 1 class
     if (classes.constFirst()->name() != u"ClassName")
@@ -110,14 +110,14 @@ public:
 </typesystem>
 )XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 4);
     const auto a = AbstractMetaClass::findClass(classes, u"A");
     const auto b = AbstractMetaClass::findClass(classes, u"B");
     const auto c = AbstractMetaClass::findClass(classes, u"C");
     const auto f = AbstractMetaClass::findClass(classes, u"F");
-    QVERIFY(!f.isNull());
+    QVERIFY(f);
 
     QCOMPARE(a->baseClass(), nullptr);
     QCOMPARE(b->baseClass(), a);
@@ -194,10 +194,10 @@ class Derived : public Base {};
 </typesystem>
 )XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto base = AbstractMetaClass::findClass(classes, u"Base");
-    QVERIFY(!base.isNull());
+    QVERIFY(base);
     QVERIFY(base->isPolymorphic());
     const auto derived = AbstractMetaClass::findClass(classes, u"Derived");
     QVERIFY(derived);
@@ -218,7 +218,7 @@ void TestAbstractMetaClass::testDefaultValues()
         </value-type>
     </typesystem>)XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
@@ -248,7 +248,7 @@ void TestAbstractMetaClass::testModifiedDefaultValues()
         </value-type>
     </typesystem>)XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
@@ -274,14 +274,14 @@ void TestAbstractMetaClass::testInnerClassOfAPolymorphicOne()
         </object-type>
     </typesystem>)XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     QVERIFY(classA->isPolymorphic());
     const auto classB = AbstractMetaClass::findClass(classes, u"A::B");
-    QVERIFY(!classB.isNull());
+    QVERIFY(classB);
     QVERIFY(!classB->isPolymorphic());
 }
 
@@ -302,15 +302,15 @@ void TestAbstractMetaClass::testForwardDeclaredInnerClass()
         </value-type>
     </typesystem>)XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     const auto classB = AbstractMetaClass::findClass(classes, u"A::B");
-    QVERIFY(!classB.isNull());
+    QVERIFY(classB);
     const auto fooF = classB->findFunction(u"foo");
-    QVERIFY(!fooF.isNull());
+    QVERIFY(fooF);
 }
 
 void TestAbstractMetaClass::testSpecialFunctions()
@@ -333,12 +333,12 @@ void TestAbstractMetaClass::testSpecialFunctions()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
 
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     auto ctors = classA->queryFunctions(FunctionQueryOption::AnyConstructor);
     QCOMPARE(ctors.size(), 2);
     QCOMPARE(ctors.constFirst()->functionType(), AbstractMetaFunction::ConstructorFunction);
@@ -349,7 +349,7 @@ void TestAbstractMetaClass::testSpecialFunctions()
              AbstractMetaFunction::AssignmentOperatorFunction);
 
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    QVERIFY(!classB.isNull());
+    QVERIFY(classB);
     ctors = classB->queryFunctions(FunctionQueryOption::AnyConstructor);
     QCOMPARE(ctors.size(), 2);
     QCOMPARE(ctors.constFirst()->functionType(), AbstractMetaFunction::ConstructorFunction);
@@ -399,7 +399,7 @@ void TestAbstractMetaClass::testClassDefaultConstructors()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 6);
 
@@ -418,28 +418,28 @@ void TestAbstractMetaClass::testClassDefaultConstructors()
     QCOMPARE(ctors[1]->minimalSignature(), u"A(A)");
 
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    QVERIFY(!classB.isNull());
+    QVERIFY(classB);
     QCOMPARE(classB->functions().size(), 2);
     QCOMPARE(classB->functions().constFirst()->minimalSignature(), u"B()");
 
     const auto classC = AbstractMetaClass::findClass(classes, u"C");
-    QVERIFY(!classC.isNull());
+    QVERIFY(classC);
     QCOMPARE(classC->functions().size(), 1);
     QCOMPARE(classC->functions().constFirst()->minimalSignature(), u"C(C)");
 
     const auto classD = AbstractMetaClass::findClass(classes, u"D");
-    QVERIFY(!classD.isNull());
+    QVERIFY(classD);
     QCOMPARE(classD->functions().size(), 1);
     QCOMPARE(classD->functions().constFirst()->minimalSignature(), u"D(D)");
     QVERIFY(classD->functions().constFirst()->isPrivate());
 
     const auto classE = AbstractMetaClass::findClass(classes, u"E");
-    QVERIFY(!classE.isNull());
+    QVERIFY(classE);
     QVERIFY(classE->hasPrivateDestructor());
     QCOMPARE(classE->functions().size(), 0);
 
     const auto classF = AbstractMetaClass::findClass(classes, u"F");
-    QVERIFY(!classF.isNull());
+    QVERIFY(classF);
 
     ctors = classF->queryFunctions(FunctionQueryOption::AnyConstructor);
     QCOMPARE(ctors.size(), 2);
@@ -468,7 +468,7 @@ void TestAbstractMetaClass::testClassInheritedDefaultConstructors()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
@@ -486,7 +486,7 @@ void TestAbstractMetaClass::testClassInheritedDefaultConstructors()
     QVERIFY(ctors[1]->isPrivate());
 
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    QVERIFY(!classB.isNull());
+    QVERIFY(classB);
 
     ctors = classB->queryFunctions(FunctionQueryOption::Constructors);
     QCOMPARE(ctors.size(), 1);
@@ -506,11 +506,11 @@ void TestAbstractMetaClass::testAbstractClassDefaultConstructors()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
 
     const auto ctors = classA->queryFunctions(FunctionQueryOption::Constructors);
     QCOMPARE(ctors.size(), 1);
@@ -527,11 +527,11 @@ void TestAbstractMetaClass::testObjectTypesMustNotHaveCopyConstructors()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
 
     const auto ctors = classA->queryFunctions(FunctionQueryOption::Constructors);
     QCOMPARE(ctors.size(), 1);
@@ -563,7 +563,7 @@ void TestAbstractMetaClass::testIsPolymorphic()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     const auto b = AbstractMetaClass::findClass(classes, u"A");
@@ -593,13 +593,13 @@ class Derived : public BaseAlias2 {
 )XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     const auto base = AbstractMetaClass::findClass(classes, u"Base");
-    QVERIFY(!base.isNull());
+    QVERIFY(base);
     const auto derived = AbstractMetaClass::findClass(classes, u"Derived");
-    QVERIFY(!derived.isNull());
+    QVERIFY(derived);
     QCOMPARE(derived->baseClasses().value(0), base);
 }
 
@@ -644,7 +644,7 @@ void TestAbstractMetaClass::testFreeOperators()
     </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(code.constData(), xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     const auto classes = builder->classes();
     QCOMPARE(classes.size(), 1);
     QVERIFY(classes.constFirst()->hasArithmeticOperatorOverload());
@@ -678,13 +678,13 @@ public:
 )XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     const auto base = AbstractMetaClass::findClass(classes, u"Base");
-    QVERIFY(!base.isNull());
+    QVERIFY(base);
     const auto derived = AbstractMetaClass::findClass(classes, u"Derived");
-    QVERIFY(!derived.isNull());
+    QVERIFY(derived);
     const auto usingMembers = derived->usingMembers();
     QCOMPARE(usingMembers.size(), 2);
     for (const auto &um : usingMembers) {
@@ -733,10 +733,10 @@ void TestAbstractMetaClass::testUsingTemplateMembers()
 )XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(code.constData(), xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto valueList = AbstractMetaClass::findClass(classes, u"ValueList");
-    QVERIFY(!valueList.isNull());
+    QVERIFY(valueList);
     auto list = valueList->templateBaseClass();
     QVERIFY(valueList->isUsingMember(list, u"append"_s, Access::Public));
     QCOMPARE(valueList->queryFunctionsByName(u"append"_s).size(), 2);
@@ -763,7 +763,7 @@ public:
 )XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto tc = AbstractMetaClass::findClass(classes, u"TestClass");
     // Verify that the constructor and 2 functions are generated.
diff --git a/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp b/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp
index 2c6cb5324..644ae8aa1 100644
--- a/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp
@@ -54,7 +54,7 @@ void TestAbstractMetaType::testConstCharPtrType()
         <function signature='justAtest()' />\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     QCOMPARE(builder->globalFunctions().size(), 1);
     const auto func = builder->globalFunctions().constFirst();
     AbstractMetaType rtype = func->type();
@@ -87,7 +87,7 @@ void TestAbstractMetaType::testApiVersionSupported()
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 false, u"1.0"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
@@ -105,7 +105,7 @@ void TestAbstractMetaType::testApiVersionNotSupported()
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 true, u"0.1"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
@@ -120,7 +120,7 @@ void TestAbstractMetaType::testCharType()
     <function signature='justAtest()'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
@@ -157,12 +157,12 @@ void TestAbstractMetaType::testTypedef()
     <value-type name='C' />\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
     const auto c = AbstractMetaClass::findClass(classes, u"C");
-    QVERIFY(!c.isNull());
+    QVERIFY(c);
     QVERIFY(c->isTypeDef());
 }
 
@@ -182,7 +182,7 @@ void TestAbstractMetaType::testTypedefWithTemplates()
     <function signature='func(A&lt;B&gt;)'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
@@ -207,12 +207,12 @@ void TestAbstractMetaType::testObjectTypeUsedAsValue()
     <object-type name='A'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     const auto overloads = classA->queryFunctionsByName(u"method"_s);
     QCOMPARE(overloads.size(), 1);
     const auto method = overloads.constFirst();
diff --git a/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp b/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp
index 883cc62e0..c3d6e4a8a 100644
--- a/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp
@@ -26,7 +26,7 @@ void TestAddFunction::testParsingFuncNameAndConstness()
     QString errorMessage;
     auto f1 = AddedFunction::createAddedFunction(QLatin1StringView(sig1), u"void"_s,
                                                  &errorMessage);
-    QVERIFY2(!f1.isNull(), qPrintable(errorMessage));
+    QVERIFY2(f1, qPrintable(errorMessage));
     QCOMPARE(f1->name(), u"func");
     QCOMPARE(f1->arguments().size(), 3);
     TypeInfo retval = f1->returnType();
@@ -40,7 +40,7 @@ void TestAddFunction::testParsingFuncNameAndConstness()
     auto f2 = AddedFunction::createAddedFunction(QLatin1StringView(sig2),
                                                  u"const Abc<int& , C<char*> *   >  * *"_s,
                                                  &errorMessage);
-    QVERIFY2(!f2.isNull(), qPrintable(errorMessage));
+    QVERIFY2(f2, qPrintable(errorMessage));
     QCOMPARE(f2->name(), u"_fu__nc_");
     const auto &args = f2->arguments();
     QCOMPARE(args.size(), 4);
@@ -69,7 +69,7 @@ void TestAddFunction::testParsingFuncNameAndConstness()
     const char sig3[] = "func()";
     auto f3 = AddedFunction::createAddedFunction(QLatin1StringView(sig3), u"void"_s,
                                                  &errorMessage);
-    QVERIFY2(!f3.isNull(), qPrintable(errorMessage));
+    QVERIFY2(f3, qPrintable(errorMessage));
     QCOMPARE(f3->name(), u"func");
     QCOMPARE(f3->arguments().size(), 0);
 
@@ -77,7 +77,7 @@ void TestAddFunction::testParsingFuncNameAndConstness()
     const char sig4[] = "operator()(int)const";
     auto f4 = AddedFunction::createAddedFunction(QLatin1StringView(sig4), u"int"_s,
                                                  &errorMessage);
-    QVERIFY2(!f4.isNull(), qPrintable(errorMessage));
+    QVERIFY2(f4, qPrintable(errorMessage));
     QCOMPARE(f4->name(), u"operator()");
     QCOMPARE(f4->arguments().size(), 1);
     QVERIFY(f4->isConstant());
@@ -102,11 +102,11 @@ struct A {
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     auto *typeDb = TypeDatabase::instance();
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     // default ctor, default copy ctor, func a() and the added functions
     QCOMPARE(classA->functions().size(), 5);
 
@@ -146,10 +146,10 @@ void TestAddFunction::testAddFunctionConstructor()
         </value-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 3); // default and added ctors
     const auto addedFunc = classA->functions().constLast();
     QCOMPARE(addedFunc->access(), Access::Public);
@@ -169,10 +169,10 @@ void TestAddFunction::testAddFunctionTagDefaultValues()
         </value-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     // default ctor, default copy ctor and the added function
     QCOMPARE(classA->functions().size(), 3);
     const auto addedFunc = classA->functions().constLast();
@@ -195,10 +195,10 @@ void TestAddFunction::testAddFunctionCodeSnippets()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     const auto addedFunc = classA->functions().constLast();
     QVERIFY(addedFunc->hasInjectedCode());
 }
@@ -209,7 +209,7 @@ void TestAddFunction::testAddFunctionWithoutParenteses()
     QString errorMessage;
     auto f1 = AddedFunction::createAddedFunction(QLatin1StringView(sig1), u"void"_s,
                                                  &errorMessage);
-    QVERIFY2(!f1.isNull(), qPrintable(errorMessage));
+    QVERIFY2(f1, qPrintable(errorMessage));
     QCOMPARE(f1->name(), u"func");
     QCOMPARE(f1->arguments().size(), 0);
     QCOMPARE(f1->isConstant(), false);
@@ -225,12 +225,12 @@ void TestAddFunction::testAddFunctionWithoutParenteses()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     const auto addedFunc = classA->findFunction(u"func");
-    QVERIFY(!addedFunc.isNull());
+    QVERIFY(addedFunc);
     QVERIFY(addedFunc->hasInjectedCode());
     const auto snips = addedFunc->injectedCodeSnips(TypeSystem::CodeSnipPositionAny,
                                                     TypeSystem::TargetLangCode);
@@ -243,7 +243,7 @@ void TestAddFunction::testAddFunctionWithDefaultArgs()
     QString errorMessage;
     auto f1 = AddedFunction::createAddedFunction(QLatin1StringView(sig1), u"void"_s,
                                                  &errorMessage);
-    QVERIFY2(!f1.isNull(), qPrintable(errorMessage));
+    QVERIFY2(f1, qPrintable(errorMessage));
     QCOMPARE(f1->name(), u"func");
     QCOMPARE(f1->arguments().size(), 0);
     QCOMPARE(f1->isConstant(), false);
@@ -262,12 +262,12 @@ void TestAddFunction::testAddFunctionWithDefaultArgs()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     const auto addedFunc = classA->findFunction(u"func");
-    QVERIFY(!addedFunc.isNull());
+    QVERIFY(addedFunc);
     const AbstractMetaArgument &arg = addedFunc->arguments().at(1);
     QCOMPARE(arg.defaultValueExpression(), u"2");
 }
@@ -285,10 +285,10 @@ void TestAddFunction::testAddFunctionAtModuleLevel()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
 
     auto *typeDb = TypeDatabase::instance();
 
@@ -310,7 +310,7 @@ void TestAddFunction::testAddFunctionWithVarargs()
     QString errorMessage;
     auto f1 = AddedFunction::createAddedFunction(QLatin1StringView(sig1), u"void"_s,
                                                  &errorMessage);
-    QVERIFY2(!f1.isNull(), qPrintable(errorMessage));
+    QVERIFY2(f1, qPrintable(errorMessage));
     QCOMPARE(f1->name(), u"func");
     QCOMPARE(f1->arguments().size(), 3);
     QVERIFY(!f1->isConstant());
@@ -326,12 +326,12 @@ void TestAddFunction::testAddFunctionWithVarargs()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     const auto addedFunc = classA->findFunction(u"func");
-    QVERIFY(!addedFunc.isNull());
+    QVERIFY(addedFunc);
     const AbstractMetaArgument &arg = addedFunc->arguments().constLast();
     QVERIFY(arg.type().isVarargs());
     QVERIFY(arg.type().typeEntry()->isVarargs());
@@ -350,12 +350,12 @@ void TestAddFunction::testAddStaticFunction()
         </value-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     const auto addedFunc = classA->findFunction(u"func");
-    QVERIFY(!addedFunc.isNull());
+    QVERIFY(addedFunc);
     QVERIFY(addedFunc->isStatic());
 }
 
@@ -375,7 +375,7 @@ void TestAddFunction::testAddGlobalFunction()
         <value-type name='B'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     const auto globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.size(), 2);
     const auto classB = AbstractMetaClass::findClass(builder->classes(), u"B");
@@ -401,7 +401,7 @@ void TestAddFunction::testAddFunctionWithApiVersion()
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 true, u"0.1"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     const auto globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.size(), 1);
 }
@@ -424,11 +424,11 @@ void TestAddFunction::testModifyAddedFunction()
 </typesystem>
 )";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto foo = AbstractMetaClass::findClass(classes, u"Foo");
     const auto method = foo->findFunction(u"method");
-    QVERIFY(!method.isNull());
+    QVERIFY(method);
     QCOMPARE(method->arguments().size(), 2);
     const AbstractMetaArgument &arg = method->arguments().at(1);
     QCOMPARE(arg.defaultValueExpression(), u"0");
@@ -451,17 +451,17 @@ void TestAddFunction::testAddFunctionOnTypedef()
         </value-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto foo = AbstractMetaClass::findClass(classes, u"FooInt");
-    QVERIFY(!foo.isNull());
+    QVERIFY(foo);
     QVERIFY(foo->hasNonPrivateConstructor());
     const auto &lst = foo->queryFunctions(FunctionQueryOption::AnyConstructor);
     for (const auto &f : lst)
         QVERIFY(f->signature().startsWith(f->name()));
     QCOMPARE(lst.size(), 2);
     const auto method = foo->findFunction(u"method");
-    QVERIFY(!method.isNull());
+    QVERIFY(method);
 }
 
 void TestAddFunction::testAddFunctionWithTemplateArg()
@@ -475,7 +475,7 @@ void TestAddFunction::testAddFunctionWithTemplateArg()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     QCOMPARE(builder->globalFunctions().size(), 1);
     const auto func = builder->globalFunctions().constFirst();
     const AbstractMetaArgument &arg = func->arguments().constFirst();
diff --git a/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp b/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp
index 6b6f7e599..f4b22b27e 100644
--- a/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp
@@ -35,7 +35,7 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByInteger()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
 
     const AbstractMetaArgument &arg = classA->functions().constLast()->arguments().constFirst();
     QVERIFY(arg.type().isArray());
@@ -46,7 +46,7 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByInteger()
 static QString functionMinimalSignature(const AbstractMetaClassCPtr &c, const QString &name)
 {
     const auto f = c->findFunction(name);
-    return f.isNull() ? QString() : f->minimalSignature();
+    return f ? f->minimalSignature() : QString();
 }
 
 void TestArrayArgument::testArraySignature()
@@ -109,7 +109,7 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValue()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
     AbstractMetaClassPtr classA = AbstractMetaClass::findClass(builder->classes(), u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
 
     auto someEnum = classA->findEnum(u"SomeEnum"_s);
     QVERIFY(someEnum.has_value());
@@ -138,9 +138,9 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValueFromGlobalEnu
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
 
     AbstractMetaEnum someEnum = builder->globalEnums().constFirst();
     auto nvalues = someEnum.findEnumValue(u"NValues");
diff --git a/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp b/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp
index ed71e6d55..58aaaf9b3 100644
--- a/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp
@@ -59,14 +59,14 @@ void TestCodeInjections::testReadFile()
         </value-type>\n\
     </typesystem>\n"_s;
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode.toLocal8Bit().constData()));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
     QCOMPARE(classA->typeEntry()->codeSnips().size(), 1);
     QString code = classA->typeEntry()->codeSnips().constFirst().code();
     QVERIFY(code.indexOf(expected) != -1);
     QVERIFY(classA->typeEntry()->isValue());
-    auto vte = qSharedPointerCast<const ValueTypeEntry>(classA->typeEntry());
+    auto vte = std::static_pointer_cast<const ValueTypeEntry>(classA->typeEntry());
     code = vte->targetConversionRule();
     QVERIFY(code.indexOf(expected) != -1);
 }
@@ -85,7 +85,7 @@ void TestCodeInjections::testInjectWithValidApiVersion()
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 true, u"1.0"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
     QCOMPARE(classA->typeEntry()->codeSnips().size(), 1);
@@ -105,7 +105,7 @@ void TestCodeInjections::testInjectWithInvalidApiVersion()
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 true, u"0.1"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
diff --git a/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp b/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp
index e266c146f..5a9b7d188 100644
--- a/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp
@@ -28,15 +28,15 @@ void TestContainer::testContainerType()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     //search for class A
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     auto baseContainer = classA->typeEntry()->baseContainerType();
     QVERIFY(baseContainer);
-    QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(baseContainer.data())->containerKind(),
+    QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(baseContainer.get())->containerKind(),
              ContainerTypeEntry::ListContainer);
 }
 
@@ -61,12 +61,12 @@ void TestContainer::testListOfValueType()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
 
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     QCOMPARE(classA->templateBaseClassInstantiations().size(), 1);
     const AbstractMetaType templateInstanceType =
         classA->templateBaseClassInstantiations().constFirst();
diff --git a/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp b/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp
index ac6cb0290..092503622 100644
--- a/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp
@@ -33,14 +33,14 @@ void TestConversionOperator::testConversionOperator()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
     const auto classC = AbstractMetaClass::findClass(classes, u"C");
-    QVERIFY(!classA.isNull());
-    QVERIFY(!classB.isNull());
-    QVERIFY(!classC.isNull());
+    QVERIFY(classA);
+    QVERIFY(classB);
+    QVERIFY(classC);
     QCOMPARE(classA->functions().size(), 2);
     QCOMPARE(classB->functions().size(), 3);
     QCOMPARE(classC->functions().size(), 3);
@@ -53,7 +53,7 @@ void TestConversionOperator::testConversionOperator()
             break;
         }
     }
-    QVERIFY(!convOp.isNull());
+    QVERIFY(convOp);
     QVERIFY(classA->externalConversionOperators().contains(convOp));
 }
 
@@ -71,10 +71,10 @@ void TestConversionOperator::testConversionOperatorOfDiscardedClass()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     QCOMPARE(classA->externalConversionOperators().size(), 0);
 }
 
@@ -95,12 +95,12 @@ void TestConversionOperator::testRemovedConversionOperator()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    QVERIFY(!classA.isNull());
-    QVERIFY(!classB.isNull());
+    QVERIFY(classA);
+    QVERIFY(classB);
     QCOMPARE(classA->functions().size(), 2);
     QCOMPARE(classB->functions().size(), 3);
     QCOMPARE(classA->externalConversionOperators().size(), 0);
@@ -121,12 +121,12 @@ void TestConversionOperator::testConversionOperatorReturningReference()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    QVERIFY(!classA.isNull());
-    QVERIFY(!classB.isNull());
+    QVERIFY(classA);
+    QVERIFY(classB);
     QCOMPARE(classA->functions().size(), 2);
     QCOMPARE(classB->functions().size(), 3);
     QCOMPARE(classA->externalConversionOperators().size(), 1);
@@ -155,12 +155,12 @@ void TestConversionOperator::testConversionOperatorReturningConstReference()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    QVERIFY(!classA.isNull());
-    QVERIFY(!classB.isNull());
+    QVERIFY(classA);
+    QVERIFY(classB);
     QCOMPARE(classA->functions().size(), 2);
     QCOMPARE(classB->functions().size(), 3);
     QCOMPARE(classA->externalConversionOperators().size(), 1);
diff --git a/sources/shiboken6/ApiExtractor/tests/testconversionruletag.cpp b/sources/shiboken6/ApiExtractor/tests/testconversionruletag.cpp
index 5b25c685d..2d754427f 100644
--- a/sources/shiboken6/ApiExtractor/tests/testconversionruletag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testconversionruletag.cpp
@@ -35,13 +35,13 @@ void TestConversionRuleTag::testConversionRuleTagWithFile()
         </value-type>\n\
     </typesystem>\n"_s;
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode.toLocal8Bit().data()));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     const auto typeEntry = classA->typeEntry();
     QVERIFY(typeEntry->isValue());
-    auto vte = qSharedPointerCast<const ValueTypeEntry>(typeEntry);
+    auto vte = std::static_pointer_cast<const ValueTypeEntry>(typeEntry);
     QVERIFY(vte->hasTargetConversionRule());
     QCOMPARE(vte->targetConversionRule(), QLatin1String(conversionData));
 }
@@ -85,10 +85,10 @@ void TestConversionRuleTag::testConversionRuleTagReplace()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     auto *typeDb = TypeDatabase::instance();
     auto typeA = typeDb->findPrimitiveType(u"A"_s);
-    QVERIFY(!typeA.isNull());
+    QVERIFY(typeA);
 
     QVERIFY(typeA->hasCustomConversion());
     auto conversion = typeA->customConversion();
@@ -115,7 +115,7 @@ void TestConversionRuleTag::testConversionRuleTagReplace()
     QCOMPARE(toNative.sourceTypeName(), u"B");
     QVERIFY(!toNative.isCustomType());
     auto typeB = typeDb->findType(u"B"_s);
-    QVERIFY(!typeB.isNull());
+    QVERIFY(typeB);
     QCOMPARE(toNative.sourceType(), typeB);
     QCOMPARE(toNative.sourceTypeCheck(), u"CheckIfInputObjectIsB(%IN)");
     QCOMPARE(toNative.conversion().trimmed(), u"%OUT = %IN.createA();");
@@ -153,12 +153,12 @@ if (!TargetDateTimeAPI) TargetDateTime_IMPORT;\n\
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     const auto classA = AbstractMetaClass::findClass(builder->classes(), u"Date");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
 
     QVERIFY(classA->typeEntry()->isValue());
-    auto vte = qSharedPointerCast<const ValueTypeEntry>(classA->typeEntry());
+    auto vte = std::static_pointer_cast<const ValueTypeEntry>(classA->typeEntry());
     QVERIFY(vte->hasCustomConversion());
     auto conversion = vte->customConversion();
 
@@ -216,10 +216,10 @@ void TestConversionRuleTag::testConversionRuleTagWithInsertTemplate()
     "// TEMPLATE - target_to_native - END";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     auto *typeDb = TypeDatabase::instance();
     auto typeA = typeDb->findPrimitiveType(u"A"_s);
-    QVERIFY(!typeA.isNull());
+    QVERIFY(typeA);
 
     QVERIFY(typeA->hasCustomConversion());
     auto conversion = typeA->customConversion();
diff --git a/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp b/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp
index 8b1b23a49..e225f91a1 100644
--- a/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp
@@ -19,17 +19,17 @@ void TestCtorInformation::testCtorIsPrivate()
                                 <value-type name='CtorLess'/>\n\
                            </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
     auto klass = AbstractMetaClass::findClass(classes, u"Control");
-    QVERIFY(!klass.isNull());
+    QVERIFY(klass);
     QVERIFY(klass->hasNonPrivateConstructor());
     klass = AbstractMetaClass::findClass(classes, u"Subject");
-    QVERIFY(!klass.isNull());
+    QVERIFY(klass);
     QVERIFY(!klass->hasNonPrivateConstructor());
     klass = AbstractMetaClass::findClass(classes, u"CtorLess");
-    QVERIFY(!klass.isNull());
+    QVERIFY(klass);
     QVERIFY(klass->hasNonPrivateConstructor());
 }
 
@@ -45,7 +45,7 @@ void TestCtorInformation::testHasNonPrivateCtor()
                                 <object-type name='Derived'/>\n\
                            </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     const auto base = AbstractMetaClass::findClass(classes, u"Base");
diff --git a/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp b/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp
index 2e07b8cba..0f65b1fc8 100644
--- a/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp
@@ -56,7 +56,7 @@ void TestDropTypeEntries::testDropEntries()
         u"Foo.NamespaceA.InnerNamespaceA"_s};
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false,
                                                                 QString(), droppedEntries));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QVERIFY(AbstractMetaClass::findClass(classes, u"ValueA"));
@@ -79,7 +79,7 @@ void TestDropTypeEntries::testDropEntries()
 void TestDropTypeEntries::testDontDropEntries()
 {
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QVERIFY(AbstractMetaClass::findClass(classes, u"ValueA"));
@@ -115,7 +115,7 @@ void TestDropTypeEntries::testDropEntryWithChildTags()
     QStringList droppedEntries(u"Foo.ValueA"_s);
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode2, xmlCode2, false,
                                                                 QString(), droppedEntries));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     QVERIFY(!AbstractMetaClass::findClass(builder->classes(), u"ValueA"));
 }
 
@@ -123,7 +123,7 @@ void TestDropTypeEntries::testDropEntryWithChildTags()
 void TestDropTypeEntries::testDontDropEntryWithChildTags()
 {
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode2, xmlCode2, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     QVERIFY(AbstractMetaClass::findClass(builder->classes(), u"ValueA"));
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp b/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp
index 11b0f6b62..de4cfd9f8 100644
--- a/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp
@@ -25,14 +25,14 @@ private:
 </typesystem>)";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     auto klass = AbstractMetaClass::findClass(classes, u"Control");
-    QVERIFY(!klass.isNull());
+    QVERIFY(klass);
     QVERIFY(!klass->hasPrivateDestructor());
     klass = AbstractMetaClass::findClass(classes, u"Subject");
-    QVERIFY(!klass.isNull());
+    QVERIFY(klass);
     QVERIFY(klass->hasPrivateDestructor());
 }
 
@@ -53,14 +53,14 @@ protected:
 </typesystem>)";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     auto klass = AbstractMetaClass::findClass(classes, u"Control");
-    QVERIFY(!klass.isNull());
+    QVERIFY(klass);
     QVERIFY(!klass->hasProtectedDestructor());
     klass = AbstractMetaClass::findClass(classes, u"Subject");
-    QVERIFY(!klass.isNull());
+    QVERIFY(klass);
     QVERIFY(klass->hasProtectedDestructor());
 }
 
@@ -81,14 +81,14 @@ protected:
 </typesystem>)";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     auto klass = AbstractMetaClass::findClass(classes, u"Control");
-    QVERIFY(!klass.isNull());
+    QVERIFY(klass);
     QVERIFY(!klass->hasVirtualDestructor());
     klass = AbstractMetaClass::findClass(classes, u"Subject");
-    QVERIFY(!klass.isNull());
+    QVERIFY(klass);
     QVERIFY(klass->hasVirtualDestructor());
 }
 
@@ -106,22 +106,22 @@ class Subject : public SubjectBase {};
 </typesystem>
 )XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 4);
 
     auto klass = AbstractMetaClass::findClass(classes, u"ControlBase");
-    QVERIFY(!klass.isNull());
+    QVERIFY(klass);
     QVERIFY(!klass->hasVirtualDestructor());
     klass = AbstractMetaClass::findClass(classes, u"Control");
-    QVERIFY(!klass.isNull());
+    QVERIFY(klass);
     QVERIFY(!klass->hasVirtualDestructor());
 
     klass = AbstractMetaClass::findClass(classes, u"SubjectBase");
-    QVERIFY(!klass.isNull());
+    QVERIFY(klass);
     QVERIFY(klass->hasVirtualDestructor());
     klass = AbstractMetaClass::findClass(classes, u"Subject");
-    QVERIFY(!klass.isNull());
+    QVERIFY(klass);
     QVERIFY(klass->hasVirtualDestructor());
 }
 
@@ -142,14 +142,14 @@ protected:
 </typesystem>)";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     auto klass = AbstractMetaClass::findClass(classes, u"Control");
-    QVERIFY(!klass.isNull());
+    QVERIFY(klass);
     QVERIFY(klass->isPolymorphic());
     klass = AbstractMetaClass::findClass(classes, u"Subject");
-    QVERIFY(!klass.isNull());
+    QVERIFY(klass);
     QVERIFY(klass->isPolymorphic());
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testenum.cpp b/sources/shiboken6/ApiExtractor/tests/testenum.cpp
index 018c0d231..8a1f6c886 100644
--- a/sources/shiboken6/ApiExtractor/tests/testenum.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testenum.cpp
@@ -38,7 +38,7 @@ void TestEnum::testEnumCppSignature()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
 
@@ -93,7 +93,7 @@ void TestEnum::testEnumWithApiVersion()
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 true, u"0.1"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
     QCOMPARE(classes[0]->enums().size(), 1);
@@ -119,7 +119,7 @@ void TestEnum::testAnonymousEnum()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
     QCOMPARE(globalEnums.size(), 1);
@@ -174,7 +174,7 @@ void TestEnum::testGlobalEnums()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
     QCOMPARE(globalEnums.size(), 2);
@@ -222,7 +222,7 @@ void TestEnum::testEnumValueFromNeighbourEnum()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
@@ -284,10 +284,10 @@ void TestEnum::testEnumValueFromExpression()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassPtr classA = AbstractMetaClass::findClass(builder->classes(), u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
 
     auto enumA = classA->findEnum(u"EnumA"_s);
     QVERIFY(enumA.has_value());
@@ -362,10 +362,10 @@ void TestEnum::testPrivateEnum()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     QCOMPARE(classA->enums().size(), 2);
 
     auto privateEnum = classA->findEnum(u"PrivateEnum"_s);
@@ -401,7 +401,7 @@ void TestEnum::testTypedefEnum()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
     QCOMPARE(globalEnums.size(), 1);
@@ -426,7 +426,7 @@ void TestEnum::testTypedefEnum()
 
 struct EnumDefaultValuesFixture
 {
-    QSharedPointer<AbstractMetaBuilder> builder;
+    std::shared_ptr<AbstractMetaBuilder> builder;
 
     AbstractMetaType globalEnum;
     AbstractMetaType testEnum;
@@ -462,7 +462,7 @@ namespace Test2
 )";
 
     fixture->builder.reset(TestUtil::parse(cppCode, xmlCode, false));
-    if (fixture->builder.isNull())
+    if (!fixture->builder)
         return -1;
 
     const auto globalEnums = fixture->builder->globalEnums();
@@ -479,15 +479,15 @@ namespace Test2
             break;
         }
     }
-    if (testNamespace.isNull())
+    if (!testNamespace)
         return -3;
 
     const auto namespaceEnums = testNamespace->enums();
     if (namespaceEnums.size() != 2)
         return -4;
     QList<EnumTypeEntryCPtr > enumTypeEntries{
-        qSharedPointerCast<const EnumTypeEntry>(namespaceEnums.at(0).typeEntry()),
-        qSharedPointerCast<const EnumTypeEntry>(namespaceEnums.at(1).typeEntry())};
+        std::static_pointer_cast<const EnumTypeEntry>(namespaceEnums.at(0).typeEntry()),
+        std::static_pointer_cast<const EnumTypeEntry>(namespaceEnums.at(1).typeEntry())};
     if (enumTypeEntries.constFirst()->flags())
         std::swap(enumTypeEntries[0], enumTypeEntries[1]);
     fixture->testEnum = AbstractMetaType(enumTypeEntries.at(0));
diff --git a/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp b/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp
index befa3a2b9..63d02bb7c 100644
--- a/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp
@@ -21,10 +21,10 @@ void TestExtraInclude::testClassExtraInclude()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
 
     QList<Include> includes = classA->typeEntry()->extraIncludes();
     QCOMPARE(includes.size(), 1);
@@ -44,13 +44,13 @@ void TestExtraInclude::testGlobalExtraIncludes()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QVERIFY(AbstractMetaClass::findClass(classes, u"A"));
 
     auto *td = TypeDatabase::instance();
     TypeSystemTypeEntryCPtr module = td->defaultTypeSystemType();
-    QVERIFY(!module.isNull());
+    QVERIFY(module);
     QCOMPARE(module->name(), u"Foo");
 
     QList<Include> includes = module->extraIncludes();
diff --git a/sources/shiboken6/ApiExtractor/tests/testfunctiontag.cpp b/sources/shiboken6/ApiExtractor/tests/testfunctiontag.cpp
index 4a98047f1..18eaf5774 100644
--- a/sources/shiboken6/ApiExtractor/tests/testfunctiontag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testfunctiontag.cpp
@@ -23,7 +23,7 @@ void TestFunctionTag::testFunctionTagForSpecificSignature()
         <function signature='globalFunction(int)'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     TypeEntryCPtr func = TypeDatabase::instance()->findType(u"globalFunction"_s);
     QVERIFY(func);
@@ -41,10 +41,10 @@ void TestFunctionTag::testFunctionTagForAllSignatures()
         <function signature='globalFunction(float)'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     TypeEntryCPtr func = TypeDatabase::instance()->findType(u"globalFunction"_s);
-    QVERIFY(!func.isNull());
+    QVERIFY(func);
     QCOMPARE(builder->globalFunctions().size(), 2);
 }
 
@@ -56,10 +56,10 @@ void TestFunctionTag::testRenameGlobalFunction()
         <function signature='global_function_with_ugly_name()' rename='smooth'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     TypeEntryCPtr func = TypeDatabase::instance()->findType(u"global_function_with_ugly_name"_s);
-    QVERIFY(!func.isNull());
+    QVERIFY(func);
 
     QCOMPARE(builder->globalFunctions().size(), 1);
     const auto metaFunc = builder->globalFunctions().constFirst();
diff --git a/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp b/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp
index 5c33512b7..56b80aaef 100644
--- a/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp
@@ -29,7 +29,7 @@ void TestImplicitConversions::testWithPrivateCtors()
         <value-type name='C'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
 
@@ -59,7 +59,7 @@ void TestImplicitConversions::testWithModifiedVisibility()
 </typesystem>
 )";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
@@ -93,7 +93,7 @@ void TestImplicitConversions::testWithAddedCtor()
         <value-type name='C'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
 
@@ -120,7 +120,7 @@ void TestImplicitConversions::testWithExternalConversionOperator()
         <value-type name='B'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
@@ -135,7 +135,7 @@ void TestImplicitConversions::testWithExternalConversionOperator()
         if (func->isConversionOperator())
             convOp = func;
     }
-    QVERIFY(!convOp.isNull());
+    QVERIFY(convOp);
     QCOMPARE(implicitConvs.constFirst(), convOp);
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp b/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp
index a063b37d0..639925729 100644
--- a/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp
@@ -25,11 +25,11 @@ void TestInsertTemplate::testInsertTemplateOnClassInjectCode()
         </value-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     QCOMPARE(classA->typeEntry()->codeSnips().size(), 1);
     QString code = classA->typeEntry()->codeSnips().constFirst().code();
     QVERIFY(code.contains(u"code template content"));
@@ -48,12 +48,12 @@ void TestInsertTemplate::testInsertTemplateOnModuleInjectCode()
         </inject-code>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QVERIFY(classes.isEmpty());
 
     TypeSystemTypeEntryCPtr module = TypeDatabase::instance()->defaultTypeSystemType();
-    QVERIFY(!module.isNull());
+    QVERIFY(module);
     QCOMPARE(module->name(), u"Foo");
     QCOMPARE(module->codeSnips().size(), 1);
     QString code = module->codeSnips().constFirst().code().trimmed();
diff --git a/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp b/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp
index 49c5b525f..ad9a071da 100644
--- a/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp
@@ -33,9 +33,9 @@ R"(<typesystem package="Foo">
 </typesystem>
 )";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     DocModificationList docMods = classA->typeEntry()->docModifications();
     QCOMPARE(docMods.size(), 2);
     QCOMPARE(docMods[0].code().trimmed(), u"<brief>Modified Brief</brief>");
@@ -94,11 +94,11 @@ void TestModifyDocumentation::testInjectAddedFunctionDocumentation()
 </typesystem>
 )XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     const auto f = classA->findFunction(u"foo");
-    QVERIFY(!f.isNull());
+    QVERIFY(f);
     QVERIFY(f->isUserAdded());
     auto docMods = f->addedFunctionDocModifications();
     QCOMPARE(docMods.size(), 1);
diff --git a/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp b/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
index 4f98c7240..c08f5a829 100644
--- a/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
@@ -46,11 +46,11 @@ void TestModifyFunction::testRenameArgument()
 
     const QByteArray xmlCode = QByteArray(xmlCode1) + pattern + QByteArray(xmlCode2);
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode.constData(), false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
     const auto func = classA->findFunction(u"method");
-    QVERIFY(!func.isNull());
+    QVERIFY(func);
 
     QCOMPARE(func->argumentName(1), u"otherArg");
 }
@@ -74,11 +74,11 @@ void TestModifyFunction::testOwnershipTransfer()
         </object-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
     const auto func = classB->findFunction(u"method");
-    QVERIFY(!func.isNull());
+    QVERIFY(func);
 
     QCOMPARE(func->argumentTargetOwnership(func->ownerClass(), 0),
              TypeSystem::CppOwnership);
@@ -124,7 +124,7 @@ void TestModifyFunction::invalidateAfterUse()
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 false, u"0.1"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
     auto func = classB->findFunction(u"call");
@@ -133,7 +133,7 @@ void TestModifyFunction::invalidateAfterUse()
     QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse());
 
     const auto classC = AbstractMetaClass::findClass(classes, u"C");
-    QVERIFY(!classC.isNull());
+    QVERIFY(classC);
     func = classC->findFunction(u"call");
     QCOMPARE(func->modifications().size(), 1);
     QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
@@ -157,7 +157,7 @@ void TestModifyFunction::invalidateAfterUse()
     QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse());
 
     const auto classE = AbstractMetaClass::findClass(classes, u"E");
-    QVERIFY(!classE.isNull());
+    QVERIFY(classE);
     func = classE->findFunction(u"call");
     QVERIFY(func);
     QCOMPARE(func->modifications().size(), 1);
@@ -197,7 +197,7 @@ void TestModifyFunction::testWithApiVersion()
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 false, u"0.1"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
     auto func = classB->findFunction(u"method");
@@ -236,34 +236,34 @@ struct A {
 )XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 false, u"0.1"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
 
     // Nothing specified, true
     const auto f1 = classA->findFunction(u"f1");
-    QVERIFY(!f1.isNull());
+    QVERIFY(f1);
     QVERIFY(!f1->allowThread());
 
     // 'auto' specified, should be false for nontrivial function
     const auto f2 = classA->findFunction(u"f2");
-    QVERIFY(!f2.isNull());
+    QVERIFY(f2);
     QVERIFY(f2->allowThread());
 
     // 'no' specified, should be false
     const auto f3 = classA->findFunction(u"f3");
-    QVERIFY(!f3.isNull());
+    QVERIFY(f3);
     QVERIFY(!f3->allowThread());
 
     // Nothing specified, should be false for simple getter
     const auto getter1 = classA->findFunction(u"getter1");
-    QVERIFY(!getter1.isNull());
+    QVERIFY(getter1);
     QVERIFY(!getter1->allowThread());
 
     // Forced to true simple getter
     const auto getter2 = classA->findFunction(u"getter2");
-    QVERIFY(!getter2.isNull());
+    QVERIFY(getter2);
     QVERIFY(getter2->allowThread()); // Forced to true simple getter
 }
 
@@ -286,7 +286,7 @@ void TestModifyFunction::testGlobalFunctionModification()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     QCOMPARE(builder->globalFunctions().size(), 1);
 
     auto *td = TypeDatabase::instance();
@@ -434,24 +434,24 @@ void TestModifyFunction::testScopedModifications()
     QFETCH(bool, expectedAllowThread);
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode.constData(), xmlCode.constData(), false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
 
     auto f = classA->findFunction(QStringLiteral("unspecified"));
-    QVERIFY(!f.isNull());
+    QVERIFY(f);
     QCOMPARE(f->exceptionSpecification(), ExceptionSpecification::Unknown);
     QCOMPARE(f->generateExceptionHandling(), expectedGenerateUnspecified);
     QCOMPARE(f->allowThread(), expectedAllowThread);
 
     f = classA->findFunction(QStringLiteral("nonThrowing"));
-    QVERIFY(!f.isNull());
+    QVERIFY(f);
     QCOMPARE(f->exceptionSpecification(), ExceptionSpecification::NoExcept);
     QCOMPARE(f->generateExceptionHandling(), expectedGenerateNonThrowing);
 
     f = classA->findFunction(QStringLiteral("throwing"));
-    QVERIFY(!f.isNull());
+    QVERIFY(f);
     QCOMPARE(f->exceptionSpecification(), ExceptionSpecification::Throws);
     QCOMPARE(f->generateExceptionHandling(), expectedGenerateThrowing);
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp b/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp
index 62f95b67e..e47aa7682 100644
--- a/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp
@@ -31,7 +31,7 @@ void TestMultipleInheritance::testVirtualClass()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 4);
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
index fe7055343..974dd0bd8 100644
--- a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
@@ -31,14 +31,14 @@ void NamespaceTest::testNamespaceMembers()
         </namespace-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto ns = AbstractMetaClass::findClass(classes, u"Namespace");
-    QVERIFY(!ns.isNull());
+    QVERIFY(ns);
     auto metaEnum = ns->findEnum(u"Option"_s);
     QVERIFY(metaEnum.has_value());
     const auto func = ns->findFunction(u"foo");
-    QVERIFY(!func.isNull());
+    QVERIFY(func);
 }
 
 void NamespaceTest::testNamespaceInnerClassMembers()
@@ -61,16 +61,16 @@ void NamespaceTest::testNamespaceInnerClassMembers()
         </namespace-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto ons = AbstractMetaClass::findClass(classes, u"OuterNamespace");
-    QVERIFY(!ons.isNull());
+    QVERIFY(ons);
     const auto ins = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace");
-    QVERIFY(!ins.isNull());
+    QVERIFY(ins);
     const auto sc = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace::SomeClass");
-    QVERIFY(!sc.isNull());
+    QVERIFY(sc);
     const auto meth = sc->findFunction(u"method");
-    QVERIFY(!meth.isNull());
+    QVERIFY(meth);
 }
 
 QTEST_APPLESS_MAIN(NamespaceTest)
diff --git a/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp b/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp
index 028af5e1d..9af411b1a 100644
--- a/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp
@@ -43,14 +43,14 @@ void TestNestedTypes::testNestedTypesModifications()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
     const auto ons = AbstractMetaClass::findClass(classes, u"OuterNamespace");
-    QVERIFY(!ons.isNull());
+    QVERIFY(ons);
 
     const auto ins = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace");
-    QVERIFY(!ins.isNull());
+    QVERIFY(ins);
     QCOMPARE(ins->functions().size(), 1);
     QCOMPARE(ins->typeEntry()->codeSnips().size(), 1);
     CodeSnip snip = ins->typeEntry()->codeSnips().constFirst();
@@ -70,7 +70,7 @@ void TestNestedTypes::testNestedTypesModifications()
 
     const auto sc =
         AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace::SomeClass");
-    QVERIFY(!sc.isNull());
+    QVERIFY(sc);
     QCOMPARE(sc->functions().size(), 2); // default constructor and removed method
     const auto removedFunc = sc->functions().constLast();
     QVERIFY(removedFunc->isModifiedRemoved());
@@ -93,23 +93,23 @@ void TestNestedTypes::testDuplicationOfNestedTypes()
     </typesystem>\n";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     const auto nspace = AbstractMetaClass::findClass(classes, u"Namespace");
-    QVERIFY(!nspace.isNull());
+    QVERIFY(nspace);
     const auto cls1 = AbstractMetaClass::findClass(classes, u"SomeClass");
-    QVERIFY(!cls1.isNull());
+    QVERIFY(cls1);
     const auto cls2 = AbstractMetaClass::findClass(classes, u"Namespace::SomeClass");
-    QVERIFY(!cls2.isNull());
+    QVERIFY(cls2);
     QCOMPARE(cls1, cls2);
     QCOMPARE(cls1->name(), u"SomeClass");
     QCOMPARE(cls1->qualifiedCppName(), u"Namespace::SomeClass");
 
     auto t1 = TypeDatabase::instance()->findType(u"Namespace::SomeClass"_s);
-    QVERIFY(!t1.isNull());
+    QVERIFY(t1);
     auto t2 = TypeDatabase::instance()->findType(u"SomeClass"_s);
-    QVERIFY(t2.isNull());
+    QVERIFY(!t2);
 }
 
 QTEST_APPLESS_MAIN(TestNestedTypes)
diff --git a/sources/shiboken6/ApiExtractor/tests/testnumericaltypedef.cpp b/sources/shiboken6/ApiExtractor/tests/testnumericaltypedef.cpp
index 8dc9b641b..9eef7ec47 100644
--- a/sources/shiboken6/ApiExtractor/tests/testnumericaltypedef.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testnumericaltypedef.cpp
@@ -24,7 +24,7 @@ void TestNumericalTypedef::testNumericalTypedef()
         <function signature='funcReal(real)'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     QCOMPARE(builder->globalFunctions().size(), 2);
     auto funcDouble = builder->globalFunctions().constFirst();
@@ -63,7 +63,7 @@ void TestNumericalTypedef::testUnsignedNumericalTypedef()
         <function signature='funcUShort(custom_ushort)'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     QCOMPARE(builder->globalFunctions().size(), 2);
     auto funcUnsignedShort = builder->globalFunctions().constFirst();
diff --git a/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp b/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp
index 76ce7a1e1..b941094f8 100644
--- a/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp
@@ -23,15 +23,15 @@ void TestPrimitiveTypeTag::testPrimitiveTypeDefaultConstructor()
         <object-type name='B'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    QVERIFY(!classB.isNull());
+    QVERIFY(classB);
 
     auto typeEntry = TypeDatabase::instance()->findPrimitiveType(u"A"_s);
-    QVERIFY(!typeEntry.isNull());
+    QVERIFY(typeEntry);
     QVERIFY(typeEntry->hasDefaultConstructor());
     QCOMPARE(typeEntry->defaultConstructor(), u"A()");
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp b/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp
index 76eccf27c..22f8b7a8e 100644
--- a/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp
@@ -32,11 +32,11 @@ void TestRefCountTag::testReferenceCountTag()
         </object-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
     const auto func = classB->findFunction(u"keepObject");
-    QVERIFY(!func.isNull());
+    QVERIFY(func);
     const auto refCount =
         func->modifications().constFirst().argument_mods().constFirst().referenceCounts().constFirst();
     QCOMPARE(refCount.action, ReferenceCount::Add);
@@ -66,11 +66,11 @@ void TestRefCountTag::testWithApiVersion()
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
                                                                 false, u"0.1"_s));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
     const auto func = classB->findFunction(u"keepObject");
-    QVERIFY(!func.isNull());
+    QVERIFY(func);
     const auto refCount =
         func->modifications().constFirst().argument_mods().constFirst().referenceCounts().constFirst();
     QCOMPARE(refCount.action, ReferenceCount::Add);
diff --git a/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp b/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp
index 89a5f78c6..e3b18758b 100644
--- a/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp
@@ -23,12 +23,12 @@ void TestReferenceToPointer::testReferenceToPointerArgument()
         <object-type name='B'/>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    QVERIFY(!classB.isNull());
+    QVERIFY(classB);
     const auto func = classB->findFunction(u"dummy");
-    QVERIFY(!func.isNull());
+    QVERIFY(func);
     QCOMPARE(func->arguments().constFirst().type().minimalSignature(), u"A*&");
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp b/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp
index 7f8244160..a12675855 100644
--- a/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp
@@ -23,10 +23,10 @@ void TestRemoveField::testRemoveField()
         </value-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     QCOMPARE(classA->fields().size(), 1);
     const AbstractMetaField &fieldA = classA->fields().constFirst();
     QCOMPARE(fieldA.name(), u"fieldA");
diff --git a/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp b/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp
index 5d22739c7..e6c5eb0c1 100644
--- a/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp
@@ -30,15 +30,15 @@ void TestRemoveImplConv::testRemoveImplConv()
         </value-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    QVERIFY(!classB.isNull());
+    QVERIFY(classB);
     const auto classC = AbstractMetaClass::findClass(classes, u"C");
-    QVERIFY(!classC.isNull());
+    QVERIFY(classC);
     const auto implConv = classC->implicitConversions();
     QCOMPARE(implConv.size(), 1);
     QCOMPARE(implConv.constFirst()->arguments().constFirst().type().typeEntry(),
diff --git a/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp b/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp
index 29f5ec2b5..c2a91c8a9 100644
--- a/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp
@@ -68,10 +68,10 @@ struct A {
         </object-type>\n\
     </typesystem>\n";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 14);
     QStringList removedSignatures;
     removedSignatures.append(u"operator>>(char&)"_s);
diff --git a/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp b/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
index b87bfb6a1..8251226b2 100644
--- a/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
@@ -45,12 +45,12 @@ void TestResolveType::testResolveReturnTypeFromParentScope()
         </namespace-type>
     </typesystem>)XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classD = AbstractMetaClass::findClass(classes, u"A::D");
-    QVERIFY(!classD.isNull());
+    QVERIFY(classD);
     const auto meth = classD->findFunction(u"method");
-    QVERIFY(!meth.isNull());
+    QVERIFY(meth);
     QVERIFY(meth);
 }
 
@@ -60,7 +60,7 @@ void TestResolveType::testResolveReturnTypeFromParentScope()
 
 struct DefaultValuesFixture
 {
-    QSharedPointer<AbstractMetaBuilder> builder;
+    std::shared_ptr<AbstractMetaBuilder> builder;
 
     AbstractMetaType intType;
     AbstractMetaType stringType;
@@ -106,7 +106,7 @@ public:
 )";
 
     fixture->builder.reset(TestUtil::parse(cppCode, xmlCode, false));
-    if (fixture->builder.isNull())
+    if (!fixture->builder)
         return -1;
 
     for (const auto &klass : fixture->builder->classes()) {
@@ -135,7 +135,7 @@ public:
         return -3;
 
     auto listFunc = fixture->klass->findFunction(u"listFunc"_s);
-    if (listFunc.isNull() || listFunc->arguments().size() != 1)
+    if (!listFunc || listFunc->arguments().size() != 1)
         return -3;
     fixture->listType = listFunc->arguments().constFirst().type();
 
@@ -251,16 +251,16 @@ public:
 )";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto testClass = AbstractMetaClass::findClass(classes, u"Test");
-    QVERIFY(!testClass.isNull());
+    QVERIFY(testClass);
 
     auto *tdb = TypeDatabase::instance();
     auto int32TEntry = tdb->findType(u"int32_t"_s);
-    QVERIFY2(!int32TEntry.isNull(), "int32_t not found");
+    QVERIFY2(int32TEntry, "int32_t not found");
     QVERIFY(int32TEntry->isPrimitive());
-    auto int32T = qSharedPointerCast<const PrimitiveTypeEntry>(int32TEntry);
+    auto int32T = std::static_pointer_cast<const PrimitiveTypeEntry>(int32TEntry);
     auto basicType = basicReferencedTypeEntry(int32T);
     QVERIFY2(basicType != int32T,
              "Typedef for int32_t not found. Check the system include paths.");
diff --git a/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp b/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp
index 9bebf1c10..fcbdbc4e6 100644
--- a/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp
@@ -25,10 +25,10 @@ void TestReverseOperators::testReverseSum()
     </typesystem>";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 4);
 
     AbstractMetaFunctionCPtr reverseOp;
@@ -42,10 +42,10 @@ void TestReverseOperators::testReverseSum()
         }
     }
 
-    QVERIFY(!normalOp.isNull());
+    QVERIFY(normalOp);
     QVERIFY(!normalOp->isReverseOperator());
     QCOMPARE(normalOp->arguments().size(), 1);
-    QVERIFY(!reverseOp.isNull());
+    QVERIFY(reverseOp);
     QVERIFY(reverseOp->isReverseOperator());
     QCOMPARE(reverseOp->arguments().size(), 1);
 }
@@ -67,14 +67,14 @@ void TestReverseOperators::testReverseSumWithAmbiguity()
     </typesystem>";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 4);
 
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    QVERIFY(!classB.isNull());
+    QVERIFY(classB);
     QCOMPARE(classB->functions().size(), 4);
 
     AbstractMetaFunctionCPtr reverseOp;
@@ -87,11 +87,11 @@ void TestReverseOperators::testReverseSumWithAmbiguity()
                 normalOp = func;
         }
     }
-    QVERIFY(!normalOp.isNull());
+    QVERIFY(normalOp);
     QVERIFY(!normalOp->isReverseOperator());
     QCOMPARE(normalOp->arguments().size(), 1);
     QCOMPARE(normalOp->minimalSignature(), u"operator+(B,A)");
-    QVERIFY(!reverseOp.isNull());
+    QVERIFY(reverseOp);
     QVERIFY(reverseOp->isReverseOperator());
     QCOMPARE(reverseOp->arguments().size(), 1);
     QCOMPARE(reverseOp->minimalSignature(), u"operator+(A,B)");
@@ -111,11 +111,11 @@ void  TestReverseOperators::testSpaceshipOperator()
         </typesystem>)";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false,
                                                                 {}, {}, LanguageLevel::Cpp20));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
     const auto testClass = AbstractMetaClass::findClass(classes, u"Test");
-    QVERIFY(!testClass.isNull());
+    QVERIFY(testClass);
     const auto &functions = testClass->functions();
     // 6 operators should be synthesized
     const auto count = std::count_if(functions.cbegin(), functions.cend(),
diff --git a/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp b/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
index 3be0a9a35..5462bb5b3 100644
--- a/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
@@ -55,13 +55,13 @@ namespace Internet {
 </typesystem>)XML").arg(file.fileName());
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, qPrintable(xmlCode1), false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
     const auto classB = AbstractMetaClass::findClass(classes, u"Bookmarks");
-    QVERIFY(!classB.isNull());
+    QVERIFY(classB);
     const auto func = classB->findFunction(u"list");
-    QVERIFY(!func.isNull());
+    QVERIFY(func);
     AbstractMetaType funcType = func->type();
     QVERIFY(!funcType.isVoid());
     QCOMPARE(funcType.cppSignature(), u"QList<Internet::Url >");
@@ -93,15 +93,15 @@ namespace Namespace {
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    QVERIFY(!classB.isNull());
+    QVERIFY(classB);
     QVERIFY(!classB->baseClass());
     QVERIFY(classB->baseClassName().isEmpty());
     const auto func = classB->findFunction(u"foo");
-    QVERIFY(!func.isNull());
+    QVERIFY(func);
     AbstractMetaType argType = func->arguments().constFirst().type();
     QCOMPARE(argType.instantiations().size(), 1);
     QCOMPARE(argType.typeEntry()->qualifiedCppName(), u"QList");
@@ -130,7 +130,7 @@ void func(List<int> arg) {}
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     const auto globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.size(), 1);
 
@@ -155,7 +155,7 @@ void func(List<int>* arg) {}
  </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaFunctionCList globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.size(), 1);
 
@@ -180,7 +180,7 @@ void func(List<int>& arg) {}
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     const auto globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.size(), 1);
 
@@ -209,19 +209,19 @@ struct List {
  </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     const AbstractMetaClassList templates = builder->templates();
 
     QCOMPARE(templates.size(), 1);
     AbstractMetaClassCPtr list = templates.constFirst();
     // Verify that the parameter of "void append(List l)" gets fixed to "List<T >"
     const auto append = list->findFunction(QStringLiteral("append"));
-    QVERIFY(!append.isNull());
+    QVERIFY(append);
     QCOMPARE(append->arguments().size(), 1);
     QCOMPARE(append->arguments().at(0).type().cppSignature(), u"List<T >");
     // Verify that the parameter of "void erase(Iterator)" is not modified
     const auto erase = list->findFunction(QStringLiteral("erase"));
-    QVERIFY(!erase.isNull());
+    QVERIFY(erase);
     QCOMPARE(erase->arguments().size(), 1);
     QEXPECT_FAIL("", "Clang: Some other code changes the parameter type", Abort);
     QCOMPARE(erase->arguments().at(0).type().cppSignature(), u"List::Iterator");
@@ -250,7 +250,7 @@ struct FooBars : public ListContainer<FooBar> {};
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     AbstractMetaClassList templates = builder->templates();
     QCOMPARE(classes.size(), 2);
@@ -287,11 +287,11 @@ template<SomeEnum type> struct Future {};
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    QVERIFY(!classB.isNull());
+    QVERIFY(classB);
     QVERIFY(!classB->baseClass());
     QVERIFY(classB->baseClassName().isEmpty());
     // 3 functions: simple constructor, copy constructor and "method()".
@@ -326,11 +326,11 @@ template<SomeEnum type> struct Future {};
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
     const auto classB = AbstractMetaClass::findClass(classes, u"Namespace::B");
-    QVERIFY(!classB.isNull());
+    QVERIFY(classB);
     QVERIFY(!classB->baseClass());
     QVERIFY(classB->baseClassName().isEmpty());
     // 3 functions: simple constructor, copy constructor and "method()".
@@ -362,14 +362,14 @@ typedef BaseTemplateClass<TypeOne> TypeOneClass;
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
 
     const auto base = AbstractMetaClass::findClass(classes, u"BaseTemplateClass");
-    QVERIFY(!base.isNull());
+    QVERIFY(base);
     const auto one = AbstractMetaClass::findClass(classes, u"TypeOneClass");
-    QVERIFY(!one.isNull());
+    QVERIFY(one);
     QCOMPARE(one->templateBaseClass(), base);
     QCOMPARE(one->functions().size(), base->functions().size());
     QVERIFY(one->isTypeDef());
@@ -411,24 +411,24 @@ typedef Vector<int> IntVector;
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
 
     const auto vector = AbstractMetaClass::findClass(classes, u"IntVector");
-    QVERIFY(!vector.isNull());
+    QVERIFY(vector);
     auto baseContainer = vector->typeEntry()->baseContainerType();
-    QVERIFY(!baseContainer.isNull());
-    QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(baseContainer.data())->containerKind(),
+    QVERIFY(baseContainer);
+    QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(baseContainer.get())->containerKind(),
              ContainerTypeEntry::ListContainer);
     QCOMPARE(vector->functions().size(), 4);
 
     const auto method = vector->findFunction(u"method");
-    QVERIFY(!method.isNull());
+    QVERIFY(method);
     QCOMPARE(method->signature(), u"method(const Vector<int > & vector)");
 
     const auto otherMethod = vector->findFunction(u"otherMethod");
-    QVERIFY(!otherMethod.isNull());
+    QVERIFY(otherMethod);
     QCOMPARE(otherMethod->signature(), u"otherMethod()");
     QVERIFY(!otherMethod->type().isVoid());
     QCOMPARE(otherMethod->type().cppSignature(), u"Vector<int >");
@@ -455,7 +455,7 @@ Array<int, 2> foo();
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     auto functions = builder->globalFunctions();
     QCOMPARE(functions.size(), 1);
     auto foo = functions.constFirst();
@@ -538,30 +538,30 @@ void TestTemplates::testTemplateTypeDefs()
     const QByteArray cppBa = cpp.toLocal8Bit();
     const QByteArray xmlBa = xml.toLocal8Bit();
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppBa.constData(), xmlBa.constData(), true));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
     const auto optional = AbstractMetaClass::findClass(classes, u"Optional");
-    QVERIFY(!optional.isNull());
+    QVERIFY(optional);
 
     // Find the typedef'ed class
     const auto optionalInt = AbstractMetaClass::findClass(classes, u"IntOptional");
-    QVERIFY(!optionalInt.isNull());
+    QVERIFY(optionalInt);
     QCOMPARE(optionalInt->templateBaseClass(), optional);
 
     // Find the class typedef'ed in the typesystem XML
     const auto xmlOptionalInt = AbstractMetaClass::findClass(classes, u"XmlIntOptional");
-    QVERIFY(!xmlOptionalInt.isNull());
+    QVERIFY(xmlOptionalInt);
     QCOMPARE(xmlOptionalInt->templateBaseClass(), optional);
 
     // Check whether the value() method now has an 'int' return
     const auto valueMethod = optionalInt->findFunction(u"value");
-    QVERIFY(!valueMethod.isNull());
+    QVERIFY(valueMethod);
     QCOMPARE(valueMethod->type().cppSignature(), u"int");
 
     // ditto for typesystem XML
     const auto xmlValueMethod = xmlOptionalInt->findFunction(u"value");
-    QVERIFY(!xmlValueMethod.isNull());
+    QVERIFY(xmlValueMethod);
     QCOMPARE(xmlValueMethod->type().cppSignature(), u"int");
 
     // Check whether the m_value field is of type 'int'
@@ -607,11 +607,11 @@ public:
 </typesystem>)XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
     const auto testClass = AbstractMetaClass::findClass(classes, u"Test");
-    QVERIFY(!testClass.isNull());
+    QVERIFY(testClass);
 
     auto fields = testClass->fields();
     QCOMPARE(fields.size(), 1);
@@ -620,7 +620,7 @@ public:
     QCOMPARE(fieldType.instantiations().size(), 1);
 
     const auto derived = AbstractMetaClass::findClass(classes, u"Derived");
-    QVERIFY(!derived.isNull());
+    QVERIFY(derived);
     auto base = derived->templateBaseClass();
     QCOMPARE(base->name(), u"Container1");
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp b/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp
index 400979c4c..a7c83907b 100644
--- a/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp
@@ -30,7 +30,7 @@ void TestTypeRevision::testRevisionAttr()
                         "</object-type>"
                         "</typesystem>";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto rev0 = AbstractMetaClass::findClass(classes, u"Rev_0");
     QCOMPARE(rev0->typeEntry()->revision(), 0);
@@ -82,7 +82,7 @@ class Bar20 {};
 )XML";
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true, version));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     QCOMPARE(builder->classes().size(), expectedClassCount);
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testvaluetypedefaultctortag.cpp b/sources/shiboken6/ApiExtractor/tests/testvaluetypedefaultctortag.cpp
index 2e762c1f9..19143e895 100644
--- a/sources/shiboken6/ApiExtractor/tests/testvaluetypedefaultctortag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testvaluetypedefaultctortag.cpp
@@ -22,17 +22,17 @@ void TestValueTypeDefaultCtorTag::testValueTypeDefaultCtorTagArgument()
         <value-type name='B' />\n\
     </typesystem>";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
 
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     QVERIFY(classA->typeEntry()->hasDefaultConstructor());
     QCOMPARE(classA->typeEntry()->defaultConstructor(), u"A(0, 0)");
 
     const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    QVERIFY(!classB.isNull());
+    QVERIFY(classB);
     QVERIFY(!classB->typeEntry()->hasDefaultConstructor());
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp b/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp
index daf0d2aa5..b472cbfba 100644
--- a/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp
@@ -17,12 +17,12 @@ void TestVoidArg::testVoidParsedFunction()
         <value-type name='A'/>\n\
     </typesystem>";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     const auto addedFunc = classA->findFunction(u"a");
-    QVERIFY(!addedFunc.isNull());
+    QVERIFY(addedFunc);
     QCOMPARE(addedFunc->arguments().size(), 0);
 }
 
@@ -36,12 +36,12 @@ void TestVoidArg::testVoidAddedFunction()
         </value-type>\n\
     </typesystem>";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     const auto addedFunc = classA->findFunction(u"a");
-    QVERIFY(!addedFunc.isNull());
+    QVERIFY(addedFunc);
     QCOMPARE(addedFunc->arguments().size(), 0);
 
 }
@@ -54,12 +54,12 @@ void TestVoidArg::testVoidPointerParsedFunction()
         <value-type name='A' />\n\
     </typesystem>";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    QVERIFY(!classA.isNull());
+    QVERIFY(classA);
     const auto addedFunc = classA->findFunction(u"a");
-    QVERIFY(!addedFunc.isNull());
+    QVERIFY(addedFunc);
     QCOMPARE(addedFunc->arguments().size(), 1);
 
 }