shiboken6: Port the MetaClass::find*() helpers to QAnyStringView

Task-number: PYSIDE-2537
Change-Id: I7d9c160b4b8c46854b11722c05510da766dcc3f5
Reviewed-by: Cristian Maureira-Fredes <cristian.maureira-fredes@qt.io>

40 files changed, 281 insertions, 236 deletions

diff --git a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
index 53be95ca8..a88de8c8a 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetabuilder.cpp
@@ -422,8 +422,8 @@ void AbstractMetaBuilderPrivate::sortLists()
     // this is a temporary solution before new type revision implementation
     // We need move QMetaObject register before QObject.
     Dependencies additionalDependencies;
-    if (auto qObjectClass = AbstractMetaClass::findClass(m_metaClasses, u"QObject")) {
-        if (auto qMetaObjectClass = AbstractMetaClass::findClass(m_metaClasses, u"QMetaObject")) {
+    if (auto qObjectClass = AbstractMetaClass::findClass(m_metaClasses, "QObject")) {
+        if (auto qMetaObjectClass = AbstractMetaClass::findClass(m_metaClasses, "QMetaObject")) {
             Dependency dependency;
             dependency.parent = qMetaObjectClass;
             dependency.child = qObjectClass;
diff --git a/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp b/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
index 23a44248e..0e3c41205 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetafunction.cpp
@@ -1398,7 +1398,7 @@ QString AbstractMetaFunction::modifiedName() const
 
 AbstractMetaFunctionCPtr
 AbstractMetaFunction::find(const AbstractMetaFunctionCList &haystack,
-                           QStringView needle)
+                           QAnyStringView needle)
 {
     for (const auto &f : haystack) {
         if (f->name() == needle)
diff --git a/sources/shiboken6/ApiExtractor/abstractmetafunction.h b/sources/shiboken6/ApiExtractor/abstractmetafunction.h
index 1966ff33b..80364bccc 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetafunction.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetafunction.h
@@ -393,7 +393,7 @@ public:
     bool isCallOperator() const;
 
     static AbstractMetaFunctionCPtr
-        find(const AbstractMetaFunctionCList &haystack, QStringView needle);
+        find(const AbstractMetaFunctionCList &haystack, QAnyStringView needle);
 
     bool matches(OperatorQueryOptions) const;
 
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
index ce0725378..c22f7f6eb 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang.cpp
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0
 
 #include "abstractmetalang.h"
+#include "anystringview_helpers.h"
 #include "abstractmetalang_helpers.h"
 #include "abstractmetaargument.h"
 #include "abstractmetaenum.h"
@@ -567,12 +568,12 @@ bool AbstractMetaClass::hasFunction(const QString &str) const
     return bool(findFunction(str));
 }
 
-AbstractMetaFunctionCPtr AbstractMetaClass::findFunction(QStringView functionName) const
+AbstractMetaFunctionCPtr AbstractMetaClass::findFunction(QAnyStringView functionName) const
 {
     return AbstractMetaFunction::find(d->m_functions, functionName);
 }
 
-AbstractMetaFunctionCList AbstractMetaClass::findFunctions(QStringView functionName) const
+AbstractMetaFunctionCList AbstractMetaClass::findFunctions(QAnyStringView functionName) const
 {
     AbstractMetaFunctionCList result;
     std::copy_if(d->m_functions.cbegin(), d->m_functions.cend(),
@@ -1715,12 +1716,12 @@ std::optional<AbstractMetaEnumValue>
 /// Target language base name or complete Target language package.class name.
 
 template <class It>
-static It findClassHelper(It begin, It end, QStringView name)
+static It findClassHelper(It begin, It end, QAnyStringView name)
 {
     if (name.isEmpty() || begin == end)
         return end;
 
-    if (name.contains(u'.')) { // Search target lang name
+    if (asv_contains(name,'.')) { // Search target lang name
         for (auto it = begin; it != end; ++it) {
             if ((*it)->fullName() == name)
                 return it;
@@ -1733,7 +1734,7 @@ static It findClassHelper(It begin, It end, QStringView name)
             return it;
     }
 
-    if (name.contains(u"::")) // Qualified, cannot possibly match name
+    if (asv_contains(name, "::")) // Qualified, cannot possibly match name
         return end;
 
     for (auto it = begin; it != end; ++it) {
@@ -1745,14 +1746,14 @@ static It findClassHelper(It begin, It end, QStringView name)
 }
 
 AbstractMetaClassPtr AbstractMetaClass::findClass(const AbstractMetaClassList &classes,
-                                                  QStringView name)
+                                                  QAnyStringView name)
 {
     auto it =findClassHelper(classes.cbegin(), classes.cend(), name);
     return it != classes.cend() ? *it : nullptr;
 }
 
 AbstractMetaClassCPtr AbstractMetaClass::findClass(const AbstractMetaClassCList &classes,
-                                                   QStringView name)
+                                                   QAnyStringView name)
 {
     auto it = findClassHelper(classes.cbegin(), classes.cend(), name);
     return it != classes.cend() ? *it : nullptr;
@@ -1791,7 +1792,7 @@ bool inheritsFrom(const AbstractMetaClassCPtr &c, const AbstractMetaClassCPtr &c
     }));
 }
 
-bool inheritsFrom(const AbstractMetaClassCPtr &c, const QString &name)
+bool inheritsFrom(const AbstractMetaClassCPtr &c, QAnyStringView name)
 {
     if (c->qualifiedCppName() == name)
         return true;
diff --git a/sources/shiboken6/ApiExtractor/abstractmetalang.h b/sources/shiboken6/ApiExtractor/abstractmetalang.h
index d5071a283..e9766a17b 100644
--- a/sources/shiboken6/ApiExtractor/abstractmetalang.h
+++ b/sources/shiboken6/ApiExtractor/abstractmetalang.h
@@ -70,8 +70,8 @@ public:
     static void addFunction(const AbstractMetaClassPtr &klass,
                             const AbstractMetaFunctionCPtr &function);
     bool hasFunction(const QString &str) const;
-    AbstractMetaFunctionCPtr findFunction(QStringView functionName) const;
-    AbstractMetaFunctionCList findFunctions(QStringView functionName) const;
+    AbstractMetaFunctionCPtr findFunction(QAnyStringView functionName) const;
+    AbstractMetaFunctionCList findFunctions(QAnyStringView functionName) const;
     AbstractMetaFunctionCPtr findOperatorBool() const;
     // Find a Qt-style isNull() method suitable for nb_bool
     AbstractMetaFunctionCPtr findQtIsNullMethod() const;
@@ -315,9 +315,9 @@ public:
                                                           bool avoidProtectedHack);
 
     static AbstractMetaClassPtr findClass(const AbstractMetaClassList &classes,
-                                        QStringView name);
+                                          QAnyStringView name);
     static AbstractMetaClassCPtr findClass(const AbstractMetaClassCList &classes,
-                                              QStringView name);
+                                           QAnyStringView name);
     static AbstractMetaClassPtr findClass(const AbstractMetaClassList &classes,
                                         const TypeEntryCPtr &typeEntry);
     static AbstractMetaClassCPtr findClass(const AbstractMetaClassCList &classes,
@@ -371,10 +371,10 @@ void AbstractMetaClass::invisibleNamespaceRecursion(Function f) const
 }
 
 bool inheritsFrom(const AbstractMetaClassCPtr &c, const AbstractMetaClassCPtr &other);
-bool inheritsFrom(const AbstractMetaClassCPtr &c, const QString &name);
+bool inheritsFrom(const AbstractMetaClassCPtr &c, QAnyStringView name);
 inline bool isQObject(const AbstractMetaClassCPtr &c)
 {
-    return inheritsFrom(c, QStringLiteral("QObject"));
+    return inheritsFrom(c, "QObject");
 }
 
 AbstractMetaClassCPtr findBaseClass(const AbstractMetaClassCPtr &c,
diff --git a/sources/shiboken6/ApiExtractor/anystringview_helpers.cpp b/sources/shiboken6/ApiExtractor/anystringview_helpers.cpp
index f26b2b6a5..504902f42 100644
--- a/sources/shiboken6/ApiExtractor/anystringview_helpers.cpp
+++ b/sources/shiboken6/ApiExtractor/anystringview_helpers.cpp
@@ -7,6 +7,8 @@
 #include <QtCore/QDebug>
 #include <QtCore/QTextStream>
 
+#include <cstring>
+
 QTextStream &operator<<(QTextStream &str, QAnyStringView asv)
 {
     asv.visit([&str](auto s) { str << s; });
@@ -21,3 +23,42 @@ QDebug operator<<(QDebug debug, QAnyStringView asv)
     asv.visit([&debug](auto s) { debug << s; });
     return debug;
 }
+
+static bool asv_containsImpl(QLatin1StringView v, char c)
+{
+    return v.contains(uint16_t(c));
+}
+
+static bool asv_containsImpl(QUtf8StringView v, char c)
+{
+    return std::strchr(v.data(), c) != nullptr;
+}
+
+static bool asv_containsImpl(QStringView v, char c)
+{
+    return v.contains(uint16_t(c));
+}
+
+bool asv_contains(QAnyStringView asv, char needle)
+{
+    return asv.visit([needle](auto s) { return asv_containsImpl(s, needle); });
+}
+
+static bool asv_containsImpl(QLatin1StringView v, const char *c)
+{
+    return v.contains(QLatin1StringView(c));
+}
+static bool asv_containsImpl(QUtf8StringView v, const char *c)
+{
+    return std::strstr(v.data(), c) != nullptr;
+}
+
+static bool asv_containsImpl(QStringView v, const char *c)
+{
+    return v.contains(QLatin1StringView(c));
+}
+
+bool asv_contains(QAnyStringView asv, const char *needle)
+{
+    return asv.visit([needle](auto s) { return asv_containsImpl(s, needle); });
+}
diff --git a/sources/shiboken6/ApiExtractor/anystringview_helpers.h b/sources/shiboken6/ApiExtractor/anystringview_helpers.h
index c3bab3369..ae6ee34bf 100644
--- a/sources/shiboken6/ApiExtractor/anystringview_helpers.h
+++ b/sources/shiboken6/ApiExtractor/anystringview_helpers.h
@@ -13,4 +13,7 @@ QT_FORWARD_DECLARE_CLASS(QDebug)
 QTextStream &operator<<(QTextStream &str, QAnyStringView asv);
 QDebug operator<<(QDebug debug, QAnyStringView asv);
 
+bool asv_contains(QAnyStringView asv, char needle);
+bool asv_contains(QAnyStringView asv, const char *needle);
+
 #endif // ANYSTRINGVIEW_STREAM_H
diff --git a/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp b/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
index a1940b762..ddfee1f0f 100644
--- a/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testabstractmetaclass.cpp
@@ -113,10 +113,10 @@ public:
     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");
+    const auto a = AbstractMetaClass::findClass(classes, "A");
+    const auto b = AbstractMetaClass::findClass(classes, "B");
+    const auto c = AbstractMetaClass::findClass(classes, "C");
+    const auto f = AbstractMetaClass::findClass(classes, "F");
     QVERIFY(f);
 
     QCOMPARE(a->baseClass(), nullptr);
@@ -196,10 +196,10 @@ class Derived : public Base {};
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto base = AbstractMetaClass::findClass(classes, u"Base");
+    const auto base = AbstractMetaClass::findClass(classes, "Base");
     QVERIFY(base);
     QVERIFY(base->isPolymorphic());
-    const auto derived = AbstractMetaClass::findClass(classes, u"Derived");
+    const auto derived = AbstractMetaClass::findClass(classes, "Derived");
     QVERIFY(derived);
     QVERIFY(derived->isPolymorphic());
 }
@@ -221,7 +221,7 @@ void TestAbstractMetaClass::testDefaultValues()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     const auto candidates = classA->queryFunctionsByName(u"method"_s);
     QCOMPARE(candidates.size(), 1);
     const auto &method = candidates.constFirst();
@@ -251,7 +251,7 @@ void TestAbstractMetaClass::testModifiedDefaultValues()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     const auto methodMatches = classA->queryFunctionsByName(u"method"_s);
     QCOMPARE(methodMatches.size(), 1);
     const auto method = methodMatches.constFirst();
@@ -277,10 +277,10 @@ void TestAbstractMetaClass::testInnerClassOfAPolymorphicOne()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QVERIFY(classA->isPolymorphic());
-    const auto classB = AbstractMetaClass::findClass(classes, u"A::B");
+    const auto classB = AbstractMetaClass::findClass(classes, "A::B");
     QVERIFY(classB);
     QVERIFY(!classB->isPolymorphic());
 }
@@ -305,11 +305,11 @@ void TestAbstractMetaClass::testForwardDeclaredInnerClass()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const auto classB = AbstractMetaClass::findClass(classes, u"A::B");
+    const auto classB = AbstractMetaClass::findClass(classes, "A::B");
     QVERIFY(classB);
-    const auto fooF = classB->findFunction(u"foo");
+    const auto fooF = classB->findFunction("foo");
     QVERIFY(fooF);
 }
 
@@ -337,7 +337,7 @@ void TestAbstractMetaClass::testSpecialFunctions()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
 
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     auto ctors = classA->queryFunctions(FunctionQueryOption::AnyConstructor);
     QCOMPARE(ctors.size(), 2);
@@ -348,7 +348,7 @@ void TestAbstractMetaClass::testSpecialFunctions()
     QCOMPARE(assigmentOps.constFirst()->functionType(),
              AbstractMetaFunction::AssignmentOperatorFunction);
 
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
     ctors = classB->queryFunctions(FunctionQueryOption::AnyConstructor);
     QCOMPARE(ctors.size(), 2);
@@ -403,7 +403,7 @@ void TestAbstractMetaClass::testClassDefaultConstructors()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 6);
 
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 2);
 
