aboutsummaryrefslogtreecommitdiffstats
path: root/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp')
-rw-r--r--sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp185
1 files changed, 84 insertions, 101 deletions
diff --git a/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp b/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
index 0d95d5abb..a7d40f70a 100644
--- a/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
@@ -1,40 +1,22 @@
-/****************************************************************************
-**
-** Copyright (C) 2016 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of the test suite of Qt for Python.
-**
-** $QT_BEGIN_LICENSE:GPL-EXCEPT$
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-** $QT_END_LICENSE$
-**
-****************************************************************************/
+// Copyright (C) 2016 The Qt Company Ltd.
+// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
#include "testmodifyfunction.h"
-#include <QtTest/QTest>
#include "testutil.h"
+#include <abstractmetaargument.h>
#include <abstractmetabuilder_p.h>
#include <abstractmetafunction.h>
#include <abstractmetalang.h>
+#include <abstractmetatype.h>
#include <modifications.h>
#include <typesystem.h>
+#include <qtcompat.h>
+
+#include <QtTest/QTest>
+
+using namespace Qt::StringLiterals;
+
void TestModifyFunction::testRenameArgument_data()
{
QTest::addColumn<QByteArray>("pattern");
@@ -46,7 +28,7 @@ void TestModifyFunction::testRenameArgument()
{
QFETCH(QByteArray, pattern);
- const char* cppCode ="\
+ const char cppCode[] = "\
struct A {\n\
void method(int=0);\n\
};\n";
@@ -64,23 +46,23 @@ 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 AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
- const auto func = classA->findFunction(QLatin1String("method"));
- QVERIFY(!func.isNull());
+ const auto classA = AbstractMetaClass::findClass(classes, "A");
+ const auto func = classA->findFunction("method");
+ QVERIFY(func);
- QCOMPARE(func->argumentName(1), QLatin1String("otherArg"));
+ QCOMPARE(func->argumentName(1), u"otherArg");
}
void TestModifyFunction::testOwnershipTransfer()
{
- const char* cppCode ="\
+ const char cppCode[] = "\
struct A {};\n\
struct B {\n\
virtual A* method();\n\
};\n";
- const char* xmlCode = "\
+ const char xmlCode[] = "\
<typesystem package=\"Foo\">\n\
<object-type name='A' />\n\
<object-type name='B'>\n\
@@ -92,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 AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
- const auto func = classB->findFunction(QLatin1String("method"));
- QVERIFY(!func.isNull());
+ const auto classB = AbstractMetaClass::findClass(classes, "B");
+ const auto func = classB->findFunction("method");
+ QVERIFY(func);
QCOMPARE(func->argumentTargetOwnership(func->ownerClass(), 0),
TypeSystem::CppOwnership);
@@ -105,7 +87,7 @@ void TestModifyFunction::testOwnershipTransfer()
void TestModifyFunction::invalidateAfterUse()
{
- const char* cppCode ="\
+ const char cppCode[] = "\
struct A {\n\
virtual void call(int *a);\n\
};\n\
@@ -119,7 +101,7 @@ void TestModifyFunction::invalidateAfterUse()
};\n\
struct E : D {\n\
};\n";
- const char* xmlCode = "\
+ const char xmlCode[] = "\
<typesystem package='Foo'>\n\
<primitive-type name='int'/>\n\
<object-type name='A'>\n\
@@ -141,48 +123,48 @@ void TestModifyFunction::invalidateAfterUse()
<object-type name='E' />\n\
</typesystem>\n";
QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
- false, QLatin1String("0.1")));
- QVERIFY(!builder.isNull());
+ false, u"0.1"_s));
+ QVERIFY(builder);
AbstractMetaClassList classes = builder->classes();
- const AbstractMetaClass *classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
- auto func = classB->findFunction(QLatin1String("call"));
+ const auto classB = AbstractMetaClass::findClass(classes, "B");
+ auto func = classB->findFunction("call");
QCOMPARE(func->modifications().size(), 1);
QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse());
- const AbstractMetaClass *classC = AbstractMetaClass::findClass(classes, QLatin1String("C"));
+ const auto classC = AbstractMetaClass::findClass(classes, "C");
QVERIFY(classC);
- func = classC->findFunction(QLatin1String("call"));
+ func = classC->findFunction("call");
QCOMPARE(func->modifications().size(), 1);
QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse());
- func = classC->findFunction(QLatin1String("call2"));
+ func = classC->findFunction("call2");
QCOMPARE(func->modifications().size(), 1);
QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse());
- const AbstractMetaClass *classD = AbstractMetaClass::findClass(classes, QLatin1String("D"));
+ AbstractMetaClassCPtr classD = AbstractMetaClass::findClass(classes, "D");
QVERIFY(classD);
- func = classD->findFunction(QLatin1String("call"));
+ func = classD->findFunction("call");
QCOMPARE(func->modifications().size(), 1);
QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse());
- func = classD->findFunction(QLatin1String("call2"));
+ func = classD->findFunction("call2");
QCOMPARE(func->modifications().size(), 1);
QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse());
- const AbstractMetaClass *classE = AbstractMetaClass::findClass(classes, QLatin1String("E"));
+ const auto classE = AbstractMetaClass::findClass(classes, "E");
QVERIFY(classE);
- func = classE->findFunction(QLatin1String("call"));
+ func = classE->findFunction("call");
QVERIFY(func);
QCOMPARE(func->modifications().size(), 1);
QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
QVERIFY(func->modifications().at(0).argument_mods().at(0).resetAfterUse());
- func = classE->findFunction(QLatin1String("call2"));
+ func = classE->findFunction("call2");
QVERIFY(func);
QCOMPARE(func->modifications().size(), 1);
QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
@@ -191,13 +173,13 @@ void TestModifyFunction::invalidateAfterUse()
void TestModifyFunction::testWithApiVersion()
{
- const char* cppCode ="\
+ const char cppCode[] = "\
struct A {};\n\
struct B {\n\
virtual A* method();\n\
virtual B* methodB();\n\
};\n";
- const char* xmlCode = "\
+ const char xmlCode[] = "\
<typesystem package='Foo'>\n\
<object-type name='A' />\n\
<object-type name='B'>\n\
@@ -214,16 +196,16 @@ void TestModifyFunction::testWithApiVersion()
</object-type>\n\
</typesystem>\n";
QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
- false, QLatin1String("0.1")));
- QVERIFY(!builder.isNull());
+ false, u"0.1"_s));
+ QVERIFY(builder);
AbstractMetaClassList classes = builder->classes();
- AbstractMetaClass* classB = AbstractMetaClass::findClass(classes, QLatin1String("B"));
- auto func = classB->findFunction(QLatin1String("method"));
+ const auto classB = AbstractMetaClass::findClass(classes, "B");
+ auto func = classB->findFunction("method");
auto returnOwnership = func->argumentTargetOwnership(func->ownerClass(), 0);
QCOMPARE(returnOwnership, TypeSystem::CppOwnership);
- func = classB->findFunction(QLatin1String("methodB"));
+ func = classB->findFunction("methodB");
returnOwnership = func->argumentTargetOwnership(func->ownerClass(), 0);
QVERIFY(returnOwnership != TypeSystem::CppOwnership);
}
@@ -253,44 +235,44 @@ struct A {
</typesystem>
)XML";
QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode,
- false, QLatin1String("0.1")));
- QVERIFY(!builder.isNull());
+ false, u"0.1"_s));
+ QVERIFY(builder);
AbstractMetaClassList classes = builder->classes();
- const AbstractMetaClass *classA = AbstractMetaClass::findClass(classes, QLatin1String("A"));
+ const auto classA = AbstractMetaClass::findClass(classes, "A");
QVERIFY(classA);
// Nothing specified, true
- const auto f1 = classA->findFunction(QLatin1String("f1"));
- QVERIFY(!f1.isNull());
+ const auto f1 = classA->findFunction("f1");
+ QVERIFY(f1);
QVERIFY(!f1->allowThread());
// 'auto' specified, should be false for nontrivial function
- const auto f2 = classA->findFunction(QLatin1String("f2"));
- QVERIFY(!f2.isNull());
+ const auto f2 = classA->findFunction("f2");
+ QVERIFY(f2);
QVERIFY(f2->allowThread());
// 'no' specified, should be false
- const auto f3 = classA->findFunction(QLatin1String("f3"));
- QVERIFY(!f3.isNull());
+ const auto f3 = classA->findFunction("f3");
+ QVERIFY(f3);
QVERIFY(!f3->allowThread());
// Nothing specified, should be false for simple getter
- const auto getter1 = classA->findFunction(QLatin1String("getter1"));
- QVERIFY(!getter1.isNull());
+ const auto getter1 = classA->findFunction("getter1");
+ QVERIFY(getter1);
QVERIFY(!getter1->allowThread());
// Forced to true simple getter
- const auto getter2 = classA->findFunction(QLatin1String("getter2"));
- QVERIFY(!getter2.isNull());
+ const auto getter2 = classA->findFunction("getter2");
+ QVERIFY(getter2);
QVERIFY(getter2->allowThread()); // Forced to true simple getter
}
void TestModifyFunction::testGlobalFunctionModification()
{
- const char* cppCode ="\
+ const char cppCode[] = "\
struct A {};\n\
void function(A* a = 0);\n";
- const char* xmlCode = "\
+ const char xmlCode[] = "\
<typesystem package='Foo'>\n\
<primitive-type name='A'/>\n\
<function signature='function(A*)'>\n\
@@ -304,23 +286,24 @@ void TestModifyFunction::testGlobalFunctionModification()
</typesystem>\n";
QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
- QVERIFY(!builder.isNull());
+ QVERIFY(builder);
QCOMPARE(builder->globalFunctions().size(), 1);
- FunctionModificationList mods = TypeDatabase::instance()->functionModifications(QLatin1String("function(A*)"));
- QCOMPARE(mods.count(), 1);
+ auto *td = TypeDatabase::instance();
+ FunctionModificationList mods = td->globalFunctionModifications({u"function(A*)"_s});
+ QCOMPARE(mods.size(), 1);
const QList<ArgumentModification> &argMods = mods.constFirst().argument_mods();
- QCOMPARE(argMods.count(), 1);
+ QCOMPARE(argMods.size(), 1);
ArgumentModification argMod = argMods.constFirst();
- QCOMPARE(argMod.replacedDefaultExpression(), QLatin1String("A()"));
+ QCOMPARE(argMod.replacedDefaultExpression(), u"A()");
QVERIFY(!builder->globalFunctions().isEmpty());
const auto func = builder->globalFunctions().constFirst();
- QCOMPARE(func->arguments().count(), 1);
+ QCOMPARE(func->arguments().size(), 1);
const AbstractMetaArgument &arg = func->arguments().constFirst();
- QCOMPARE(arg.type().cppSignature(), QLatin1String("A *"));
- QCOMPARE(arg.originalDefaultValueExpression(), QLatin1String("0"));
- QCOMPARE(arg.defaultValueExpression(), QLatin1String("A()"));
+ QCOMPARE(arg.type().cppSignature(), u"A *");
+ QCOMPARE(arg.originalDefaultValueExpression(), u"0");
+ QCOMPARE(arg.defaultValueExpression(), u"A()");
}
// Tests modifications of exception handling and allow-thread
@@ -451,44 +434,44 @@ void TestModifyFunction::testScopedModifications()
QFETCH(bool, expectedAllowThread);
QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode.constData(), xmlCode.constData(), false));
- QVERIFY(!builder.isNull());
+ QVERIFY(builder);
- const AbstractMetaClass *classA = AbstractMetaClass::findClass(builder->classes(), QLatin1String("A"));
+ const auto classA = AbstractMetaClass::findClass(builder->classes(), "A");
QVERIFY(classA);
- auto f = classA->findFunction(QStringLiteral("unspecified"));
- QVERIFY(!f.isNull());
+ auto f = classA->findFunction("unspecified");
+ QVERIFY(f);
QCOMPARE(f->exceptionSpecification(), ExceptionSpecification::Unknown);
QCOMPARE(f->generateExceptionHandling(), expectedGenerateUnspecified);
QCOMPARE(f->allowThread(), expectedAllowThread);
- f = classA->findFunction(QStringLiteral("nonThrowing"));
- QVERIFY(!f.isNull());
+ f = classA->findFunction("nonThrowing");
+ QVERIFY(f);
QCOMPARE(f->exceptionSpecification(), ExceptionSpecification::NoExcept);
QCOMPARE(f->generateExceptionHandling(), expectedGenerateNonThrowing);
- f = classA->findFunction(QStringLiteral("throwing"));
- QVERIFY(!f.isNull());
+ f = classA->findFunction("throwing");
+ QVERIFY(f);
QCOMPARE(f->exceptionSpecification(), ExceptionSpecification::Throws);
QCOMPARE(f->generateExceptionHandling(), expectedGenerateThrowing);
}
void TestModifyFunction::testSnakeCaseRenaming_data()
{
- QTest::addColumn<QString>("name");
- QTest::addColumn<QString>("expected");
+ QTest::addColumn<QLatin1StringView>("name");
+ QTest::addColumn<QLatin1StringView>("expected");
QTest::newRow("s1")
- << QStringLiteral("snakeCaseFunc") << QStringLiteral("snake_case_func");
+ << "snakeCaseFunc"_L1 << "snake_case_func"_L1;
QTest::newRow("s2")
- << QStringLiteral("SnakeCaseFunc") << QStringLiteral("snake_case_func");
+ << "SnakeCaseFunc"_L1 << "snake_case_func"_L1;
QTest::newRow("consecutive-uppercase")
- << QStringLiteral("snakeCAseFunc") << QStringLiteral("snakeCAseFunc");
+ << "snakeCAseFunc"_L1 << "snakeCAseFunc"_L1;
}
void TestModifyFunction::testSnakeCaseRenaming()
{
- QFETCH(QString, name);
- QFETCH(QString, expected);
+ QFETCH(QLatin1StringView, name);
+ QFETCH(QLatin1StringView, expected);
const QString actual = AbstractMetaBuilder::getSnakeCaseName(name);
QCOMPARE(actual, expected);
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-21 17:35:16 +0000