From a14ea7738f493280f5c7b6e4a8834a7d1daacd1e Mon Sep 17 00:00:00 2001 From: Friedemann Kleint Date: Tue, 20 Oct 2020 09:34:31 +0200 Subject: shiboken2/ApiExtractor tests: Avoid detaching of lists Use constFirst/Last() instead of first()/last(). Change-Id: I3e7c72e3ab72b86565eea087b470f2a51b2999f8 Reviewed-by: Cristian Maureira-Fredes --- .../ApiExtractor/tests/testabstractmetaclass.cpp | 53 +++++++++---------- .../ApiExtractor/tests/testabstractmetatype.cpp | 14 ++--- .../ApiExtractor/tests/testaddfunction.cpp | 16 +++--- .../ApiExtractor/tests/testarrayargument.cpp | 8 +-- .../ApiExtractor/tests/testcodeinjection.cpp | 2 +- .../shiboken2/ApiExtractor/tests/testcontainer.cpp | 3 +- .../ApiExtractor/tests/testconversionoperator.cpp | 24 ++++++--- .../ApiExtractor/tests/testconversionruletag.cpp | 5 +- .../ApiExtractor/tests/testdroptypeentries.cpp | 2 +- sources/shiboken2/ApiExtractor/tests/testenum.cpp | 60 +++++++++++----------- .../ApiExtractor/tests/testextrainclude.cpp | 6 +-- .../ApiExtractor/tests/testfunctiontag.cpp | 7 +-- .../ApiExtractor/tests/testimplicitconversions.cpp | 8 +-- .../ApiExtractor/tests/testinserttemplate.cpp | 4 +- .../ApiExtractor/tests/testmodifyfunction.cpp | 8 +-- .../ApiExtractor/tests/testnestedtypes.cpp | 10 ++-- .../ApiExtractor/tests/testnumericaltypedef.cpp | 16 +++--- .../ApiExtractor/tests/testrefcounttag.cpp | 4 +- .../ApiExtractor/tests/testreferencetopointer.cpp | 2 +- .../ApiExtractor/tests/testremovefield.cpp | 2 +- .../ApiExtractor/tests/testremoveimplconv.cpp | 3 +- .../shiboken2/ApiExtractor/tests/testtemplates.cpp | 27 +++++----- 22 files changed, 152 insertions(+), 132 deletions(-) (limited to 'sources') diff --git a/sources/shiboken2/ApiExtractor/tests/testabstractmetaclass.cpp b/sources/shiboken2/ApiExtractor/tests/testabstractmetaclass.cpp index f0aa4a318..19bfb8464 100644 --- a/sources/shiboken2/ApiExtractor/tests/testabstractmetaclass.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testabstractmetaclass.cpp @@ -57,7 +57,7 @@ void TestAbstractMetaClass::testClassNameUnderNamespace() QVERIFY(!builder.isNull()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.count(), 2); // 1 namespace + 1 class - if (classes.first()->name() != QLatin1String("ClassName")) + if (classes.constFirst()->name() != QLatin1String("ClassName")) qSwap(classes[0], classes[1]); QCOMPARE(classes[0]->name(), QLatin1String("ClassName")); @@ -71,7 +71,7 @@ void TestAbstractMetaClass::testClassNameUnderNamespace() AbstractMetaFunctionList ctors = classes[0]->queryFunctions(AbstractMetaClass::Constructors); QCOMPARE(ctors.size(), 2); - if (ctors.first()->minimalSignature() != QLatin1String("ClassName()")) + if (ctors.constFirst()->minimalSignature() != QLatin1String("ClassName()")) qSwap(ctors[0], ctors[1]); QCOMPARE(ctors[0]->arguments().size(), 0); @@ -149,9 +149,9 @@ public: QVERIFY(f->attributes() & AbstractMetaAttributes::FinalCppClass); // implementing class, ownclass, declaringclass - AbstractMetaFunction* ctorA = a->queryFunctions(AbstractMetaClass::Constructors).first(); - AbstractMetaFunction* ctorB = b->queryFunctions(AbstractMetaClass::Constructors).first(); - AbstractMetaFunction* ctorC = c->queryFunctions(AbstractMetaClass::Constructors).first(); + AbstractMetaFunction *ctorA = a->queryFunctions(AbstractMetaClass::Constructors).constFirst(); + AbstractMetaFunction *ctorB = b->queryFunctions(AbstractMetaClass::Constructors).constFirst(); + AbstractMetaFunction *ctorC = c->queryFunctions(AbstractMetaClass::Constructors).constFirst(); QVERIFY(ctorA->isConstructor()); QVERIFY(!ctorA->isVirtual()); QVERIFY(ctorB->isConstructor()); @@ -241,8 +241,8 @@ void TestAbstractMetaClass::testDefaultValues() QCOMPARE(classes.count(), 2); AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QCOMPARE(classA->queryFunctionsByName(QLatin1String("method")).count(), 1); - AbstractMetaFunction* method = classA->queryFunctionsByName(QLatin1String("method")).first(); - AbstractMetaArgument* arg = method->arguments().first(); + AbstractMetaFunction* method = classA->queryFunctionsByName(QLatin1String("method")).constFirst(); + AbstractMetaArgument* arg = method->arguments().constFirst(); QCOMPARE(arg->defaultValueExpression(), arg->originalDefaultValueExpression()); } @@ -270,8 +270,8 @@ void TestAbstractMetaClass::testModifiedDefaultValues() QCOMPARE(classes.count(), 2); AbstractMetaClass* classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QCOMPARE(classA->queryFunctionsByName(QLatin1String("method")).count(), 1); - AbstractMetaFunction* method = classA->queryFunctionsByName(QLatin1String("method")).first(); - AbstractMetaArgument* arg = method->arguments().first(); + AbstractMetaFunction *method = classA->queryFunctionsByName(QLatin1String("method")).constFirst(); + AbstractMetaArgument *arg = method->arguments().constFirst(); QCOMPARE(arg->defaultValueExpression(), QLatin1String("Hello")); QCOMPARE(arg->originalDefaultValueExpression(), QLatin1String("A::B()")); } @@ -357,21 +357,22 @@ void TestAbstractMetaClass::testSpecialFunctions() QVERIFY(classA); AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors); QCOMPARE(ctors.size(), 2); - QCOMPARE(ctors.first()->functionType(), AbstractMetaFunction::ConstructorFunction); + QCOMPARE(ctors.constFirst()->functionType(), AbstractMetaFunction::ConstructorFunction); QCOMPARE(ctors.at(1)->functionType(), AbstractMetaFunction::CopyConstructorFunction); AbstractMetaFunctionList assigmentOps = classA->queryFunctionsByName(QLatin1String("operator=")); QCOMPARE(assigmentOps.size(), 1); - QCOMPARE(assigmentOps.first()->functionType(), AbstractMetaFunction::AssignmentOperatorFunction); + QCOMPARE(assigmentOps.constFirst()->functionType(), + AbstractMetaFunction::AssignmentOperatorFunction); const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B")); QVERIFY(classB); ctors = classB->queryFunctions(AbstractMetaClass::Constructors); QCOMPARE(ctors.size(), 2); - QCOMPARE(ctors.first()->functionType(), AbstractMetaFunction::ConstructorFunction); + QCOMPARE(ctors.constFirst()->functionType(), AbstractMetaFunction::ConstructorFunction); QCOMPARE(ctors.at(1)->functionType(), AbstractMetaFunction::CopyConstructorFunction); assigmentOps = classA->queryFunctionsByName(QLatin1String("operator=")); QCOMPARE(assigmentOps.size(), 1); - QCOMPARE(assigmentOps.first()->functionType(), AbstractMetaFunction::AssignmentOperatorFunction); + QCOMPARE(assigmentOps.constFirst()->functionType(), AbstractMetaFunction::AssignmentOperatorFunction); } void TestAbstractMetaClass::testClassDefaultConstructors() @@ -424,7 +425,7 @@ void TestAbstractMetaClass::testClassDefaultConstructors() AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors); QCOMPARE(ctors.size(), 2); - if (ctors.first()->minimalSignature() != QLatin1String("A()")) + if (ctors.constFirst()->minimalSignature() != QLatin1String("A()")) qSwap(ctors[0], ctors[1]); QCOMPARE(ctors[0]->arguments().size(), 0); @@ -435,18 +436,18 @@ void TestAbstractMetaClass::testClassDefaultConstructors() AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("B")); QVERIFY(classB); QCOMPARE(classB->functions().size(), 2); - QCOMPARE(classB->functions().first()->minimalSignature(), QLatin1String("B()")); + QCOMPARE(classB->functions().constFirst()->minimalSignature(), QLatin1String("B()")); AbstractMetaClass* classC = AbstractMetaClass::findClass(classes, QLatin1String("C")); QVERIFY(classC); QCOMPARE(classC->functions().size(), 1); - QCOMPARE(classC->functions().first()->minimalSignature(), QLatin1String("C(C)")); + QCOMPARE(classC->functions().constFirst()->minimalSignature(), QLatin1String("C(C)")); AbstractMetaClass* classD = AbstractMetaClass::findClass(classes, QLatin1String("D")); QVERIFY(classD); QCOMPARE(classD->functions().size(), 1); - QCOMPARE(classD->functions().first()->minimalSignature(), QLatin1String("D(D)")); - QVERIFY(classD->functions().first()->isPrivate()); + QCOMPARE(classD->functions().constFirst()->minimalSignature(), QLatin1String("D(D)")); + QVERIFY(classD->functions().constFirst()->isPrivate()); AbstractMetaClass* classE = AbstractMetaClass::findClass(classes, QLatin1String("E")); QVERIFY(classE); @@ -458,7 +459,7 @@ void TestAbstractMetaClass::testClassDefaultConstructors() ctors = classF->queryFunctions(AbstractMetaClass::Constructors); QCOMPARE(ctors.size(), 2); - if (ctors.first()->minimalSignature() != QLatin1String("F(int,int)")) + if (ctors.constFirst()->minimalSignature() != QLatin1String("F(int,int)")) qSwap(ctors[0], ctors[1]); QCOMPARE(ctors[0]->arguments().size(), 2); @@ -491,7 +492,7 @@ void TestAbstractMetaClass::testClassInheritedDefaultConstructors() AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors); QCOMPARE(ctors.size(), 2); - if (ctors.first()->minimalSignature() != QLatin1String("A()")) + if (ctors.constFirst()->minimalSignature() != QLatin1String("A()")) qSwap(ctors[0], ctors[1]); QCOMPARE(ctors[0]->arguments().size(), 0); @@ -505,8 +506,8 @@ void TestAbstractMetaClass::testClassInheritedDefaultConstructors() ctors = classB->queryFunctions(AbstractMetaClass::Constructors); QCOMPARE(ctors.size(), 1); - QCOMPARE(ctors.first()->arguments().size(), 0); - QCOMPARE(ctors.first()->minimalSignature(), QLatin1String("B()")); + QCOMPARE(ctors.constFirst()->arguments().size(), 0); + QCOMPARE(ctors.constFirst()->minimalSignature(), QLatin1String("B()")); } void TestAbstractMetaClass::testAbstractClassDefaultConstructors() @@ -529,8 +530,8 @@ void TestAbstractMetaClass::testAbstractClassDefaultConstructors() AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors); QCOMPARE(ctors.size(), 1); - QCOMPARE(ctors.first()->arguments().size(), 0); - QCOMPARE(ctors.first()->minimalSignature(), QLatin1String("A()")); + QCOMPARE(ctors.constFirst()->arguments().size(), 0); + QCOMPARE(ctors.constFirst()->minimalSignature(), QLatin1String("A()")); } void TestAbstractMetaClass::testObjectTypesMustNotHaveCopyConstructors() @@ -550,8 +551,8 @@ void TestAbstractMetaClass::testObjectTypesMustNotHaveCopyConstructors() AbstractMetaFunctionList ctors = classA->queryFunctions(AbstractMetaClass::Constructors); QCOMPARE(ctors.size(), 1); - QCOMPARE(ctors.first()->arguments().size(), 0); - QCOMPARE(ctors.first()->minimalSignature(), QLatin1String("A()")); + QCOMPARE(ctors.constFirst()->arguments().size(), 0); + QCOMPARE(ctors.constFirst()->minimalSignature(), QLatin1String("A()")); } void TestAbstractMetaClass::testIsPolymorphic() diff --git a/sources/shiboken2/ApiExtractor/tests/testabstractmetatype.cpp b/sources/shiboken2/ApiExtractor/tests/testabstractmetatype.cpp index 63434b3a5..980d08489 100644 --- a/sources/shiboken2/ApiExtractor/tests/testabstractmetatype.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testabstractmetatype.cpp @@ -73,7 +73,7 @@ void TestAbstractMetaType::testConstCharPtrType() QScopedPointer builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); QCOMPARE(builder->globalFunctions().size(), 1); - AbstractMetaFunction* func = builder->globalFunctions().first(); + AbstractMetaFunction *func = builder->globalFunctions().constFirst(); AbstractMetaType* rtype = func->type(); // Test properties of const char* QVERIFY(rtype); @@ -142,11 +142,11 @@ void TestAbstractMetaType::testCharType() AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.size(), 1); - QCOMPARE(classes.first()->package(), QLatin1String("Foo")); + QCOMPARE(classes.constFirst()->package(), QLatin1String("Foo")); AbstractMetaFunctionList functions = builder->globalFunctions(); QCOMPARE(functions.size(), 1); - AbstractMetaFunction* func = functions.first(); + AbstractMetaFunction *func = functions.constFirst(); AbstractMetaType* rtype = func->type(); // Test properties of const char* QVERIFY(rtype); @@ -206,10 +206,10 @@ void TestAbstractMetaType::testTypedefWithTemplates() QCOMPARE(classes.size(), 1); AbstractMetaFunctionList functions = builder->globalFunctions(); QCOMPARE(functions.count(), 1); - AbstractMetaFunction* function = functions.first(); + AbstractMetaFunction *function = functions.constFirst(); AbstractMetaArgumentList args = function->arguments(); QCOMPARE(args.count(), 1); - AbstractMetaArgument* arg = args.first(); + AbstractMetaArgument *arg = args.constFirst(); AbstractMetaType* metaType = arg->type(); QCOMPARE(metaType->cppSignature(), QLatin1String("A")); } @@ -233,11 +233,11 @@ void TestAbstractMetaType::testObjectTypeUsedAsValue() QVERIFY(classA); AbstractMetaFunctionList overloads = classA->queryFunctionsByName(QLatin1String("method")); QCOMPARE(overloads.count(), 1); - AbstractMetaFunction* method = overloads.first(); + AbstractMetaFunction* method = overloads.constFirst(); QVERIFY(method); AbstractMetaArgumentList args = method->arguments(); QCOMPARE(args.count(), 1); - AbstractMetaArgument* arg = args.first(); + AbstractMetaArgument* arg = args.constFirst(); AbstractMetaType* metaType = arg->type(); QCOMPARE(metaType->cppSignature(), QLatin1String("A")); QVERIFY(metaType->isValue()); diff --git a/sources/shiboken2/ApiExtractor/tests/testaddfunction.cpp b/sources/shiboken2/ApiExtractor/tests/testaddfunction.cpp index a131e7fe2..46307f94c 100644 --- a/sources/shiboken2/ApiExtractor/tests/testaddfunction.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testaddfunction.cpp @@ -140,7 +140,7 @@ void TestAddFunction::testAddFunctionConstructor() const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); QCOMPARE(classA->functions().count(), 3); // default and added ctors - AbstractMetaFunction* addedFunc = classA->functions().last(); + AbstractMetaFunction *addedFunc = classA->functions().constLast(); QCOMPARE(addedFunc->visibility(), AbstractMetaFunction::Public); QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::ConstructorFunction); QCOMPARE(addedFunc->arguments().size(), 1); @@ -163,7 +163,7 @@ void TestAddFunction::testAddFunctionTagDefaultValues() const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); QCOMPARE(classA->functions().count(), 3); // default ctor, default copy ctor and the added function - AbstractMetaFunction* addedFunc = classA->functions().last(); + AbstractMetaFunction *addedFunc = classA->functions().constLast(); QCOMPARE(addedFunc->visibility(), AbstractMetaFunction::Public); QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::NormalFunction); QVERIFY(addedFunc->isUserAdded()); @@ -187,7 +187,7 @@ void TestAddFunction::testAddFunctionCodeSnippets() AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); - AbstractMetaFunction* addedFunc = classA->functions().last(); + AbstractMetaFunction *addedFunc = classA->functions().constLast(); QVERIFY(addedFunc->hasInjectedCode()); } @@ -281,8 +281,8 @@ void TestAddFunction::testAddFunctionAtModuleLevel() const FunctionModificationList mods = addedFuncs.constFirst()->modifications; QCOMPARE(mods.size(), 1); - QVERIFY(mods.first().isCodeInjection()); - CodeSnip snip = mods.first().snips.first(); + QVERIFY(mods.constFirst().isCodeInjection()); + CodeSnip snip = mods.constFirst().snips.constFirst(); QCOMPARE(snip.code().trimmed(), QLatin1String("custom_code();")); } @@ -312,7 +312,7 @@ void TestAddFunction::testAddFunctionWithVarargs() QVERIFY(classA); const AbstractMetaFunction* addedFunc = classA->findFunction(QLatin1String("func")); QVERIFY(addedFunc); - const AbstractMetaArgument* arg = addedFunc->arguments().last(); + const AbstractMetaArgument *arg = addedFunc->arguments().constLast(); QVERIFY(arg->type()->isVarargs()); QVERIFY(arg->type()->typeEntry()->isVarargs()); } @@ -458,8 +458,8 @@ void TestAddFunction::testAddFunctionWithTemplateArg() QScopedPointer builder(TestUtil::parse(cppCode, xmlCode)); QVERIFY(!builder.isNull()); QCOMPARE(builder->globalFunctions().size(), 1); - AbstractMetaFunction* func = builder->globalFunctions().first(); - AbstractMetaArgument* arg = func->arguments().first(); + AbstractMetaFunction *func = builder->globalFunctions().constFirst(); + AbstractMetaArgument *arg = func->arguments().constFirst(); QCOMPARE(arg->type()->instantiations().count(), 1); } diff --git a/sources/shiboken2/ApiExtractor/tests/testarrayargument.cpp b/sources/shiboken2/ApiExtractor/tests/testarrayargument.cpp index a8b9a2eff..b7b5ead17 100644 --- a/sources/shiboken2/ApiExtractor/tests/testarrayargument.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testarrayargument.cpp @@ -52,7 +52,7 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByInteger() const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A")); QVERIFY(classA); - const AbstractMetaArgument* arg = classA->functions().last()->arguments().first(); + const AbstractMetaArgument *arg = classA->functions().constLast()->arguments().constFirst(); QVERIFY(arg->type()->isArray()); QCOMPARE(arg->type()->arrayElementCount(), 3); QCOMPARE(arg->type()->arrayElementType()->name(), QLatin1String("double")); @@ -131,7 +131,7 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValue() AbstractMetaEnumValue *nvalues = classA->findEnumValue(QLatin1String("NValues")); QVERIFY(nvalues); - const AbstractMetaArgument* arg = classA->functions().last()->arguments().first(); + const AbstractMetaArgument *arg = classA->functions().constLast()->arguments().constFirst(); QVERIFY(arg->type()->isArray()); QCOMPARE(arg->type()->arrayElementCount(), nvalues->value().value()); QCOMPARE(arg->type()->arrayElementType()->name(), QLatin1String("double")); @@ -157,12 +157,12 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValueFromGlobalEnu const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A")); QVERIFY(classA); - AbstractMetaEnum* someEnum = builder->globalEnums().first(); + AbstractMetaEnum *someEnum = builder->globalEnums().constFirst(); QVERIFY(someEnum); const AbstractMetaEnumValue *nvalues = someEnum->findEnumValue(QLatin1String("NValues")); QVERIFY(nvalues); - const AbstractMetaArgument* arg = classA->functions().last()->arguments().first(); + const AbstractMetaArgument *arg = classA->functions().constLast()->arguments().constFirst(); QVERIFY(arg->type()->isArray()); QCOMPARE(arg->type()->arrayElementCount(), nvalues->value().value()); QCOMPARE(arg->type()->arrayElementType()->name(), QLatin1String("double")); diff --git a/sources/shiboken2/ApiExtractor/tests/testcodeinjection.cpp b/sources/shiboken2/ApiExtractor/tests/testcodeinjection.cpp index aeca2d3f4..eed35552e 100644 --- a/sources/shiboken2/ApiExtractor/tests/testcodeinjection.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testcodeinjection.cpp @@ -79,7 +79,7 @@ void TestCodeInjections::testReadFile() AbstractMetaClassList classes = builder->classes(); const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QCOMPARE(classA->typeEntry()->codeSnips().count(), 1); - QString code = classA->typeEntry()->codeSnips().first().code(); + QString code = classA->typeEntry()->codeSnips().constFirst().code(); QVERIFY(code.indexOf(expected) != -1); code = classA->typeEntry()->conversionRule(); QVERIFY(code.indexOf(expected) != -1); diff --git a/sources/shiboken2/ApiExtractor/tests/testcontainer.cpp b/sources/shiboken2/ApiExtractor/tests/testcontainer.cpp index aaa72238c..0da16924a 100644 --- a/sources/shiboken2/ApiExtractor/tests/testcontainer.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testcontainer.cpp @@ -91,7 +91,8 @@ void TestContainer::testListOfValueType() const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); QCOMPARE(classA->templateBaseClassInstantiations().count(), 1); - const AbstractMetaType* templateInstanceType = classA->templateBaseClassInstantiations().first(); + const AbstractMetaType *templateInstanceType = + classA->templateBaseClassInstantiations().constFirst(); QVERIFY(templateInstanceType); QCOMPARE(templateInstanceType->indirections(), 0); diff --git a/sources/shiboken2/ApiExtractor/tests/testconversionoperator.cpp b/sources/shiboken2/ApiExtractor/tests/testconversionoperator.cpp index 142c783a4..2af427294 100644 --- a/sources/shiboken2/ApiExtractor/tests/testconversionoperator.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testconversionoperator.cpp @@ -148,11 +148,15 @@ void TestConversionOperator::testConversionOperatorReturningReference() QCOMPARE(classA->functions().count(), 2); QCOMPARE(classB->functions().count(), 3); QCOMPARE(classA->externalConversionOperators().count(), 1); - QCOMPARE(classA->externalConversionOperators().first()->type()->cppSignature(), QLatin1String("A")); - QCOMPARE(classA->externalConversionOperators().first()->ownerClass()->name(), QLatin1String("B")); + QCOMPARE(classA->externalConversionOperators().constFirst()->type()->cppSignature(), + QLatin1String("A")); + QCOMPARE(classA->externalConversionOperators().constFirst()->ownerClass()->name(), + QLatin1String("B")); QCOMPARE(classA->implicitConversions().count(), 1); - QCOMPARE(classA->implicitConversions().first()->type()->cppSignature(), QLatin1String("A")); - QCOMPARE(classA->implicitConversions().first()->ownerClass()->name(), QLatin1String("B")); + QCOMPARE(classA->implicitConversions().constFirst()->type()->cppSignature(), + QLatin1String("A")); + QCOMPARE(classA->implicitConversions().constFirst()->ownerClass()->name(), + QLatin1String("B")); } void TestConversionOperator::testConversionOperatorReturningConstReference() @@ -178,11 +182,15 @@ void TestConversionOperator::testConversionOperatorReturningConstReference() QCOMPARE(classA->functions().count(), 2); QCOMPARE(classB->functions().count(), 3); QCOMPARE(classA->externalConversionOperators().count(), 1); - QCOMPARE(classA->externalConversionOperators().first()->type()->cppSignature(), QLatin1String("A")); - QCOMPARE(classA->externalConversionOperators().first()->ownerClass()->name(), QLatin1String("B")); + QCOMPARE(classA->externalConversionOperators().constFirst()->type()->cppSignature(), + QLatin1String("A")); + QCOMPARE(classA->externalConversionOperators().constFirst()->ownerClass()->name(), + QLatin1String("B")); QCOMPARE(classA->implicitConversions().count(), 1); - QCOMPARE(classA->implicitConversions().first()->type()->cppSignature(), QLatin1String("A")); - QCOMPARE(classA->implicitConversions().first()->ownerClass()->name(), QLatin1String("B")); + QCOMPARE(classA->implicitConversions().constFirst()->type()->cppSignature(), + QLatin1String("A")); + QCOMPARE(classA->implicitConversions().constFirst()->ownerClass()->name(), + QLatin1String("B")); } QTEST_APPLESS_MAIN(TestConversionOperator) diff --git a/sources/shiboken2/ApiExtractor/tests/testconversionruletag.cpp b/sources/shiboken2/ApiExtractor/tests/testconversionruletag.cpp index aa2bec5d6..15a9231ff 100644 --- a/sources/shiboken2/ApiExtractor/tests/testconversionruletag.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testconversionruletag.cpp @@ -179,7 +179,8 @@ if (!TargetDateTimeAPI) TargetDateTime_IMPORT;\n\ QVERIFY(conversion->hasTargetToNativeConversions()); QCOMPARE(conversion->targetToNativeConversions().size(), 1); - CustomConversion::TargetToNativeConversion* toNative = conversion->targetToNativeConversions().first(); + CustomConversion::TargetToNativeConversion *toNative = + conversion->targetToNativeConversions().constFirst(); QVERIFY(toNative); QCOMPARE(toNative->sourceTypeName(), QLatin1String("TargetDate")); QVERIFY(toNative->isCustomType()); @@ -241,7 +242,7 @@ void TestConversionRuleTag::testConversionRuleTagWithInsertTemplate() QVERIFY(conversion->hasTargetToNativeConversions()); QCOMPARE(conversion->targetToNativeConversions().size(), 1); - CustomConversion::TargetToNativeConversion* toNative = conversion->targetToNativeConversions().first(); + CustomConversion::TargetToNativeConversion* toNative = conversion->targetToNativeConversions().constFirst(); QVERIFY(toNative); QCOMPARE(toNative->conversion().trimmed(), QLatin1String(targetToNativeExpected)); diff --git a/sources/shiboken2/ApiExtractor/tests/testdroptypeentries.cpp b/sources/shiboken2/ApiExtractor/tests/testdroptypeentries.cpp index 7b3da182f..786c3717e 100644 --- a/sources/shiboken2/ApiExtractor/tests/testdroptypeentries.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testdroptypeentries.cpp @@ -87,7 +87,7 @@ void TestDropTypeEntries::testDropEntries() AbstractMetaEnumList globalEnums = builder->globalEnums(); QCOMPARE(globalEnums.count(), 1); - QCOMPARE(globalEnums.first()->name(), QLatin1String("EnumA")); + QCOMPARE(globalEnums.constFirst()->name(), QLatin1String("EnumA")); TypeDatabase* td = TypeDatabase::instance(); QVERIFY(td->findType(QLatin1String("funcA"))); diff --git a/sources/shiboken2/ApiExtractor/tests/testenum.cpp b/sources/shiboken2/ApiExtractor/tests/testenum.cpp index c04a37d9d..82cdd291c 100644 --- a/sources/shiboken2/ApiExtractor/tests/testenum.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testenum.cpp @@ -58,31 +58,32 @@ void TestEnum::testEnumCppSignature() AbstractMetaEnumList globalEnums = builder->globalEnums(); QCOMPARE(globalEnums.count(), 1); - QCOMPARE(globalEnums.first()->name(), QLatin1String("GlobalEnum")); + QCOMPARE(globalEnums.constFirst()->name(), QLatin1String("GlobalEnum")); // enum as parameter of a function AbstractMetaFunctionList functions = builder->globalFunctions(); QCOMPARE(functions.count(), 1); - QCOMPARE(functions.first()->arguments().count(), 1); - QCOMPARE(functions.first()->arguments().first()->type()->cppSignature(), QLatin1String("A::ClassEnum")); + QCOMPARE(functions.constFirst()->arguments().count(), 1); + QCOMPARE(functions.constFirst()->arguments().constFirst()->type()->cppSignature(), + QLatin1String("A::ClassEnum")); // enum as parameter of a method const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QCOMPARE(classA->enums().count(), 1); AbstractMetaFunctionList funcs = classA->queryFunctionsByName(QLatin1String("method")); QVERIFY(!funcs.isEmpty()); - AbstractMetaFunction* method = funcs.first(); + AbstractMetaFunction *method = funcs.constFirst(); QVERIFY(method); - AbstractMetaArgument* arg = method->arguments().first(); + AbstractMetaArgument *arg = method->arguments().constFirst(); QCOMPARE(arg->type()->name(), QLatin1String("ClassEnum")); QCOMPARE(arg->type()->cppSignature(), QLatin1String("A::ClassEnum")); - QCOMPARE(functions.first()->arguments().count(), 1); - arg = functions.first()->arguments().first(); + QCOMPARE(functions.constFirst()->arguments().count(), 1); + arg = functions.constFirst()->arguments().constFirst(); QCOMPARE(arg->type()->name(), QLatin1String("ClassEnum")); QCOMPARE(arg->type()->cppSignature(), QLatin1String("A::ClassEnum")); AbstractMetaEnumList classEnums = classA->enums(); - QCOMPARE(classEnums.first()->name(), QLatin1String("ClassEnum")); + QCOMPARE(classEnums.constFirst()->name(), QLatin1String("ClassEnum")); AbstractMetaEnumValue *e = AbstractMetaClass::findEnumValue(classes, QLatin1String("CA")); QVERIFY(e); e = AbstractMetaClass::findEnumValue(classes, QLatin1String("ClassEnum::CA")); @@ -136,8 +137,9 @@ void TestEnum::testAnonymousEnum() AbstractMetaEnumList globalEnums = builder->globalEnums(); QCOMPARE(globalEnums.count(), 1); - QCOMPARE(globalEnums.first()->typeEntry()->qualifiedCppName(), QLatin1String("Global0")); - QVERIFY(globalEnums.first()->isAnonymous()); + QCOMPARE(globalEnums.constFirst()->typeEntry()->qualifiedCppName(), + QLatin1String("Global0")); + QVERIFY(globalEnums.constFirst()->isAnonymous()); AbstractMetaClassList classes = builder->classes(); QCOMPARE(classes.count(), 1); @@ -148,12 +150,12 @@ void TestEnum::testAnonymousEnum() QVERIFY(anonEnumA1->isAnonymous()); QCOMPARE(anonEnumA1->typeEntry()->qualifiedCppName(), QLatin1String("A::A1")); - AbstractMetaEnumValue* enumValueA0 = anonEnumA1->values().first(); + AbstractMetaEnumValue* enumValueA0 = anonEnumA1->values().constFirst(); QCOMPARE(enumValueA0->name(), QLatin1String("A0")); QCOMPARE(enumValueA0->value().value(), 0); QCOMPARE(enumValueA0->stringValue(), QString()); - AbstractMetaEnumValue* enumValueA1 = anonEnumA1->values().last(); + AbstractMetaEnumValue *enumValueA1 = anonEnumA1->values().constLast(); QCOMPARE(enumValueA1->name(), QLatin1String("A1")); QCOMPARE(enumValueA1->value().value(), 1); QCOMPARE(enumValueA1->stringValue(), QString()); @@ -163,12 +165,12 @@ void TestEnum::testAnonymousEnum() QVERIFY(anonEnumIsThis->isAnonymous()); QCOMPARE(anonEnumIsThis->typeEntry()->qualifiedCppName(), QLatin1String("A::isThis")); - AbstractMetaEnumValue* enumValueIsThis = anonEnumIsThis->values().first(); + AbstractMetaEnumValue* enumValueIsThis = anonEnumIsThis->values().constFirst(); QCOMPARE(enumValueIsThis->name(), QLatin1String("isThis")); QCOMPARE(enumValueIsThis->value().value(), static_cast(true)); QCOMPARE(enumValueIsThis->stringValue(), QLatin1String("true")); - AbstractMetaEnumValue* enumValueIsThat = anonEnumIsThis->values().last(); + AbstractMetaEnumValue *enumValueIsThat = anonEnumIsThis->values().constLast(); QCOMPARE(enumValueIsThat->name(), QLatin1String("isThat")); QCOMPARE(enumValueIsThat->value().value(), static_cast(false)); QCOMPARE(enumValueIsThat->stringValue(), QLatin1String("false")); @@ -191,28 +193,28 @@ void TestEnum::testGlobalEnums() AbstractMetaEnumList globalEnums = builder->globalEnums(); QCOMPARE(globalEnums.count(), 2); - AbstractMetaEnum* enumA = globalEnums.first(); + AbstractMetaEnum *enumA = globalEnums.constFirst(); QCOMPARE(enumA->typeEntry()->qualifiedCppName(), QLatin1String("EnumA")); - AbstractMetaEnumValue* enumValueA0 = enumA->values().first(); + AbstractMetaEnumValue *enumValueA0 = enumA->values().constFirst(); QCOMPARE(enumValueA0->name(), QLatin1String("A0")); QCOMPARE(enumValueA0->value().value(), 0); QCOMPARE(enumValueA0->stringValue(), QString()); - AbstractMetaEnumValue* enumValueA1 = enumA->values().last(); + AbstractMetaEnumValue *enumValueA1 = enumA->values().constLast(); QCOMPARE(enumValueA1->name(), QLatin1String("A1")); QCOMPARE(enumValueA1->value().value(), 1); QCOMPARE(enumValueA1->stringValue(), QString()); - AbstractMetaEnum* enumB = globalEnums.last(); + AbstractMetaEnum *enumB = globalEnums.constLast(); QCOMPARE(enumB->typeEntry()->qualifiedCppName(), QLatin1String("EnumB")); - AbstractMetaEnumValue* enumValueB0 = enumB->values().first(); + AbstractMetaEnumValue* enumValueB0 = enumB->values().constFirst(); QCOMPARE(enumValueB0->name(), QLatin1String("B0")); QCOMPARE(enumValueB0->value().value(), 2); QCOMPARE(enumValueB0->stringValue(), QLatin1String("2")); - AbstractMetaEnumValue* enumValueB1 = enumB->values().last(); + AbstractMetaEnumValue *enumValueB1 = enumB->values().constLast(); QCOMPARE(enumValueB1->name(), QLatin1String("B1")); QCOMPARE(enumValueB1->value().value(), 4); QCOMPARE(enumValueB1->stringValue(), QLatin1String("0x4")); @@ -244,12 +246,12 @@ void TestEnum::testEnumValueFromNeighbourEnum() QVERIFY(enumA); QCOMPARE(enumA->typeEntry()->qualifiedCppName(), QLatin1String("A::EnumA")); - AbstractMetaEnumValue* enumValueA0 = enumA->values().first(); + AbstractMetaEnumValue* enumValueA0 = enumA->values().constFirst(); QCOMPARE(enumValueA0->name(), QLatin1String("ValueA0")); QCOMPARE(enumValueA0->value().value(), 0); QCOMPARE(enumValueA0->stringValue(), QString()); - AbstractMetaEnumValue* enumValueA1 = enumA->values().last(); + AbstractMetaEnumValue* enumValueA1 = enumA->values().constLast(); QCOMPARE(enumValueA1->name(), QLatin1String("ValueA1")); QCOMPARE(enumValueA1->value().value(), 1); QCOMPARE(enumValueA1->stringValue(), QString()); @@ -258,12 +260,12 @@ void TestEnum::testEnumValueFromNeighbourEnum() QVERIFY(enumB); QCOMPARE(enumB->typeEntry()->qualifiedCppName(), QLatin1String("A::EnumB")); - AbstractMetaEnumValue* enumValueB0 = enumB->values().first(); + AbstractMetaEnumValue *enumValueB0 = enumB->values().constFirst(); QCOMPARE(enumValueB0->name(), QLatin1String("ValueB0")); QCOMPARE(enumValueB0->value().value(), 1); QCOMPARE(enumValueB0->stringValue(), QLatin1String("A::ValueA1")); - AbstractMetaEnumValue* enumValueB1 = enumB->values().last(); + AbstractMetaEnumValue *enumValueB1 = enumB->values().constLast(); QCOMPARE(enumValueB1->name(), QLatin1String("ValueB1")); QCOMPARE(enumValueB1->value().value(), 0); QCOMPARE(enumValueB1->stringValue(), QLatin1String("ValueA0")); @@ -389,12 +391,12 @@ void TestEnum::testPrivateEnum() QVERIFY(publicEnum); QCOMPARE(publicEnum->typeEntry()->qualifiedCppName(), QLatin1String("A::PublicEnum")); - AbstractMetaEnumValue* pub0 = publicEnum->values().first(); + AbstractMetaEnumValue *pub0 = publicEnum->values().constFirst(); QCOMPARE(pub0->name(), QLatin1String("Pub0")); QCOMPARE(pub0->value().value(), 0x0f); QCOMPARE(pub0->stringValue(), QLatin1String("Priv0")); - AbstractMetaEnumValue* pub1 = publicEnum->values().last(); + AbstractMetaEnumValue *pub1 = publicEnum->values().constLast(); QCOMPARE(pub1->name(), QLatin1String("Pub1")); QCOMPARE(pub1->value().value(), 0xf0); QCOMPARE(pub1->stringValue(), QLatin1String("A::Priv1")); @@ -418,15 +420,15 @@ void TestEnum::testTypedefEnum() AbstractMetaEnumList globalEnums = builder->globalEnums(); QCOMPARE(globalEnums.count(), 1); - AbstractMetaEnum* enumA = globalEnums.first(); + AbstractMetaEnum *enumA = globalEnums.constFirst(); QCOMPARE(enumA->typeEntry()->qualifiedCppName(), QLatin1String("EnumA")); - AbstractMetaEnumValue* enumValueA0 = enumA->values().first(); + AbstractMetaEnumValue *enumValueA0 = enumA->values().constFirst(); QCOMPARE(enumValueA0->name(), QLatin1String("A0")); QCOMPARE(enumValueA0->value().value(), 0); QCOMPARE(enumValueA0->stringValue(), QLatin1String("")); - AbstractMetaEnumValue* enumValueA1 = enumA->values().last(); + AbstractMetaEnumValue *enumValueA1 = enumA->values().constLast(); QCOMPARE(enumValueA1->name(), QLatin1String("A1")); QCOMPARE(enumValueA1->value().value(), 1); QCOMPARE(enumValueA1->stringValue(), QString()); diff --git a/sources/shiboken2/ApiExtractor/tests/testextrainclude.cpp b/sources/shiboken2/ApiExtractor/tests/testextrainclude.cpp index 7e5664842..565f157e1 100644 --- a/sources/shiboken2/ApiExtractor/tests/testextrainclude.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testextrainclude.cpp @@ -52,7 +52,7 @@ void TestExtraInclude::testClassExtraInclude() QVector includes = classA->typeEntry()->extraIncludes(); QCOMPARE(includes.count(), 1); - QCOMPARE(includes.first().name(), QLatin1String("header.h")); + QCOMPARE(includes.constFirst().name(), QLatin1String("header.h")); } void TestExtraInclude::testGlobalExtraIncludes() @@ -79,8 +79,8 @@ void TestExtraInclude::testGlobalExtraIncludes() QVector includes = module->extraIncludes(); QCOMPARE(includes.count(), 2); - QCOMPARE(includes.first().name(), QLatin1String("header1.h")); - QCOMPARE(includes.last().name(), QLatin1String("header2.h")); + QCOMPARE(includes.constFirst().name(), QLatin1String("header1.h")); + QCOMPARE(includes.constLast().name(), QLatin1String("header2.h")); } QTEST_APPLESS_MAIN(TestExtraInclude) diff --git a/sources/shiboken2/ApiExtractor/tests/testfunctiontag.cpp b/sources/shiboken2/ApiExtractor/tests/testfunctiontag.cpp index b9aee5824..b942ea9b5 100644 --- a/sources/shiboken2/ApiExtractor/tests/testfunctiontag.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testfunctiontag.cpp @@ -81,12 +81,13 @@ void TestFunctionTag::testRenameGlobalFunction() QVERIFY(func); QCOMPARE(builder->globalFunctions().size(), 1); - const AbstractMetaFunction* metaFunc = builder->globalFunctions().first(); + const AbstractMetaFunction *metaFunc = builder->globalFunctions().constFirst(); QVERIFY(metaFunc); QCOMPARE(metaFunc->modifications().size(), 1); - QVERIFY(metaFunc->modifications().first().isRenameModifier()); - QCOMPARE(metaFunc->modifications().first().renamedTo(), QLatin1String("smooth")); + QVERIFY(metaFunc->modifications().constFirst().isRenameModifier()); + QCOMPARE(metaFunc->modifications().constFirst().renamedTo(), + QLatin1String("smooth")); QCOMPARE(metaFunc->name(), QLatin1String("smooth")); QCOMPARE(metaFunc->originalName(), QLatin1String("global_function_with_ugly_name")); diff --git a/sources/shiboken2/ApiExtractor/tests/testimplicitconversions.cpp b/sources/shiboken2/ApiExtractor/tests/testimplicitconversions.cpp index 26fb148d5..f960fca2f 100644 --- a/sources/shiboken2/ApiExtractor/tests/testimplicitconversions.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testimplicitconversions.cpp @@ -59,7 +59,8 @@ void TestImplicitConversions::testWithPrivateCtors() const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, QLatin1String("C")); AbstractMetaFunctionList implicitConvs = classA->implicitConversions(); QCOMPARE(implicitConvs.count(), 1); - QCOMPARE(implicitConvs.first()->arguments().first()->type()->typeEntry(), classC->typeEntry()); + QCOMPARE(implicitConvs.constFirst()->arguments().constFirst()->type()->typeEntry(), + classC->typeEntry()); } void TestImplicitConversions::testWithModifiedVisibility() @@ -88,7 +89,8 @@ void TestImplicitConversions::testWithModifiedVisibility() const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B")); AbstractMetaFunctionList implicitConvs = classA->implicitConversions(); QCOMPARE(implicitConvs.count(), 1); - QCOMPARE(implicitConvs.first()->arguments().first()->type()->typeEntry(), classB->typeEntry()); + QCOMPARE(implicitConvs.constFirst()->arguments().constFirst()->type()->typeEntry(), + classB->typeEntry()); } @@ -157,7 +159,7 @@ void TestImplicitConversions::testWithExternalConversionOperator() convOp = func; } QVERIFY(convOp); - QCOMPARE(implicitConvs.first(), convOp); + QCOMPARE(implicitConvs.constFirst(), convOp); } QTEST_APPLESS_MAIN(TestImplicitConversions) diff --git a/sources/shiboken2/ApiExtractor/tests/testinserttemplate.cpp b/sources/shiboken2/ApiExtractor/tests/testinserttemplate.cpp index 2d1692ee9..13cbaf2d8 100644 --- a/sources/shiboken2/ApiExtractor/tests/testinserttemplate.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testinserttemplate.cpp @@ -53,7 +53,7 @@ void TestInsertTemplate::testInsertTemplateOnClassInjectCode() const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); QCOMPARE(classA->typeEntry()->codeSnips().count(), 1); - QString code = classA->typeEntry()->codeSnips().first().code(); + QString code = classA->typeEntry()->codeSnips().constFirst().code(); QVERIFY(code.contains(QLatin1String("code template content"))); } @@ -79,7 +79,7 @@ void TestInsertTemplate::testInsertTemplateOnModuleInjectCode() QCOMPARE(module->name(), QLatin1String("Foo")); QVERIFY(module); QCOMPARE(module->codeSnips().count(), 1); - QString code = module->codeSnips().first().code().trimmed(); + QString code = module->codeSnips().constFirst().code().trimmed(); QVERIFY(code.contains(QLatin1String("code template content"))); } diff --git a/sources/shiboken2/ApiExtractor/tests/testmodifyfunction.cpp b/sources/shiboken2/ApiExtractor/tests/testmodifyfunction.cpp index 4fd4269f6..b579cb410 100644 --- a/sources/shiboken2/ApiExtractor/tests/testmodifyfunction.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testmodifyfunction.cpp @@ -303,15 +303,15 @@ void TestModifyFunction::testGlobalFunctionModification() FunctionModificationList mods = TypeDatabase::instance()->functionModifications(QLatin1String("function(A*)")); QCOMPARE(mods.count(), 1); - QVector argMods = mods.first().argument_mods; + QVector argMods = mods.constFirst().argument_mods; QCOMPARE(argMods.count(), 1); - ArgumentModification argMod = argMods.first(); + ArgumentModification argMod = argMods.constFirst(); QCOMPARE(argMod.replacedDefaultExpression, QLatin1String("A()")); - const AbstractMetaFunction* func = builder->globalFunctions().first(); + const AbstractMetaFunction *func = builder->globalFunctions().constFirst(); QVERIFY(func); QCOMPARE(func->arguments().count(), 1); - const AbstractMetaArgument* arg = func->arguments().first(); + const AbstractMetaArgument *arg = func->arguments().constFirst(); QCOMPARE(arg->type()->cppSignature(), QLatin1String("A *")); QCOMPARE(arg->originalDefaultValueExpression(), QLatin1String("0")); QCOMPARE(arg->defaultValueExpression(), QLatin1String("A()")); diff --git a/sources/shiboken2/ApiExtractor/tests/testnestedtypes.cpp b/sources/shiboken2/ApiExtractor/tests/testnestedtypes.cpp index e61418467..446c6f431 100644 --- a/sources/shiboken2/ApiExtractor/tests/testnestedtypes.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testnestedtypes.cpp @@ -68,24 +68,24 @@ void TestNestedTypes::testNestedTypesModifications() QVERIFY(ins); QCOMPARE(ins->functions().count(), 1); QCOMPARE(ins->typeEntry()->codeSnips().count(), 1); - CodeSnip snip = ins->typeEntry()->codeSnips().first(); + CodeSnip snip = ins->typeEntry()->codeSnips().constFirst(); QCOMPARE(snip.code().trimmed(), QLatin1String("custom_code1();")); - AbstractMetaFunction* addedFunc = ins->functions().first(); + AbstractMetaFunction *addedFunc = ins->functions().constFirst(); QVERIFY(addedFunc->isUserAdded()); QCOMPARE(addedFunc->visibility(), AbstractMetaFunction::Public); QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::NormalFunction); QCOMPARE(addedFunc->type()->minimalSignature(), QLatin1String("OuterNamespace::InnerNamespace::SomeClass")); QCOMPARE(addedFunc->modifications().size(), 1); - QVERIFY(addedFunc->modifications().first().isCodeInjection()); - snip = addedFunc->modifications().first().snips.first(); + QVERIFY(addedFunc->modifications().constFirst().isCodeInjection()); + snip = addedFunc->modifications().constFirst().snips.constFirst(); QCOMPARE(snip.code().trimmed(), QLatin1String("custom_code2();")); const AbstractMetaClass *sc = AbstractMetaClass::findClass(classes, QLatin1String("OuterNamespace::InnerNamespace::SomeClass")); QVERIFY(ins); QCOMPARE(sc->functions().count(), 2); // default constructor and removed method - AbstractMetaFunction* removedFunc = sc->functions().last(); + AbstractMetaFunction *removedFunc = sc->functions().constLast(); QVERIFY(removedFunc->isModifiedRemoved()); } diff --git a/sources/shiboken2/ApiExtractor/tests/testnumericaltypedef.cpp b/sources/shiboken2/ApiExtractor/tests/testnumericaltypedef.cpp index 193bd8051..03129073a 100644 --- a/sources/shiboken2/ApiExtractor/tests/testnumericaltypedef.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testnumericaltypedef.cpp @@ -49,9 +49,9 @@ void TestNumericalTypedef::testNumericalTypedef() QVERIFY(!builder.isNull()); QCOMPARE(builder->globalFunctions().size(), 2); - const AbstractMetaFunction* funcDouble = builder->globalFunctions().first(); + const AbstractMetaFunction *funcDouble = builder->globalFunctions().constFirst(); QVERIFY(funcDouble); - const AbstractMetaFunction* funcReal = builder->globalFunctions().last(); + const AbstractMetaFunction *funcReal = builder->globalFunctions().constLast(); QVERIFY(funcReal); if (funcDouble->name() == QLatin1String("funcReal")) @@ -60,13 +60,13 @@ void TestNumericalTypedef::testNumericalTypedef() QCOMPARE(funcDouble->minimalSignature(), QLatin1String("funcDouble(double)")); QCOMPARE(funcReal->minimalSignature(), QLatin1String("funcReal(real)")); - const AbstractMetaType* doubleType = funcDouble->arguments().first()->type(); + const AbstractMetaType *doubleType = funcDouble->arguments().constFirst()->type(); QVERIFY(doubleType); QCOMPARE(doubleType->cppSignature(), QLatin1String("double")); QVERIFY(doubleType->isPrimitive()); QVERIFY(doubleType->typeEntry()->isCppPrimitive()); - const AbstractMetaType* realType = funcReal->arguments().first()->type(); + const AbstractMetaType *realType = funcReal->arguments().constFirst()->type(); QVERIFY(realType); QCOMPARE(realType->cppSignature(), QLatin1String("real")); QVERIFY(realType->isPrimitive()); @@ -91,9 +91,9 @@ void TestNumericalTypedef::testUnsignedNumericalTypedef() QVERIFY(!builder.isNull()); QCOMPARE(builder->globalFunctions().size(), 2); - const AbstractMetaFunction* funcUnsignedShort = builder->globalFunctions().first(); + const AbstractMetaFunction *funcUnsignedShort = builder->globalFunctions().constFirst(); QVERIFY(funcUnsignedShort); - const AbstractMetaFunction* funcUShort = builder->globalFunctions().last(); + const AbstractMetaFunction *funcUShort = builder->globalFunctions().constLast(); QVERIFY(funcUShort); if (funcUnsignedShort->name() == QLatin1String("funcUShort")) @@ -102,13 +102,13 @@ void TestNumericalTypedef::testUnsignedNumericalTypedef() QCOMPARE(funcUnsignedShort->minimalSignature(), QLatin1String("funcUnsignedShort(unsigned short)")); QCOMPARE(funcUShort->minimalSignature(), QLatin1String("funcUShort(custom_ushort)")); - const AbstractMetaType* unsignedShortType = funcUnsignedShort->arguments().first()->type(); + const AbstractMetaType *unsignedShortType = funcUnsignedShort->arguments().constFirst()->type(); QVERIFY(unsignedShortType); QCOMPARE(unsignedShortType->cppSignature(), QLatin1String("unsigned short")); QVERIFY(unsignedShortType->isPrimitive()); QVERIFY(unsignedShortType->typeEntry()->isCppPrimitive()); - const AbstractMetaType* ushortType = funcUShort->arguments().first()->type(); + const AbstractMetaType *ushortType = funcUShort->arguments().constFirst()->type(); QVERIFY(ushortType); QCOMPARE(ushortType->cppSignature(), QLatin1String("custom_ushort")); QVERIFY(ushortType->isPrimitive()); diff --git a/sources/shiboken2/ApiExtractor/tests/testrefcounttag.cpp b/sources/shiboken2/ApiExtractor/tests/testrefcounttag.cpp index 38099c455..9d1dcc1ae 100644 --- a/sources/shiboken2/ApiExtractor/tests/testrefcounttag.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testrefcounttag.cpp @@ -56,7 +56,7 @@ void TestRefCountTag::testReferenceCountTag() const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B")); const AbstractMetaFunction* func = classB->findFunction(QLatin1String("keepObject")); QVERIFY(func); - ReferenceCount refCount = func->modifications().first().argument_mods.first().referenceCounts.first(); + ReferenceCount refCount = func->modifications().constFirst().argument_mods.constFirst().referenceCounts.constFirst(); QCOMPARE(refCount.action, ReferenceCount::Add); } @@ -89,7 +89,7 @@ void TestRefCountTag::testWithApiVersion() const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B")); const AbstractMetaFunction* func = classB->findFunction(QLatin1String("keepObject")); QVERIFY(func); - ReferenceCount refCount = func->modifications().first().argument_mods.first().referenceCounts.first(); + ReferenceCount refCount = func->modifications().constFirst().argument_mods.constFirst().referenceCounts.constFirst(); QCOMPARE(refCount.action, ReferenceCount::Add); QCOMPARE(func->modifications().size(), 1); diff --git a/sources/shiboken2/ApiExtractor/tests/testreferencetopointer.cpp b/sources/shiboken2/ApiExtractor/tests/testreferencetopointer.cpp index c7b4abe9a..228bfaecd 100644 --- a/sources/shiboken2/ApiExtractor/tests/testreferencetopointer.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testreferencetopointer.cpp @@ -51,7 +51,7 @@ void TestReferenceToPointer::testReferenceToPointerArgument() QVERIFY(classB); const AbstractMetaFunction* func = classB->findFunction(QLatin1String("dummy")); QVERIFY(func); - QCOMPARE(func->arguments().first()->type()->minimalSignature(), QLatin1String("A*&")); + QCOMPARE(func->arguments().constFirst()->type()->minimalSignature(), QLatin1String("A*&")); } QTEST_APPLESS_MAIN(TestReferenceToPointer) diff --git a/sources/shiboken2/ApiExtractor/tests/testremovefield.cpp b/sources/shiboken2/ApiExtractor/tests/testremovefield.cpp index b586fd711..dd9b735a4 100644 --- a/sources/shiboken2/ApiExtractor/tests/testremovefield.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testremovefield.cpp @@ -52,7 +52,7 @@ void TestRemoveField::testRemoveField() const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A")); QVERIFY(classA); QCOMPARE(classA->fields().size(), 1); - const AbstractMetaField* fieldA = classA->fields().first(); + const AbstractMetaField *fieldA = classA->fields().constFirst(); QVERIFY(fieldA); QCOMPARE(fieldA->name(), QLatin1String("fieldA")); } diff --git a/sources/shiboken2/ApiExtractor/tests/testremoveimplconv.cpp b/sources/shiboken2/ApiExtractor/tests/testremoveimplconv.cpp index 96090d1cc..20170089a 100644 --- a/sources/shiboken2/ApiExtractor/tests/testremoveimplconv.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testremoveimplconv.cpp @@ -63,7 +63,8 @@ void TestRemoveImplConv::testRemoveImplConv() QVERIFY(classC); AbstractMetaFunctionList implConv = classC->implicitConversions(); QCOMPARE(implConv.count(), 1); - QCOMPARE(implConv.first()->arguments().first()->type()->typeEntry(), classB->typeEntry()); + QCOMPARE(implConv.constFirst()->arguments().constFirst()->type()->typeEntry(), + classB->typeEntry()); } QTEST_APPLESS_MAIN(TestRemoveImplConv) diff --git a/sources/shiboken2/ApiExtractor/tests/testtemplates.cpp b/sources/shiboken2/ApiExtractor/tests/testtemplates.cpp index ec3ddb8b2..f6c70a651 100644 --- a/sources/shiboken2/ApiExtractor/tests/testtemplates.cpp +++ b/sources/shiboken2/ApiExtractor/tests/testtemplates.cpp @@ -115,15 +115,15 @@ namespace Namespace { QVERIFY(!classB->baseClass()); QVERIFY(classB->baseClassName().isEmpty()); const AbstractMetaFunction* func = classB->findFunction(QLatin1String("foo")); - AbstractMetaType* argType = func->arguments().first()->type(); + AbstractMetaType* argType = func->arguments().constFirst()->type(); QCOMPARE(argType->instantiations().count(), 1); QCOMPARE(argType->typeEntry()->qualifiedCppName(), QLatin1String("QList")); - const AbstractMetaType* instance1 = argType->instantiations().first(); + const AbstractMetaType* instance1 = argType->instantiations().constFirst(); QCOMPARE(instance1->instantiations().count(), 1); QCOMPARE(instance1->typeEntry()->qualifiedCppName(), QLatin1String("Namespace::A")); - const AbstractMetaType* instance2 = instance1->instantiations().first(); + const AbstractMetaType* instance2 = instance1->instantiations().constFirst(); QCOMPARE(instance2->instantiations().count(), 0); QCOMPARE(instance2->typeEntry()->qualifiedCppName(), QLatin1String("Namespace::E1")); } @@ -147,9 +147,10 @@ void func(List arg) {} AbstractMetaFunctionList globalFuncs = builder->globalFunctions(); QCOMPARE(globalFuncs.count(), 1); - AbstractMetaFunction* func = globalFuncs.first(); + AbstractMetaFunction *func = globalFuncs.constFirst(); QCOMPARE(func->minimalSignature(), QLatin1String("func(List)")); - QCOMPARE(func->arguments().first()->type()->cppSignature(), QLatin1String("List")); + QCOMPARE(func->arguments().constFirst()->type()->cppSignature(), + QLatin1String("List")); } void TestTemplates::testTemplatePointerAsArgument() @@ -171,9 +172,10 @@ void func(List* arg) {} AbstractMetaFunctionList globalFuncs = builder->globalFunctions(); QCOMPARE(globalFuncs.count(), 1); - AbstractMetaFunction* func = globalFuncs.first(); + AbstractMetaFunction* func = globalFuncs.constFirst(); QCOMPARE(func->minimalSignature(), QLatin1String("func(List*)")); - QCOMPARE(func->arguments().first()->type()->cppSignature(), QLatin1String("List *")); + QCOMPARE(func->arguments().constFirst()->type()->cppSignature(), + QLatin1String("List *")); } void TestTemplates::testTemplateReferenceAsArgument() @@ -195,9 +197,10 @@ void func(List& arg) {} AbstractMetaFunctionList globalFuncs = builder->globalFunctions(); QCOMPARE(globalFuncs.count(), 1); - AbstractMetaFunction* func = globalFuncs.first(); + AbstractMetaFunction* func = globalFuncs.constFirst(); QCOMPARE(func->minimalSignature(), QLatin1String("func(List&)")); - QCOMPARE(func->arguments().first()->type()->cppSignature(), QLatin1String("List &")); + QCOMPARE(func->arguments().constFirst()->type()->cppSignature(), + QLatin1String("List &")); } void TestTemplates::testTemplateParameterFixup() @@ -223,7 +226,7 @@ struct List { const AbstractMetaClassList templates = builder->templates(); QCOMPARE(templates.count(), 1); - const AbstractMetaClass *list = templates.first(); + const AbstractMetaClass *list = templates.constFirst(); // Verify that the parameter of "void append(List l)" gets fixed to "List" const AbstractMetaFunction *append = list->findFunction(QStringLiteral("append")); QVERIFY(append); @@ -269,7 +272,7 @@ struct FooBars : public ListContainer {}; const AbstractMetaClass* foobars = AbstractMetaClass::findClass(classes, QLatin1String("FooBars")); QCOMPARE(foobars->functions().count(), 4); - const AbstractMetaClass* lc = templates.first(); + const AbstractMetaClass *lc = templates.constFirst(); QCOMPARE(lc->functions().count(), 2); } @@ -391,7 +394,7 @@ typedef BaseTemplateClass TypeOneClass; QVERIFY(one->hasTemplateBaseClassInstantiations()); AbstractMetaTypeList instantiations = one->templateBaseClassInstantiations(); QCOMPARE(instantiations.count(), 1); - const AbstractMetaType* inst = instantiations.first(); + const AbstractMetaType *inst = instantiations.constFirst(); QVERIFY(inst); QVERIFY(!inst->isEnum()); QVERIFY(!inst->typeEntry()->isEnum()); -- cgit v1.2.3