@@ -417,28 +417,28 @@ void TestAbstractMetaClass::testClassDefaultConstructors()
     QCOMPARE(ctors[1]->arguments().size(), 1);
     QCOMPARE(ctors[1]->minimalSignature(), u"A(A)");
 
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
     QCOMPARE(classB->functions().size(), 2);
     QCOMPARE(classB->functions().constFirst()->minimalSignature(), u"B()");
 
-    const auto classC = AbstractMetaClass::findClass(classes, u"C");
+    const auto classC = AbstractMetaClass::findClass(classes, "C");
     QVERIFY(classC);
     QCOMPARE(classC->functions().size(), 1);
     QCOMPARE(classC->functions().constFirst()->minimalSignature(), u"C(C)");
 
-    const auto classD = AbstractMetaClass::findClass(classes, u"D");
+    const auto classD = AbstractMetaClass::findClass(classes, "D");
     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");
+    const auto classE = AbstractMetaClass::findClass(classes, "E");
     QVERIFY(classE);
     QVERIFY(classE->hasPrivateDestructor());
     QCOMPARE(classE->functions().size(), 0);
 
-    const auto classF = AbstractMetaClass::findClass(classes, u"F");
+    const auto classF = AbstractMetaClass::findClass(classes, "F");
     QVERIFY(classF);
 
     ctors = classF->queryFunctions(FunctionQueryOption::AnyConstructor);
@@ -471,7 +471,7 @@ void TestAbstractMetaClass::testClassInheritedDefaultConstructors()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
 
     auto ctors = classA->queryFunctions(FunctionQueryOption::AnyConstructor);
@@ -485,7 +485,7 @@ void TestAbstractMetaClass::testClassInheritedDefaultConstructors()
     QCOMPARE(ctors[1]->minimalSignature(), u"A(A)");
     QVERIFY(ctors[1]->isPrivate());
 
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
 
     ctors = classB->queryFunctions(FunctionQueryOption::Constructors);
@@ -509,7 +509,7 @@ void TestAbstractMetaClass::testAbstractClassDefaultConstructors()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
 
     const auto ctors = classA->queryFunctions(FunctionQueryOption::Constructors);
@@ -530,7 +530,7 @@ void TestAbstractMetaClass::testObjectTypesMustNotHaveCopyConstructors()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
 
     const auto ctors = classA->queryFunctions(FunctionQueryOption::Constructors);
