amass/qt6windows7
1
0
Fork 0
mirror of https://github.com/crystalidea/qt6windows7.git synced 2025-07-07 01:35:25 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

qt 6.6.0 clean

Browse Source
This commit is contained in:
kleuter
2023-11-01 22:23:55 +01:00
parent 7b5ada15e7
commit 5d8194efa7
1449 changed files with 134276 additions and 31391 deletions
Download Patch File Download Diff File Expand all files Collapse all files

244
tests/auto/tools/moc/tst_moc.cpp
View File

@ -11,6 +11,8 @@
#include <qversionnumber.h>
#include <qregularexpression.h>
#include <private/qobject_p.h>
#include "using-namespaces.h"
#include "assign-namespace.h"
#include "no-keywords.h"
@ -111,6 +113,12 @@ public:
Key2
};
Q_ENUM(TestGEnum2)
enum TestGEnum3: quint8 {
Key1 = 23,
Key2
};
Q_ENUM(TestGEnum3)
};
}
@ -129,6 +137,12 @@ namespace TestQNamespace {
};
Q_ENUM_NS(TestEnum2)
enum TestEnum3: qint8 {
Key1 = 23,
Key2
};
Q_ENUM_NS(TestEnum3)
// try to dizzy moc by adding a struct in between
struct TestGadget {
Q_GADGET
@ -141,8 +155,13 @@ namespace TestQNamespace {
Key1 = 23,
Key2
};
enum TestGEnum3: qint16 {
Key1 = 33,
Key2
};
Q_ENUM(TestGEnum1)
Q_ENUM(TestGEnum2)
Q_ENUM(TestGEnum3)
};
struct TestGadgetExport {
@ -159,6 +178,12 @@ namespace TestQNamespace {
Key2
};
Q_ENUM(TestGeEnum2)
enum TestGeEnum3: quint16 {
Key1 = 26,
Key2
};
Q_ENUM(TestGeEnum3)
};
enum class TestFlag1 {
@ -178,6 +203,27 @@ namespace TestQNamespace {
Q_FLAG_NS(TestFlag2)
}
namespace TestSameEnumNamespace {
Q_NAMESPACE
enum class TestSameEnumNamespace {
Key1 = 1,
Key2 = 2,
};
Q_ENUM_NS(TestSameEnumNamespace)
}
namespace TestNestedSameEnumNamespace {
namespace a {
Q_NAMESPACE
// enum class with the same name as the enclosing nested namespace
enum class a {
Key11 = 11,
Key12 = 12,
};
Q_ENUM_NS(a)
}
}
namespace TestExportNamespace {
Q_NAMESPACE_EXPORT(TESTEXPORTMACRO)
@ -724,6 +770,7 @@ private slots:
void templateGtGt();
void qprivateslots();
void qprivateproperties();
void anonymousProperties();
void warnOnPropertyWithoutREAD();
void constructors();
void typenameWithUnsigned();
@ -768,6 +815,7 @@ private slots:
void optionsFileError_data();
void optionsFileError();
void testQNamespace();
void testNestedQNamespace();
void cxx17Namespaces();
void cxxAttributes();
void mocJsonOutput();
@ -778,6 +826,7 @@ private slots:
void setQPRopertyBinding();
void privateQPropertyShim();
void readWriteThroughBindable();
void invokableCtors();
void virtualInlineTaggedSlot();
signals:
@ -1662,6 +1711,54 @@ void tst_Moc::qprivateproperties()
QVERIFY(zapBindable.isBindable());
}
class AnonymousPropertyTest1 : public QObject
{
Q_OBJECT
QT_ANONYMOUS_PROPERTY(int READ foo WRITE setFoo)
public:
int foo() { return mFoo ; }
void setFoo(int value) { mFoo = value; }
private:
int mFoo = 0;
};
class AnonymousPropertyTest2 : public QObject
{
Q_OBJECT
QT_ANONYMOUS_PRIVATE_PROPERTY(d, int READ bar WRITE setBar)
class MyDPointer {
public:
int bar() { return mBar ; }
void setBar(int value) { mBar = value; }
private:
int mBar = 0;
};
public:
AnonymousPropertyTest2(QObject *parent = nullptr) : QObject(parent), d (new MyDPointer) {}
MyDPointer *d_func() {return d.data();}
const MyDPointer *d_func() const {return d.data();}
private:
QScopedPointer<MyDPointer> d;
};
void tst_Moc::anonymousProperties()
{
AnonymousPropertyTest1 test1;
test1.setProperty("", 17);
QCOMPARE(test1.property(""), QVariant::fromValue(17));
AnonymousPropertyTest2 test2;
test2.setProperty("", 27);
QCOMPARE(test2.property(""), QVariant::fromValue(27));
}
void tst_Moc::warnOnPropertyWithoutREAD()
{
#ifdef MOC_CROSS_COMPILED
@ -2128,7 +2225,7 @@ void tst_Moc::warnings_data()
<< QStringList()
<< 0
<< QString()
<< QString("standard input:0:1: note: No relevant classes found. No output generated.");
<< QString("standard input: note: No relevant classes found. No output generated.");
// passing "-nn" should suppress "no relevant classes" note
QTest::newRow("-nn")
@ -2270,7 +2367,7 @@ void tst_Moc::warnings_data()
<< QStringList()
<< 1
<< QString("IGNORE_ALL_STDOUT")
<< QString(":-1:1: error: Unexpected character in macro argument list.");
<< QString(": error: Unexpected character in macro argument list.");
QTest::newRow("Missing header warning")
<< QByteArray("class X : public QObject { Q_OBJECT };")
@ -2404,23 +2501,29 @@ void tst_Moc::cxx11Enums_data()
QTest::addColumn<QByteArray>("enumName");
QTest::addColumn<char>("prefix");
QTest::addColumn<bool>("isScoped");
QTest::addColumn<bool>("isTyped");
const QMetaObject *meta1 = &CXX11Enums::staticMetaObject;
const QMetaObject *meta2 = &CXX11Enums2::staticMetaObject;
const QMetaObject *meta3 = &CXX11Enums3::staticMetaObject;
QTest::newRow("EnumClass") << meta1 << QByteArray("EnumClass") << QByteArray("EnumClass") << 'A' << true;
QTest::newRow("EnumClass 2") << meta2 << QByteArray("EnumClass") << QByteArray("EnumClass") << 'A' << true;
QTest::newRow("TypedEnum") << meta1 << QByteArray("TypedEnum") << QByteArray("TypedEnum") << 'B' << false;
QTest::newRow("TypedEnum 2") << meta2 << QByteArray("TypedEnum") << QByteArray("TypedEnum") << 'B' << false;
QTest::newRow("TypedEnumClass") << meta1 << QByteArray("TypedEnumClass") << QByteArray("TypedEnumClass") << 'C' << true;
QTest::newRow("TypedEnumClass 2") << meta2 << QByteArray("TypedEnumClass") << QByteArray("TypedEnumClass") << 'C' << true;
QTest::newRow("NormalEnum") << meta1 << QByteArray("NormalEnum") << QByteArray("NormalEnum") << 'D' << false;
QTest::newRow("NormalEnum 2") << meta2 << QByteArray("NormalEnum") << QByteArray("NormalEnum") << 'D' << false;
QTest::newRow("ClassFlags") << meta1 << QByteArray("ClassFlags") << QByteArray("ClassFlag") << 'F' << true;
QTest::newRow("ClassFlags 2") << meta2 << QByteArray("ClassFlags") << QByteArray("ClassFlag") << 'F' << true;
QTest::newRow("EnumStruct") << meta1 << QByteArray("EnumStruct") << QByteArray("EnumStruct") << 'G' << true;
QTest::newRow("TypedEnumStruct") << meta1 << QByteArray("TypedEnumStruct") << QByteArray("TypedEnumStruct") << 'H' << true;
QTest::newRow("StructFlags") << meta1 << QByteArray("StructFlags") << QByteArray("StructFlag") << 'I' << true;
QTest::newRow("EnumClass") << meta1 << QByteArray("EnumClass") << QByteArray("EnumClass") << 'A' << true << false;
QTest::newRow("EnumClass 2") << meta2 << QByteArray("EnumClass") << QByteArray("EnumClass") << 'A' << true << false;
QTest::newRow("EnumClass 3") << meta3 << QByteArray("EnumClass") << QByteArray("EnumClass") << 'A' << true << false;
QTest::newRow("TypedEnum") << meta1 << QByteArray("TypedEnum") << QByteArray("TypedEnum") << 'B' << false << true;
QTest::newRow("TypedEnum 2") << meta2 << QByteArray("TypedEnum") << QByteArray("TypedEnum") << 'B' << false << true;
QTest::newRow("TypedEnum 3") << meta3 << QByteArray("TypedEnum") << QByteArray("TypedEnum") << 'B' << false << true;
QTest::newRow("TypedEnumClass") << meta1 << QByteArray("TypedEnumClass") << QByteArray("TypedEnumClass") << 'C' << true << true;
QTest::newRow("TypedEnumClass 2") << meta2 << QByteArray("TypedEnumClass") << QByteArray("TypedEnumClass") << 'C' << true << true;
QTest::newRow("TypedEnumClass 3") << meta3 << QByteArray("TypedEnumClass") << QByteArray("TypedEnumClass") << 'C' << true << true;
QTest::newRow("NormalEnum") << meta1 << QByteArray("NormalEnum") << QByteArray("NormalEnum") << 'D' << false << false;
QTest::newRow("NormalEnum 2") << meta2 << QByteArray("NormalEnum") << QByteArray("NormalEnum") << 'D' << false << false;
QTest::newRow("NormalEnum 3") << meta3 << QByteArray("NormalEnum") << QByteArray("NormalEnum") << 'D' << false << false;
QTest::newRow("ClassFlags") << meta1 << QByteArray("ClassFlags") << QByteArray("ClassFlag") << 'F' << true << false;
QTest::newRow("ClassFlags 2") << meta2 << QByteArray("ClassFlags") << QByteArray("ClassFlag") << 'F' << true << false;
QTest::newRow("EnumStruct") << meta1 << QByteArray("EnumStruct") << QByteArray("EnumStruct") << 'G' << true << false;
QTest::newRow("TypedEnumStruct") << meta1 << QByteArray("TypedEnumStruct") << QByteArray("TypedEnumStruct") << 'H' << true << true;
QTest::newRow("StructFlags") << meta1 << QByteArray("StructFlags") << QByteArray("StructFlag") << 'I' << true << false;
}
void tst_Moc::cxx11Enums()
@ -2432,24 +2535,39 @@ void tst_Moc::cxx11Enums()
QFETCH(QByteArray, enumName);
QFETCH(char, prefix);
QFETCH(bool, isScoped);
QFETCH(bool, isTyped);
int idx = meta->indexOfEnumerator(typeName);
QVERIFY(idx != -1);
QCOMPARE(meta->indexOfEnumerator(enumName), idx);
QCOMPARE(meta->enumerator(idx).enclosingMetaObject(), meta);
QCOMPARE(meta->enumerator(idx).isValid(), true);
QCOMPARE(meta->enumerator(idx).keyCount(), 4);
QCOMPARE(meta->enumerator(idx).name(), typeName.constData());
QCOMPARE(meta->enumerator(idx).enumName(), enumName.constData());
bool isFlag = meta->enumerator(idx).isFlag();
const QMetaEnum metaEnum = meta->enumerator(idx);
QCOMPARE(metaEnum.enclosingMetaObject(), meta);
QCOMPARE(metaEnum.isValid(), true);
QCOMPARE(metaEnum.keyCount(), 4);
QCOMPARE(metaEnum.name(), typeName.constData());
QCOMPARE(metaEnum.enumName(), enumName.constData());
const QMetaType metaType = metaEnum.metaType();
const bool isUnsigned = metaType.flags() & QMetaType::IsUnsignedEnumeration;
if (isTyped) {
QCOMPARE(size_t(metaType.sizeOf()), sizeof(char));
QCOMPARE(isUnsigned, !std::is_signed_v<char>);
} else if (isScoped) {
QCOMPARE(size_t(metaType.sizeOf()), sizeof(int));
QCOMPARE(isUnsigned, !std::is_signed_v<int>);
} else {
// underlying type is implementation defined
}
bool isFlag = metaEnum.isFlag();
for (int i = 0; i < 4; i++) {
QByteArray v = prefix + QByteArray::number(i);
const int value = isFlag ? (1 << i) : i;
QCOMPARE(meta->enumerator(idx).keyToValue(v), value);
QCOMPARE(meta->enumerator(idx).valueToKey(value), v.constData());
QCOMPARE(metaEnum.keyToValue(v), value);
QCOMPARE(metaEnum.valueToKey(value), v.constData());
}
QCOMPARE(meta->enumerator(idx).isScoped(), isScoped);
QCOMPARE(metaEnum.isScoped(), isScoped);
}
void tst_Moc::cxx11TrailingReturn()
@ -3970,10 +4088,12 @@ void tst_Moc::optionsFileError()
}
static void checkEnum(const QMetaEnum &enumerator, const QByteArray &name,
const QList<QPair<QByteArray, int>> &keys)
const QList<QPair<QByteArray, int>> &keys,
const QMetaType underlyingType = QMetaType::fromType<int>())
{
QCOMPARE(name, QByteArray{enumerator.name()});
QCOMPARE(keys.size(), enumerator.keyCount());
QCOMPARE(underlyingType, enumerator.metaType().underlyingType());
for (int i = 0; i < enumerator.keyCount(); ++i) {
QCOMPARE(keys[i].first, QByteArray{enumerator.key(i)});
QCOMPARE(keys[i].second, enumerator.value(i));
@ -3988,29 +4108,57 @@ public:
FooNamespace::Enum1 prop() { return FooNamespace::Enum1::Key2; }
};
void tst_Moc::testNestedQNamespace()
{
QCOMPARE(TestSameEnumNamespace::staticMetaObject.enumeratorCount(), 1);
checkEnum(TestSameEnumNamespace::staticMetaObject.enumerator(0), "TestSameEnumNamespace",
{{"Key1", 1}, {"Key2", 2}});
QMetaEnum meta1 = QMetaEnum::fromType<TestSameEnumNamespace::TestSameEnumNamespace>();
QVERIFY(meta1.isValid());
QCOMPARE(meta1.name(), "TestSameEnumNamespace");
QCOMPARE(meta1.enclosingMetaObject(), &TestSameEnumNamespace::staticMetaObject);
QCOMPARE(meta1.keyCount(), 2);
// QTBUG-112996
QCOMPARE(TestNestedSameEnumNamespace::a::staticMetaObject.enumeratorCount(), 1);
checkEnum(TestNestedSameEnumNamespace::a::staticMetaObject.enumerator(0), "a",
{{"Key11", 11}, {"Key12", 12}});
QMetaEnum meta2 = QMetaEnum::fromType<TestNestedSameEnumNamespace::a::a>();
QVERIFY(meta2.isValid());
QCOMPARE(meta2.name(), "a");
QCOMPARE(meta2.enclosingMetaObject(), &TestNestedSameEnumNamespace::a::staticMetaObject);
QCOMPARE(meta2.keyCount(), 2);
}
void tst_Moc::testQNamespace()
{
QCOMPARE(TestQNamespace::staticMetaObject.enumeratorCount(), 4);
QCOMPARE(TestQNamespace::staticMetaObject.enumeratorCount(), 5);
checkEnum(TestQNamespace::staticMetaObject.enumerator(0), "TestEnum1",
{{"Key1", 11}, {"Key2", 12}});
checkEnum(TestQNamespace::staticMetaObject.enumerator(1), "TestEnum2",
{{"Key1", 17}, {"Key2", 18}});
checkEnum(TestQNamespace::staticMetaObject.enumerator(2), "TestFlag1",
checkEnum(TestQNamespace::staticMetaObject.enumerator(2), "TestEnum3",
{{"Key1", 23}, {"Key2", 24}}, QMetaType::fromType<qint8>());
checkEnum(TestQNamespace::staticMetaObject.enumerator(3), "TestFlag1",
{{"None", 0}, {"Flag1", 1}, {"Flag2", 2}, {"Any", 1 | 2}});
checkEnum(TestQNamespace::staticMetaObject.enumerator(3), "TestFlag2",
checkEnum(TestQNamespace::staticMetaObject.enumerator(4), "TestFlag2",
{{"None", 0}, {"Flag1", 4}, {"Flag2", 8}, {"Any", 4 | 8}});
QCOMPARE(TestQNamespace::TestGadget::staticMetaObject.enumeratorCount(), 2);
QCOMPARE(TestQNamespace::TestGadget::staticMetaObject.enumeratorCount(), 3);
checkEnum(TestQNamespace::TestGadget::staticMetaObject.enumerator(0), "TestGEnum1",
{{"Key1", 13}, {"Key2", 14}});
checkEnum(TestQNamespace::TestGadget::staticMetaObject.enumerator(1), "TestGEnum2",
{{"Key1", 23}, {"Key2", 24}});
checkEnum(TestQNamespace::TestGadget::staticMetaObject.enumerator(2), "TestGEnum3",
{{"Key1", 33}, {"Key2", 34}}, QMetaType::fromType<qint16>());
QCOMPARE(TestQNamespace::TestGadgetExport::staticMetaObject.enumeratorCount(), 2);
QCOMPARE(TestQNamespace::TestGadgetExport::staticMetaObject.enumeratorCount(), 3);
checkEnum(TestQNamespace::TestGadgetExport::staticMetaObject.enumerator(0), "TestGeEnum1",
{{"Key1", 20}, {"Key2", 21}});
checkEnum(TestQNamespace::TestGadgetExport::staticMetaObject.enumerator(1), "TestGeEnum2",
{{"Key1", 23}, {"Key2", 24}});
checkEnum(TestQNamespace::TestGadgetExport::staticMetaObject.enumerator(2), "TestGeEnum3",
{{"Key1", 26}, {"Key2", 27}}, QMetaType::fromType<quint16>());
QMetaEnum meta = QMetaEnum::fromType<TestQNamespace::TestEnum1>();
QVERIFY(meta.isValid());
@ -4454,6 +4602,42 @@ void tst_Moc::readWriteThroughBindable()
}
}
struct WithInvokableCtor
{
Q_GADGET
Q_PROPERTY(int thing MEMBER m_thing CONSTANT FINAL)
public:
WithInvokableCtor() = default;
Q_INVOKABLE WithInvokableCtor(int theThing) : m_thing(theThing) {}
int m_thing = 10;
};
void tst_Moc::invokableCtors()
{
const QMetaType metaType = QMetaType::fromType<WithInvokableCtor>();
Q_ASSERT(metaType.sizeOf() > 0);
const QMetaObject *metaObject = metaType.metaObject();
QVERIFY(metaObject);
QCOMPARE(metaObject->constructorCount(), 1);
WithInvokableCtor *result = nullptr;
const auto guard = qScopeGuard([&]() { delete result; });
int argument = 17;
void *a[] = { &result, &argument };
metaObject->static_metacall(QMetaObject::CreateInstance, 0, a);
QVERIFY(result);
QCOMPARE(result->m_thing, 17);
// Call dtor so that we're left with "uninitialized" memory.
WithInvokableCtor result2;
result2.~WithInvokableCtor();
void *b[] = { &result2, &argument };
metaObject->static_metacall(QMetaObject::ConstructInPlace, 0, b);
QCOMPARE(result2.m_thing, 17);
}
void tst_Moc::virtualInlineTaggedSlot()
{
auto mo = TagTest::staticMetaObject;