@@ -566,10 +566,10 @@ void TestAbstractMetaClass::testIsPolymorphic()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    const auto b = AbstractMetaClass::findClass(classes, u"A");
+    const auto b = AbstractMetaClass::findClass(classes, "A");
 
     QVERIFY(!b->isPolymorphic());
-    const auto a = AbstractMetaClass::findClass(classes, u"B");
+    const auto a = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(!a->isPolymorphic());
 }
 
@@ -596,9 +596,9 @@ class Derived : public BaseAlias2 {
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    const auto base = AbstractMetaClass::findClass(classes, u"Base");
+    const auto base = AbstractMetaClass::findClass(classes, "Base");
     QVERIFY(base);
-    const auto derived = AbstractMetaClass::findClass(classes, u"Derived");
+    const auto derived = AbstractMetaClass::findClass(classes, "Derived");
     QVERIFY(derived);
     QCOMPARE(derived->baseClasses().value(0), base);
 }
@@ -681,9 +681,9 @@ public:
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    const auto base = AbstractMetaClass::findClass(classes, u"Base");
+    const auto base = AbstractMetaClass::findClass(classes, "Base");
     QVERIFY(base);
-    const auto derived = AbstractMetaClass::findClass(classes, u"Derived");
+    const auto derived = AbstractMetaClass::findClass(classes, "Derived");
     QVERIFY(derived);
     const auto usingMembers = derived->usingMembers();
     QCOMPARE(usingMembers.size(), 2);
@@ -735,7 +735,7 @@ void TestAbstractMetaClass::testUsingTemplateMembers()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(code.constData(), xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto valueList = AbstractMetaClass::findClass(classes, u"ValueList");
+    const auto valueList = AbstractMetaClass::findClass(classes, "ValueList");
     QVERIFY(valueList);
     auto list = valueList->templateBaseClass();
     QVERIFY(valueList->isUsingMember(list, u"append"_s, Access::Public));
@@ -765,7 +765,7 @@ public:
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto tc = AbstractMetaClass::findClass(classes, u"TestClass");
+    const auto tc = AbstractMetaClass::findClass(classes, "TestClass");
     // Verify that the constructor and 2 functions are generated.
     const auto &functions = tc->functions();
     QCOMPARE(functions.size(), 5);
diff --git a/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp b/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp
index 4a2821db8..2c320c874 100644
--- a/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testabstractmetatype.cpp
@@ -161,7 +161,7 @@ void TestAbstractMetaType::testTypedef()
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    const auto c = AbstractMetaClass::findClass(classes, u"C");
+    const auto c = AbstractMetaClass::findClass(classes, "C");
     QVERIFY(c);
     QVERIFY(c->isTypeDef());
 }
@@ -211,7 +211,7 @@ void TestAbstractMetaType::testObjectTypeUsedAsValue()
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     const auto overloads = classA->queryFunctionsByName(u"method"_s);
     QCOMPARE(overloads.size(), 1);
diff --git a/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp b/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp
index c3d6e4a8a..3a9aafe39 100644
--- a/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testaddfunction.cpp
@@ -105,12 +105,12 @@ struct A {
     QVERIFY(builder);
     auto *typeDb = TypeDatabase::instance();
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     // default ctor, default copy ctor, func a() and the added functions
     QCOMPARE(classA->functions().size(), 5);
 
-    auto addedFunc = classA->findFunction(u"b");
+    auto addedFunc = classA->findFunction("b");
     QVERIFY(addedFunc);
     QCOMPARE(addedFunc->access(), Access::Protected);
     QCOMPARE(addedFunc->functionType(), AbstractMetaFunction::NormalFunction);
@@ -131,7 +131,7 @@ struct A {
     QCOMPARE(args.at(1).defaultValueExpression(), u"4.6");
     QCOMPARE(args.at(2).type().typeEntry(), typeDb->findType(u"B"_s));
 
-    auto addedCallOperator = classA->findFunction(u"operator()");
+    auto addedCallOperator = classA->findFunction("operator()");
     QVERIFY(addedCallOperator);
 }
 
@@ -148,7 +148,7 @@ void TestAddFunction::testAddFunctionConstructor()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 3); // default and added ctors
     const auto addedFunc = classA->functions().constLast();
@@ -171,7 +171,7 @@ void TestAddFunction::testAddFunctionTagDefaultValues()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     // default ctor, default copy ctor and the added function
     QCOMPARE(classA->functions().size(), 3);
@@ -197,7 +197,7 @@ void TestAddFunction::testAddFunctionCodeSnippets()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     const auto addedFunc = classA->functions().constLast();
     QVERIFY(addedFunc->hasInjectedCode());
@@ -227,9 +227,9 @@ void TestAddFunction::testAddFunctionWithoutParenteses()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const auto addedFunc = classA->findFunction(u"func");
+    const auto addedFunc = classA->findFunction("func");
     QVERIFY(addedFunc);
     QVERIFY(addedFunc->hasInjectedCode());
     const auto snips = addedFunc->injectedCodeSnips(TypeSystem::CodeSnipPositionAny,
@@ -264,9 +264,9 @@ void TestAddFunction::testAddFunctionWithDefaultArgs()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const auto addedFunc = classA->findFunction(u"func");
+    const auto addedFunc = classA->findFunction("func");
     QVERIFY(addedFunc);
     const AbstractMetaArgument &arg = addedFunc->arguments().at(1);
     QCOMPARE(arg.defaultValueExpression(), u"2");
@@ -287,7 +287,7 @@ void TestAddFunction::testAddFunctionAtModuleLevel()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
 
     auto *typeDb = TypeDatabase::instance();
@@ -328,9 +328,9 @@ void TestAddFunction::testAddFunctionWithVarargs()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const auto addedFunc = classA->findFunction(u"func");
+    const auto addedFunc = classA->findFunction("func");
     QVERIFY(addedFunc);
     const AbstractMetaArgument &arg = addedFunc->arguments().constLast();
     QVERIFY(arg.type().isVarargs());
@@ -352,9 +352,9 @@ void TestAddFunction::testAddStaticFunction()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const auto addedFunc = classA->findFunction(u"func");
+    const auto addedFunc = classA->findFunction("func");
     QVERIFY(addedFunc);
     QVERIFY(addedFunc->isStatic());
 }
@@ -378,10 +378,10 @@ void TestAddFunction::testAddGlobalFunction()
     QVERIFY(builder);
     const auto globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.size(), 2);
-    const auto classB = AbstractMetaClass::findClass(builder->classes(), u"B");
+    const auto classB = AbstractMetaClass::findClass(builder->classes(), "B");
     QVERIFY(classB);
-    QVERIFY(!classB->findFunction(u"globalFunc"));
-    QVERIFY(!classB->findFunction(u"globalFunc2"));
+    QVERIFY(!classB->findFunction("globalFunc"));
+    QVERIFY(!classB->findFunction("globalFunc2"));
     QVERIFY(!globalFuncs[0]->injectedCodeSnips().isEmpty());
     QVERIFY(!globalFuncs[1]->injectedCodeSnips().isEmpty());
 }
@@ -426,8 +426,8 @@ void TestAddFunction::testModifyAddedFunction()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto foo = AbstractMetaClass::findClass(classes, u"Foo");
-    const auto method = foo->findFunction(u"method");
+    const auto foo = AbstractMetaClass::findClass(classes, "Foo");
+    const auto method = foo->findFunction("method");
     QVERIFY(method);
     QCOMPARE(method->arguments().size(), 2);
     const AbstractMetaArgument &arg = method->arguments().at(1);
@@ -453,14 +453,14 @@ void TestAddFunction::testAddFunctionOnTypedef()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto foo = AbstractMetaClass::findClass(classes, u"FooInt");
+    const auto foo = AbstractMetaClass::findClass(classes, "FooInt");
     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");
+    const auto method = foo->findFunction("method");
     QVERIFY(method);
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp b/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp
index f4b22b27e..6e1820bed 100644
--- a/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testarrayargument.cpp
@@ -34,7 +34,7 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByInteger()
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
-    const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    const auto classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QVERIFY(classA);
 
     const AbstractMetaArgument &arg = classA->functions().constLast()->arguments().constFirst();
@@ -72,7 +72,7 @@ void TestArrayArgument::testArraySignature()
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
-    const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    const auto classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QCOMPARE(functionMinimalSignature(classA, u"mi1"_s),
              u"mi1(int[5])");
     QCOMPARE(functionMinimalSignature(classA, u"mi1c"_s),
@@ -108,7 +108,7 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValue()
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(!builder.isNull());
-    AbstractMetaClassPtr classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    AbstractMetaClassPtr classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QVERIFY(classA);
 
     auto someEnum = classA->findEnum(u"SomeEnum"_s);
@@ -139,7 +139,7 @@ void TestArrayArgument::testArrayArgumentWithSizeDefinedByEnumValueFromGlobalEnu
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(builder);
-    const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    const auto classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QVERIFY(classA);
 
     AbstractMetaEnum someEnum = builder->globalEnums().constFirst();
diff --git a/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp b/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp
index 58aaaf9b3..bab82ffa2 100644
--- a/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testcodeinjection.cpp
@@ -61,7 +61,7 @@ void TestCodeInjections::testReadFile()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode.toLocal8Bit().constData()));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QCOMPARE(classA->typeEntry()->codeSnips().size(), 1);
     QString code = classA->typeEntry()->codeSnips().constFirst().code();
     QVERIFY(code.indexOf(expected) != -1);
@@ -87,7 +87,7 @@ void TestCodeInjections::testInjectWithValidApiVersion()
                                                                 true, u"1.0"_s));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QCOMPARE(classA->typeEntry()->codeSnips().size(), 1);
 }
 
@@ -108,7 +108,7 @@ void TestCodeInjections::testInjectWithInvalidApiVersion()
     QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QCOMPARE(classA->typeEntry()->codeSnips().size(), 0);
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp b/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp
index 5a9b7d188..0bb72b3c1 100644
--- a/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testcontainer.cpp
@@ -32,7 +32,7 @@ void TestContainer::testContainerType()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
     //search for class A
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     auto baseContainer = classA->typeEntry()->baseContainerType();
     QVERIFY(baseContainer);
@@ -65,7 +65,7 @@ void TestContainer::testListOfValueType()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
 
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->templateBaseClassInstantiations().size(), 1);
     const AbstractMetaType templateInstanceType =
diff --git a/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp b/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp
index 092503622..8f2b277af 100644
--- a/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testconversionoperator.cpp
@@ -35,9 +35,9 @@ void TestConversionOperator::testConversionOperator()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     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");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
+    const auto classC = AbstractMetaClass::findClass(classes, "C");
     QVERIFY(classA);
     QVERIFY(classB);
     QVERIFY(classC);
@@ -73,7 +73,7 @@ void TestConversionOperator::testConversionOperatorOfDiscardedClass()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->externalConversionOperators().size(), 0);
 }
@@ -97,8 +97,8 @@ void TestConversionOperator::testRemovedConversionOperator()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classA);
     QVERIFY(classB);
     QCOMPARE(classA->functions().size(), 2);
@@ -123,8 +123,8 @@ void TestConversionOperator::testConversionOperatorReturningReference()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classA);
     QVERIFY(classB);
     QCOMPARE(classA->functions().size(), 2);
@@ -157,8 +157,8 @@ void TestConversionOperator::testConversionOperatorReturningConstReference()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classA);
     QVERIFY(classB);
     QCOMPARE(classA->functions().size(), 2);
diff --git a/sources/shiboken6/ApiExtractor/tests/testconversionruletag.cpp b/sources/shiboken6/ApiExtractor/tests/testconversionruletag.cpp
index 2d754427f..9cae84c89 100644
--- a/sources/shiboken6/ApiExtractor/tests/testconversionruletag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testconversionruletag.cpp
@@ -37,7 +37,7 @@ void TestConversionRuleTag::testConversionRuleTagWithFile()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode.toLocal8Bit().data()));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     const auto typeEntry = classA->typeEntry();
     QVERIFY(typeEntry->isValue());
@@ -154,7 +154,7 @@ if (!TargetDateTimeAPI) TargetDateTime_IMPORT;\n\
 
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
-    const auto classA = AbstractMetaClass::findClass(builder->classes(), u"Date");
+    const auto classA = AbstractMetaClass::findClass(builder->classes(), "Date");
     QVERIFY(classA);
 
     QVERIFY(classA->typeEntry()->isValue());
diff --git a/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp b/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp
index e225f91a1..c3a3ebef0 100644
--- a/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testctorinformation.cpp
@@ -22,13 +22,13 @@ void TestCtorInformation::testCtorIsPrivate()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
-    auto klass = AbstractMetaClass::findClass(classes, u"Control");
+    auto klass = AbstractMetaClass::findClass(classes, "Control");
     QVERIFY(klass);
     QVERIFY(klass->hasNonPrivateConstructor());
-    klass = AbstractMetaClass::findClass(classes, u"Subject");
+    klass = AbstractMetaClass::findClass(classes, "Subject");
     QVERIFY(klass);
     QVERIFY(!klass->hasNonPrivateConstructor());
-    klass = AbstractMetaClass::findClass(classes, u"CtorLess");
+    klass = AbstractMetaClass::findClass(classes, "CtorLess");
     QVERIFY(klass);
     QVERIFY(klass->hasNonPrivateConstructor());
 }
@@ -48,9 +48,9 @@ void TestCtorInformation::testHasNonPrivateCtor()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    const auto base = AbstractMetaClass::findClass(classes, u"Base");
+    const auto base = AbstractMetaClass::findClass(classes, "Base");
     QCOMPARE(base->hasNonPrivateConstructor(), true);
-    const auto derived = AbstractMetaClass::findClass(classes, u"Derived");
+    const auto derived = AbstractMetaClass::findClass(classes, "Derived");
     QCOMPARE(derived->hasNonPrivateConstructor(), true);
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp b/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp
index 0f65b1fc8..9b4ab38f5 100644
--- a/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testdroptypeentries.cpp
@@ -59,13 +59,13 @@ void TestDropTypeEntries::testDropEntries()
     QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
-    QVERIFY(AbstractMetaClass::findClass(classes, u"ValueA"));
-    QVERIFY(!AbstractMetaClass::findClass(classes, u"ValueB"));
-    QVERIFY(AbstractMetaClass::findClass(classes, u"ObjectA"));
-    QVERIFY(!AbstractMetaClass::findClass(classes, u"ObjectB"));
-    QVERIFY(AbstractMetaClass::findClass(classes, u"NamespaceA"));
-    QVERIFY(!AbstractMetaClass::findClass(classes, u"NamespaceA::InnerClassA"));
-    QVERIFY(!AbstractMetaClass::findClass(classes, u"NamespaceB"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "ValueA"));
+    QVERIFY(!AbstractMetaClass::findClass(classes, "ValueB"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "ObjectA"));
+    QVERIFY(!AbstractMetaClass::findClass(classes, "ObjectB"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "NamespaceA"));
+    QVERIFY(!AbstractMetaClass::findClass(classes, "NamespaceA::InnerClassA"));
+    QVERIFY(!AbstractMetaClass::findClass(classes, "NamespaceB"));
 
     AbstractMetaEnumList globalEnums = builder->globalEnums();
     QCOMPARE(globalEnums.size(), 1);
@@ -82,13 +82,13 @@ void TestDropTypeEntries::testDontDropEntries()
     QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
-    QVERIFY(AbstractMetaClass::findClass(classes, u"ValueA"));
-    QVERIFY(AbstractMetaClass::findClass(classes, u"ValueB"));
-    QVERIFY(AbstractMetaClass::findClass(classes, u"ObjectA"));
-    QVERIFY(AbstractMetaClass::findClass(classes, u"ObjectB"));
-    QVERIFY(AbstractMetaClass::findClass(classes, u"NamespaceA"));
-    QVERIFY(AbstractMetaClass::findClass(classes, u"NamespaceA::InnerClassA"));
-    QVERIFY(AbstractMetaClass::findClass(classes, u"NamespaceB"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "ValueA"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "ValueB"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "ObjectA"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "ObjectB"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "NamespaceA"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "NamespaceA::InnerClassA"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "NamespaceB"));
 
     QCOMPARE(builder->globalEnums().size(), 2);
 
@@ -116,7 +116,7 @@ void TestDropTypeEntries::testDropEntryWithChildTags()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode2, xmlCode2, false,
                                                                 QString(), droppedEntries));
     QVERIFY(builder);
-    QVERIFY(!AbstractMetaClass::findClass(builder->classes(), u"ValueA"));
+    QVERIFY(!AbstractMetaClass::findClass(builder->classes(), "ValueA"));
 }
 
 
@@ -124,7 +124,7 @@ void TestDropTypeEntries::testDontDropEntryWithChildTags()
 {
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode2, xmlCode2, false));
     QVERIFY(builder);
-    QVERIFY(AbstractMetaClass::findClass(builder->classes(), u"ValueA"));
+    QVERIFY(AbstractMetaClass::findClass(builder->classes(), "ValueA"));
 }
 
 void TestDropTypeEntries::testConditionalParsing_data()
diff --git a/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp b/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp
index de4cfd9f8..2152d39de 100644
--- a/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testdtorinformation.cpp
@@ -28,10 +28,10 @@ private:
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    auto klass = AbstractMetaClass::findClass(classes, u"Control");
+    auto klass = AbstractMetaClass::findClass(classes, "Control");
     QVERIFY(klass);
     QVERIFY(!klass->hasPrivateDestructor());
-    klass = AbstractMetaClass::findClass(classes, u"Subject");
+    klass = AbstractMetaClass::findClass(classes, "Subject");
     QVERIFY(klass);
     QVERIFY(klass->hasPrivateDestructor());
 }
@@ -56,10 +56,10 @@ protected:
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    auto klass = AbstractMetaClass::findClass(classes, u"Control");
+    auto klass = AbstractMetaClass::findClass(classes, "Control");
     QVERIFY(klass);
     QVERIFY(!klass->hasProtectedDestructor());
-    klass = AbstractMetaClass::findClass(classes, u"Subject");
+    klass = AbstractMetaClass::findClass(classes, "Subject");
     QVERIFY(klass);
     QVERIFY(klass->hasProtectedDestructor());
 }
@@ -84,10 +84,10 @@ protected:
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    auto klass = AbstractMetaClass::findClass(classes, u"Control");
+    auto klass = AbstractMetaClass::findClass(classes, "Control");
     QVERIFY(klass);
     QVERIFY(!klass->hasVirtualDestructor());
-    klass = AbstractMetaClass::findClass(classes, u"Subject");
+    klass = AbstractMetaClass::findClass(classes, "Subject");
     QVERIFY(klass);
     QVERIFY(klass->hasVirtualDestructor());
 }
@@ -110,17 +110,17 @@ class Subject : public SubjectBase {};
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 4);
 
-    auto klass = AbstractMetaClass::findClass(classes, u"ControlBase");
+    auto klass = AbstractMetaClass::findClass(classes, "ControlBase");
     QVERIFY(klass);
     QVERIFY(!klass->hasVirtualDestructor());
-    klass = AbstractMetaClass::findClass(classes, u"Control");
+    klass = AbstractMetaClass::findClass(classes, "Control");
     QVERIFY(klass);
     QVERIFY(!klass->hasVirtualDestructor());
 
-    klass = AbstractMetaClass::findClass(classes, u"SubjectBase");
+    klass = AbstractMetaClass::findClass(classes, "SubjectBase");
     QVERIFY(klass);
     QVERIFY(klass->hasVirtualDestructor());
-    klass = AbstractMetaClass::findClass(classes, u"Subject");
+    klass = AbstractMetaClass::findClass(classes, "Subject");
     QVERIFY(klass);
     QVERIFY(klass->hasVirtualDestructor());
 }
@@ -145,10 +145,10 @@ protected:
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    auto klass = AbstractMetaClass::findClass(classes, u"Control");
+    auto klass = AbstractMetaClass::findClass(classes, "Control");
     QVERIFY(klass);
     QVERIFY(klass->isPolymorphic());
-    klass = AbstractMetaClass::findClass(classes, u"Subject");
+    klass = AbstractMetaClass::findClass(classes, "Subject");
     QVERIFY(klass);
     QVERIFY(klass->isPolymorphic());
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testenum.cpp b/sources/shiboken6/ApiExtractor/tests/testenum.cpp
index 8a1f6c886..c7c2b8b3b 100644
--- a/sources/shiboken6/ApiExtractor/tests/testenum.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testenum.cpp
@@ -54,7 +54,7 @@ void TestEnum::testEnumCppSignature()
              u"A::ClassEnum");
 
     // enum as parameter of a method
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QCOMPARE(classA->enums().size(), 1);
     const auto funcs = classA->queryFunctionsByName(u"method"_s);
     QVERIFY(!funcs.isEmpty());
@@ -286,7 +286,7 @@ void TestEnum::testEnumValueFromExpression()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(builder);
 
-    AbstractMetaClassPtr classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    AbstractMetaClassPtr classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QVERIFY(classA);
 
     auto enumA = classA->findEnum(u"EnumA"_s);
@@ -364,7 +364,7 @@ void TestEnum::testPrivateEnum()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(builder);
 
-    const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    const auto classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QVERIFY(classA);
     QCOMPARE(classA->enums().size(), 2);
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp b/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp
index 63d02bb7c..fcc409a42 100644
--- a/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testextrainclude.cpp
@@ -23,7 +23,7 @@ void TestExtraInclude::testClassExtraInclude()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
 
     QList<Include> includes = classA->typeEntry()->extraIncludes();
@@ -46,7 +46,7 @@ void TestExtraInclude::testGlobalExtraIncludes()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    QVERIFY(AbstractMetaClass::findClass(classes, u"A"));
+    QVERIFY(AbstractMetaClass::findClass(classes, "A"));
 
     auto *td = TypeDatabase::instance();
     TypeSystemTypeEntryCPtr module = td->defaultTypeSystemType();
diff --git a/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp b/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp
index 56b80aaef..899d00ad4 100644
--- a/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testimplicitconversions.cpp
@@ -33,8 +33,8 @@ void TestImplicitConversions::testWithPrivateCtors()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
 
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    const auto classC = AbstractMetaClass::findClass(classes, u"C");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    const auto classC = AbstractMetaClass::findClass(classes, "C");
     const auto implicitConvs = classA->implicitConversions();
     QCOMPARE(implicitConvs.size(), 1);
     QCOMPARE(implicitConvs.constFirst()->arguments().constFirst().type().typeEntry(),
@@ -62,8 +62,8 @@ void TestImplicitConversions::testWithModifiedVisibility()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     const auto implicitConvs = classA->implicitConversions();
     QCOMPARE(implicitConvs.size(), 1);
     QCOMPARE(implicitConvs.constFirst()->arguments().constFirst().type().typeEntry(),
@@ -97,12 +97,12 @@ void TestImplicitConversions::testWithAddedCtor()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
 
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     auto implicitConvs = classA->implicitConversions();
     QCOMPARE(implicitConvs.size(), 2);
 
     // Added constructors with custom types should never result in implicit converters.
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     implicitConvs = classB->implicitConversions();
     QCOMPARE(implicitConvs.size(), 0);
 }
@@ -123,8 +123,8 @@ void TestImplicitConversions::testWithExternalConversionOperator()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     const auto implicitConvs = classA->implicitConversions();
     QCOMPARE(implicitConvs.size(), 1);
     const auto &externalConvOps = classA->externalConversionOperators();
diff --git a/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp b/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp
index 639925729..23cf0f9ea 100644
--- a/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testinserttemplate.cpp
@@ -28,7 +28,7 @@ void TestInsertTemplate::testInsertTemplateOnClassInjectCode()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->typeEntry()->codeSnips().size(), 1);
     QString code = classA->typeEntry()->codeSnips().constFirst().code();
diff --git a/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp b/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp
index ad9a071da..d40cb4d0e 100644
--- a/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testmodifydocumentation.cpp
@@ -34,7 +34,7 @@ R"(<typesystem package="Foo">
 )";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
-    const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    const auto classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QVERIFY(classA);
     DocModificationList docMods = classA->typeEntry()->docModifications();
     QCOMPARE(docMods.size(), 2);
@@ -95,9 +95,9 @@ void TestModifyDocumentation::testInjectAddedFunctionDocumentation()
 )XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
-    const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    const auto classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QVERIFY(classA);
-    const auto f = classA->findFunction(u"foo");
+    const auto f = classA->findFunction("foo");
     QVERIFY(f);
     QVERIFY(f->isUserAdded());
     auto docMods = f->addedFunctionDocModifications();
diff --git a/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp b/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
index c08f5a829..1e0e1b5bd 100644
--- a/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testmodifyfunction.cpp
@@ -48,8 +48,8 @@ void TestModifyFunction::testRenameArgument()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode.constData(), false));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
-    const auto func = classA->findFunction(u"method");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
+    const auto func = classA->findFunction("method");
     QVERIFY(func);
 
     QCOMPARE(func->argumentName(1), u"otherArg");
@@ -76,8 +76,8 @@ void TestModifyFunction::testOwnershipTransfer()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    const auto func = classB->findFunction(u"method");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
+    const auto func = classB->findFunction("method");
     QVERIFY(func);
 
     QCOMPARE(func->argumentTargetOwnership(func->ownerClass(), 0),
@@ -126,45 +126,45 @@ void TestModifyFunction::invalidateAfterUse()
                                                                 false, u"0.1"_s));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    auto func = classB->findFunction(u"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 auto classC = AbstractMetaClass::findClass(classes, u"C");
+    const auto classC = AbstractMetaClass::findClass(classes, "C");
     QVERIFY(classC);
-    func = classC->findFunction(u"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(u"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());
 
-    AbstractMetaClassCPtr classD =  AbstractMetaClass::findClass(classes, u"D");
+    AbstractMetaClassCPtr classD =  AbstractMetaClass::findClass(classes, "D");
     QVERIFY(classD);
-    func = classD->findFunction(u"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(u"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 auto classE = AbstractMetaClass::findClass(classes, u"E");
+    const auto classE = AbstractMetaClass::findClass(classes, "E");
     QVERIFY(classE);
-    func = classE->findFunction(u"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(u"call2");
+    func = classE->findFunction("call2");
     QVERIFY(func);
     QCOMPARE(func->modifications().size(), 1);
     QCOMPARE(func->modifications().at(0).argument_mods().size(), 1);
@@ -199,13 +199,13 @@ void TestModifyFunction::testWithApiVersion()
                                                                 false, u"0.1"_s));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    auto func = classB->findFunction(u"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(u"methodB");
+    func = classB->findFunction("methodB");
     returnOwnership = func->argumentTargetOwnership(func->ownerClass(), 0);
     QVERIFY(returnOwnership != TypeSystem::CppOwnership);
 }
@@ -238,31 +238,31 @@ struct A {
                                                                 false, u"0.1"_s));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
 
     // Nothing specified, true
-    const auto f1 = classA->findFunction(u"f1");
+    const auto f1 = classA->findFunction("f1");
     QVERIFY(f1);
     QVERIFY(!f1->allowThread());
 
     // 'auto' specified, should be false for nontrivial function
-    const auto f2 = classA->findFunction(u"f2");
+    const auto f2 = classA->findFunction("f2");
     QVERIFY(f2);
     QVERIFY(f2->allowThread());
 
     // 'no' specified, should be false
-    const auto f3 = classA->findFunction(u"f3");
+    const auto f3 = classA->findFunction("f3");
     QVERIFY(f3);
     QVERIFY(!f3->allowThread());
 
     // Nothing specified, should be false for simple getter
-    const auto getter1 = classA->findFunction(u"getter1");
+    const auto getter1 = classA->findFunction("getter1");
     QVERIFY(getter1);
     QVERIFY(!getter1->allowThread());
 
     // Forced to true simple getter
-    const auto getter2 = classA->findFunction(u"getter2");
+    const auto getter2 = classA->findFunction("getter2");
     QVERIFY(getter2);
     QVERIFY(getter2->allowThread()); // Forced to true simple getter
 }
@@ -436,7 +436,7 @@ void TestModifyFunction::testScopedModifications()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode.constData(), xmlCode.constData(), false));
     QVERIFY(builder);
 
-    const auto classA = AbstractMetaClass::findClass(builder->classes(), u"A");
+    const auto classA = AbstractMetaClass::findClass(builder->classes(), "A");
     QVERIFY(classA);
 
     auto f = classA->findFunction(QStringLiteral("unspecified"));
diff --git a/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp b/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp
index e47aa7682..1cf4c8e0f 100644
--- a/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testmultipleinheritance.cpp
@@ -35,7 +35,7 @@ void TestMultipleInheritance::testVirtualClass()
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 4);
 
-    const auto classD = AbstractMetaClass::findClass(classes, u"D");
+    const auto classD = AbstractMetaClass::findClass(classes, "D");
     bool functionFound = false;
     for (const auto &f : classD->functions()) {
         if (f->name() == u"theBug") {
diff --git a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
index 974dd0bd8..3773e614a 100644
--- a/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testnamespace.cpp
@@ -33,11 +33,11 @@ void NamespaceTest::testNamespaceMembers()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto ns = AbstractMetaClass::findClass(classes, u"Namespace");
+    const auto ns = AbstractMetaClass::findClass(classes, "Namespace");
     QVERIFY(ns);
     auto metaEnum = ns->findEnum(u"Option"_s);
     QVERIFY(metaEnum.has_value());
-    const auto func = ns->findFunction(u"foo");
+    const auto func = ns->findFunction("foo");
     QVERIFY(func);
 }
 
@@ -63,13 +63,13 @@ void NamespaceTest::testNamespaceInnerClassMembers()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto ons = AbstractMetaClass::findClass(classes, u"OuterNamespace");
+    const auto ons = AbstractMetaClass::findClass(classes, "OuterNamespace");
     QVERIFY(ons);
-    const auto ins = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace");
+    const auto ins = AbstractMetaClass::findClass(classes, "OuterNamespace::InnerNamespace");
     QVERIFY(ins);
-    const auto sc = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace::SomeClass");
+    const auto sc = AbstractMetaClass::findClass(classes, "OuterNamespace::InnerNamespace::SomeClass");
     QVERIFY(sc);
-    const auto meth = sc->findFunction(u"method");
+    const auto meth = sc->findFunction("method");
     QVERIFY(meth);
 }
 
diff --git a/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp b/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp
index 9af411b1a..10ca1a0f6 100644
--- a/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testnestedtypes.cpp
@@ -46,10 +46,10 @@ void TestNestedTypes::testNestedTypesModifications()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
-    const auto ons = AbstractMetaClass::findClass(classes, u"OuterNamespace");
+    const auto ons = AbstractMetaClass::findClass(classes, "OuterNamespace");
     QVERIFY(ons);
 
-    const auto ins = AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace");
+    const auto ins = AbstractMetaClass::findClass(classes, "OuterNamespace::InnerNamespace");
     QVERIFY(ins);
     QCOMPARE(ins->functions().size(), 1);
     QCOMPARE(ins->typeEntry()->codeSnips().size(), 1);
@@ -69,7 +69,7 @@ void TestNestedTypes::testNestedTypesModifications()
     QCOMPARE(snip.code().trimmed(), u"custom_code2();");
 
     const auto sc =
-        AbstractMetaClass::findClass(classes, u"OuterNamespace::InnerNamespace::SomeClass");
+        AbstractMetaClass::findClass(classes, "OuterNamespace::InnerNamespace::SomeClass");
     QVERIFY(sc);
     QCOMPARE(sc->functions().size(), 2); // default constructor and removed method
     const auto removedFunc = sc->functions().constLast();
@@ -96,11 +96,11 @@ void TestNestedTypes::testDuplicationOfNestedTypes()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 2);
-    const auto nspace = AbstractMetaClass::findClass(classes, u"Namespace");
+    const auto nspace = AbstractMetaClass::findClass(classes, "Namespace");
     QVERIFY(nspace);
-    const auto cls1 = AbstractMetaClass::findClass(classes, u"SomeClass");
+    const auto cls1 = AbstractMetaClass::findClass(classes, "SomeClass");
     QVERIFY(cls1);
-    const auto cls2 = AbstractMetaClass::findClass(classes, u"Namespace::SomeClass");
+    const auto cls2 = AbstractMetaClass::findClass(classes, "Namespace::SomeClass");
     QVERIFY(cls2);
     QCOMPARE(cls1, cls2);
     QCOMPARE(cls1->name(), u"SomeClass");
diff --git a/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp b/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp
index b941094f8..99cced09d 100644
--- a/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testprimitivetypetag.cpp
@@ -27,7 +27,7 @@ void TestPrimitiveTypeTag::testPrimitiveTypeDefaultConstructor()
 
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
 
     auto typeEntry = TypeDatabase::instance()->findPrimitiveType(u"A"_s);
diff --git a/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp b/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp
index 22f8b7a8e..f2e261624 100644
--- a/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testrefcounttag.cpp
@@ -34,8 +34,8 @@ void TestRefCountTag::testReferenceCountTag()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    const auto func = classB->findFunction(u"keepObject");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
+    const auto func = classB->findFunction("keepObject");
     QVERIFY(func);
     const auto refCount =
         func->modifications().constFirst().argument_mods().constFirst().referenceCounts().constFirst();
@@ -68,8 +68,8 @@ void TestRefCountTag::testWithApiVersion()
                                                                 false, u"0.1"_s));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
-    const auto func = classB->findFunction(u"keepObject");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
+    const auto func = classB->findFunction("keepObject");
     QVERIFY(func);
     const auto refCount =
         func->modifications().constFirst().argument_mods().constFirst().referenceCounts().constFirst();
diff --git a/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp b/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp
index e3b18758b..ae85c5a86 100644
--- a/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testreferencetopointer.cpp
@@ -25,9 +25,9 @@ void TestReferenceToPointer::testReferenceToPointerArgument()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
-    const auto func = classB->findFunction(u"dummy");
+    const auto func = classB->findFunction("dummy");
     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 a12675855..8739e8dc8 100644
--- a/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testremovefield.cpp
@@ -25,7 +25,7 @@ void TestRemoveField::testRemoveField()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->fields().size(), 1);
     const AbstractMetaField &fieldA = classA->fields().constFirst();
diff --git a/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp b/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp
index e6c5eb0c1..87e318e95 100644
--- a/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testremoveimplconv.cpp
@@ -33,11 +33,11 @@ void TestRemoveImplConv::testRemoveImplConv()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
-    const auto classC = AbstractMetaClass::findClass(classes, u"C");
+    const auto classC = AbstractMetaClass::findClass(classes, "C");
     QVERIFY(classC);
     const auto implConv = classC->implicitConversions();
     QCOMPARE(implConv.size(), 1);
diff --git a/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp b/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp
index c2a91c8a9..17a069b5e 100644
--- a/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testremoveoperatormethod.cpp
@@ -70,7 +70,7 @@ struct A {
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 14);
     QStringList removedSignatures;
diff --git a/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp b/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
index 5e486ea51..67ebcc606 100644
--- a/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
@@ -49,9 +49,9 @@ void TestResolveType::testResolveReturnTypeFromParentScope()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classD = AbstractMetaClass::findClass(classes, u"A::D");
+    const auto classD = AbstractMetaClass::findClass(classes, "A::D");
     QVERIFY(classD);
-    const auto meth = classD->findFunction(u"method");
+    const auto meth = classD->findFunction("method");
     QVERIFY(meth);
     QVERIFY(meth);
 }
@@ -125,7 +125,7 @@ public:
     fixture->classType = AbstractMetaType(fixture->klass->typeEntry());
     fixture->classType.decideUsagePattern();
 
-    for (const auto &f : fixture->klass->findFunctions(u"Test"_s)) {
+    for (const auto &f : fixture->klass->findFunctions("Test")) {
         if (f->functionType() == AbstractMetaFunction::ConstructorFunction
             && f->arguments().size() == 1) {
             const auto type = f->arguments().constFirst().type();
@@ -138,7 +138,7 @@ public:
     if (fixture->intType.isVoid() || fixture->stringType.isVoid())
         return -3;
 
-    auto listFunc = fixture->klass->findFunction(u"listFunc"_s);
+    auto listFunc = fixture->klass->findFunction("listFunc");
     if (!listFunc || listFunc->arguments().size() != 1)
         return -3;
     fixture->listType = listFunc->arguments().constFirst().type();
@@ -265,7 +265,7 @@ public:
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto testClass = AbstractMetaClass::findClass(classes, u"Test");
+    const auto testClass = AbstractMetaClass::findClass(classes, "Test");
     QVERIFY(testClass);
 
     auto *tdb = TypeDatabase::instance();
diff --git a/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp b/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp
index fcbdbc4e6..f4eecff2c 100644
--- a/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testreverseoperators.cpp
@@ -27,7 +27,7 @@ void TestReverseOperators::testReverseSum()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 4);
 
@@ -69,11 +69,11 @@ void TestReverseOperators::testReverseSumWithAmbiguity()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QCOMPARE(classA->functions().size(), 4);
 
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
     QCOMPARE(classB->functions().size(), 4);
 
@@ -114,7 +114,7 @@ void  TestReverseOperators::testSpaceshipOperator()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
-    const auto testClass = AbstractMetaClass::findClass(classes, u"Test");
+    const auto testClass = AbstractMetaClass::findClass(classes, "Test");
     QVERIFY(testClass);
     const auto &functions = testClass->functions();
     // 6 operators should be synthesized
diff --git a/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp b/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
index eba2ecea9..8d0ea055b 100644
--- a/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testtemplates.cpp
@@ -58,9 +58,9 @@ namespace Internet {
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
-    const auto classB = AbstractMetaClass::findClass(classes, u"Bookmarks");
+    const auto classB = AbstractMetaClass::findClass(classes, "Bookmarks");
     QVERIFY(classB);
-    const auto func = classB->findFunction(u"list");
+    const auto func = classB->findFunction("list");
     QVERIFY(func);
     AbstractMetaType funcType = func->type();
     QVERIFY(!funcType.isVoid());
@@ -96,11 +96,11 @@ namespace Namespace {
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
     QVERIFY(!classB->baseClass());
     QVERIFY(classB->baseClassName().isEmpty());
-    const auto func = classB->findFunction(u"foo");
+    const auto func = classB->findFunction("foo");
     QVERIFY(func);
     AbstractMetaType argType = func->arguments().constFirst().type();
     QCOMPARE(argType.instantiations().size(), 1);
@@ -255,7 +255,7 @@ struct FooBars : public ListContainer<FooBar> {};
     QCOMPARE(classes.size(), 2);
     QCOMPARE(templates.size(), 1);
 
-    const auto foobars = AbstractMetaClass::findClass(classes, u"FooBars");
+    const auto foobars = AbstractMetaClass::findClass(classes, "FooBars");
     QCOMPARE(foobars->functions().size(), 4);
 
     AbstractMetaClassCPtr lc = templates.constFirst();
@@ -289,7 +289,7 @@ template<SomeEnum type> struct Future {};
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
     QVERIFY(!classB->baseClass());
     QVERIFY(classB->baseClassName().isEmpty());
@@ -328,7 +328,7 @@ template<SomeEnum type> struct Future {};
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
-    const auto classB = AbstractMetaClass::findClass(classes, u"Namespace::B");
+    const auto classB = AbstractMetaClass::findClass(classes, "Namespace::B");
     QVERIFY(classB);
     QVERIFY(!classB->baseClass());
     QVERIFY(classB->baseClassName().isEmpty());
@@ -365,9 +365,9 @@ typedef BaseTemplateClass<TypeOne> TypeOneClass;
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 3);
 
-    const auto base = AbstractMetaClass::findClass(classes, u"BaseTemplateClass");
+    const auto base = AbstractMetaClass::findClass(classes, "BaseTemplateClass");
     QVERIFY(base);
-    const auto one = AbstractMetaClass::findClass(classes, u"TypeOneClass");
+    const auto one = AbstractMetaClass::findClass(classes, "TypeOneClass");
     QVERIFY(one);
     QCOMPARE(one->templateBaseClass(), base);
     QCOMPARE(one->functions().size(), base->functions().size());
@@ -414,7 +414,7 @@ typedef Vector<int> IntVector;
     AbstractMetaClassList classes = builder->classes();
     QCOMPARE(classes.size(), 1);
 
-    const auto vector = AbstractMetaClass::findClass(classes, u"IntVector");
+    const auto vector = AbstractMetaClass::findClass(classes, "IntVector");
     QVERIFY(vector);
     auto baseContainer = vector->typeEntry()->baseContainerType();
     QVERIFY(baseContainer);
@@ -422,11 +422,11 @@ typedef Vector<int> IntVector;
              ContainerTypeEntry::ListContainer);
     QCOMPARE(vector->functions().size(), 4);
 
-    const auto method = vector->findFunction(u"method");
+    const auto method = vector->findFunction("method");
     QVERIFY(method);
     QCOMPARE(method->signature(), u"method(const Vector<int> & vector)");
 
-    const auto otherMethod = vector->findFunction(u"otherMethod");
+    const auto otherMethod = vector->findFunction("otherMethod");
     QVERIFY(otherMethod);
     QCOMPARE(otherMethod->signature(), u"otherMethod()");
     QVERIFY(!otherMethod->type().isVoid());
@@ -540,26 +540,26 @@ void TestTemplates::testTemplateTypeDefs()
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
 
-    const auto optional = AbstractMetaClass::findClass(classes, u"Optional");
+    const auto optional = AbstractMetaClass::findClass(classes, "Optional");
     QVERIFY(optional);
 
     // Find the typedef'ed class
-    const auto optionalInt = AbstractMetaClass::findClass(classes, u"IntOptional");
+    const auto optionalInt = AbstractMetaClass::findClass(classes, "IntOptional");
     QVERIFY(optionalInt);
     QCOMPARE(optionalInt->templateBaseClass(), optional);
 
     // Find the class typedef'ed in the typesystem XML
-    const auto xmlOptionalInt = AbstractMetaClass::findClass(classes, u"XmlIntOptional");
+    const auto xmlOptionalInt = AbstractMetaClass::findClass(classes, "XmlIntOptional");
     QVERIFY(xmlOptionalInt);
     QCOMPARE(xmlOptionalInt->templateBaseClass(), optional);
 
     // Check whether the value() method now has an 'int' return
-    const auto valueMethod = optionalInt->findFunction(u"value");
+    const auto valueMethod = optionalInt->findFunction("value");
     QVERIFY(valueMethod);
     QCOMPARE(valueMethod->type().cppSignature(), u"int");
 
     // ditto for typesystem XML
-    const auto xmlValueMethod = xmlOptionalInt->findFunction(u"value");
+    const auto xmlValueMethod = xmlOptionalInt->findFunction("value");
     QVERIFY(xmlValueMethod);
     QCOMPARE(xmlValueMethod->type().cppSignature(), u"int");
 
@@ -609,7 +609,7 @@ public:
     QVERIFY(builder);
 
     AbstractMetaClassList classes = builder->classes();
-    const auto testClass = AbstractMetaClass::findClass(classes, u"Test");
+    const auto testClass = AbstractMetaClass::findClass(classes, "Test");
     QVERIFY(testClass);
 
     auto fields = testClass->fields();
@@ -618,7 +618,7 @@ public:
     QCOMPARE(fieldType.name(), u"Container1");
     QCOMPARE(fieldType.instantiations().size(), 1);
 
-    const auto derived = AbstractMetaClass::findClass(classes, u"Derived");
+    const auto derived = AbstractMetaClass::findClass(classes, "Derived");
     QVERIFY(derived);
     auto base = derived->templateBaseClass();
     QVERIFY(base);
diff --git a/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp b/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp
index a7c83907b..72dae8cc5 100644
--- a/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testtyperevision.cpp
@@ -32,13 +32,13 @@ void TestTypeRevision::testRevisionAttr()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto rev0 = AbstractMetaClass::findClass(classes, u"Rev_0");
+    const auto rev0 = AbstractMetaClass::findClass(classes, "Rev_0");
     QCOMPARE(rev0->typeEntry()->revision(), 0);
 
-    const auto rev1 = AbstractMetaClass::findClass(classes, u"Rev_1");
+    const auto rev1 = AbstractMetaClass::findClass(classes, "Rev_1");
     QCOMPARE(rev1->typeEntry()->revision(), 1);
 
-    const auto rev2 = AbstractMetaClass::findClass(classes, u"Rev_2");
+    const auto rev2 = AbstractMetaClass::findClass(classes, "Rev_2");
     QCOMPARE(rev2->typeEntry()->revision(), 2);
 
     auto rev3 = rev2->findEnum(u"Rev_3"_s);
diff --git a/sources/shiboken6/ApiExtractor/tests/testvaluetypedefaultctortag.cpp b/sources/shiboken6/ApiExtractor/tests/testvaluetypedefaultctortag.cpp
index 19143e895..98e30eac2 100644
--- a/sources/shiboken6/ApiExtractor/tests/testvaluetypedefaultctortag.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testvaluetypedefaultctortag.cpp
@@ -26,12 +26,12 @@ void TestValueTypeDefaultCtorTag::testValueTypeDefaultCtorTagArgument()
 
     AbstractMetaClassList classes = builder->classes();
 
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
     QVERIFY(classA->typeEntry()->hasDefaultConstructor());
     QCOMPARE(classA->typeEntry()->defaultConstructor(), u"A(0, 0)");
 
-    const auto classB = AbstractMetaClass::findClass(classes, u"B");
+    const auto classB = AbstractMetaClass::findClass(classes, "B");
     QVERIFY(classB);
     QVERIFY(!classB->typeEntry()->hasDefaultConstructor());
 }
diff --git a/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp b/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp
index b472cbfba..a600181a5 100644
--- a/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testvoidarg.cpp
@@ -19,9 +19,9 @@ void TestVoidArg::testVoidParsedFunction()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const auto addedFunc = classA->findFunction(u"a");
+    const auto addedFunc = classA->findFunction("a");
     QVERIFY(addedFunc);
     QCOMPARE(addedFunc->arguments().size(), 0);
 }
@@ -38,9 +38,9 @@ void TestVoidArg::testVoidAddedFunction()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const auto addedFunc = classA->findFunction(u"a");
+    const auto addedFunc = classA->findFunction("a");
     QVERIFY(addedFunc);
     QCOMPARE(addedFunc->arguments().size(), 0);
 
@@ -56,9 +56,9 @@ void TestVoidArg::testVoidPointerParsedFunction()
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode));
     QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const auto classA = AbstractMetaClass::findClass(classes, u"A");
+    const auto classA = AbstractMetaClass::findClass(classes, "A");
     QVERIFY(classA);
-    const auto addedFunc = classA->findFunction(u"a");
+    const auto addedFunc = classA->findFunction("a");
     QVERIFY(addedFunc);
     QCOMPARE(addedFunc->arguments().size(), 1);
 
diff --git a/sources/shiboken6/generator/shiboken/cppgenerator.cpp b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
index 74a9d8e91..4d30c7ad2 100644
--- a/sources/shiboken6/generator/shiboken/cppgenerator.cpp
+++ b/sources/shiboken6/generator/shiboken/cppgenerator.cpp
@@ -4337,7 +4337,7 @@ void CppGenerator::writeClassDefinition(TextStream &s,
     if (hasHashFunction(metaClass))
         tp_hash = u'&' + cpythonBaseName(metaClass) + u"_HashFunc"_s;
 
-    const auto callOp = metaClass->findFunction(u"operator()");
+    const auto callOp = metaClass->findFunction("operator()");
     if (callOp && !callOp->isModifiedRemoved())
         tp_call = u'&' + cpythonFunctionName(callOp);