diff options
Diffstat (limited to 'tests/auto/corelib/kernel/qmetatype')
10 files changed, 619 insertions, 197 deletions
diff --git a/tests/auto/corelib/kernel/qmetatype/CMakeLists.txt b/tests/auto/corelib/kernel/qmetatype/CMakeLists.txt index a176d2b0e7..65bec3e187 100644 --- a/tests/auto/corelib/kernel/qmetatype/CMakeLists.txt +++ b/tests/auto/corelib/kernel/qmetatype/CMakeLists.txt @@ -1,12 +1,16 @@ # Copyright (C) 2022 The Qt Company Ltd. -# SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 - -# Generated from qmetatype.pro. +# SPDX-License-Identifier: BSD-3-Clause ##################################################################### ## tst_qmetatype Test: ##################################################################### +if(NOT QT_BUILD_STANDALONE_TESTS AND NOT QT_BUILDING_QT) + cmake_minimum_required(VERSION 3.16) + project(tst_qmetatype LANGUAGES CXX) + find_package(Qt6BuildInternals REQUIRED COMPONENTS STANDALONE_TEST) +endif() + # Collect test data list(APPEND test_data "./typeFlags.bin") @@ -43,12 +47,11 @@ qt_internal_add_test(tst_qmetatype SOURCES tst_qmetatype.h tst_qmetatype.cpp tst_qmetatype2.cpp tst_qmetatype3.cpp - DEFINES - QT_DISABLE_DEPRECATED_BEFORE=0 INCLUDE_DIRECTORIES ../../../other/qvariant_common LIBRARIES Qt::CorePrivate + Qt::TestPrivate Qt::Gui qmetatype_lib1 qmetatype_lib2 diff --git a/tests/auto/corelib/kernel/qmetatype/lib1.cpp b/tests/auto/corelib/kernel/qmetatype/lib1.cpp index 6a811241e9..e5478f87d9 100644 --- a/tests/auto/corelib/kernel/qmetatype/lib1.cpp +++ b/tests/auto/corelib/kernel/qmetatype/lib1.cpp @@ -1,5 +1,5 @@ // Copyright (C) 2022 Intel Corporation -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #define LIB_NAMESPACE Lib1 #include "lib_common.cpp" diff --git a/tests/auto/corelib/kernel/qmetatype/lib2.cpp b/tests/auto/corelib/kernel/qmetatype/lib2.cpp index b5a56f6c68..0a905e669a 100644 --- a/tests/auto/corelib/kernel/qmetatype/lib2.cpp +++ b/tests/auto/corelib/kernel/qmetatype/lib2.cpp @@ -1,5 +1,5 @@ // Copyright (C) 2022 Intel Corporation -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #define LIB_NAMESPACE Lib2 #include "lib_common.cpp" diff --git a/tests/auto/corelib/kernel/qmetatype/lib_common.cpp b/tests/auto/corelib/kernel/qmetatype/lib_common.cpp index f0554ec25c..179f539ccc 100644 --- a/tests/auto/corelib/kernel/qmetatype/lib_common.cpp +++ b/tests/auto/corelib/kernel/qmetatype/lib_common.cpp @@ -1,5 +1,5 @@ // Copyright (C) 2022 Intel Corporation -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include <qcollator.h> #include "tst_qmetatype_libs.h" diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp index 4565e78985..81bf5d5ea8 100644 --- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp +++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp @@ -1,5 +1,5 @@ // Copyright (C) 2021 The Qt Company Ltd. -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include "tst_qmetatype.h" @@ -13,6 +13,8 @@ #include <memory> #include <vector> +#include <QtCore/qflags.h> + Q_DECLARE_METATYPE(QMetaType::Type) Q_DECLARE_METATYPE(QPartialOrdering) @@ -121,6 +123,26 @@ static_assert(!QTypeTraits::has_operator_less_than_v<std::tuple<int, Nested2>>); static_assert(QTypeTraits::has_operator_equal_v<std::tuple<int, Nested2>>); static_assert(!QTypeTraits::has_operator_less_than_v<std::tuple<int, Nested2>>); +// optionals of nesteds +static_assert(QTypeTraits::has_operator_equal_v<std::optional<std::variant<QString>>>); +static_assert(QTypeTraits::has_operator_less_than_v<std::optional<std::variant<QString>>>); +static_assert(!QTypeTraits::has_operator_equal_v<std::optional<std::variant<NoOperators>>>); +static_assert(!QTypeTraits::has_operator_less_than_v<std::optional<std::variant<NoOperators>>>); + +static_assert(QTypeTraits::has_operator_equal_v<std::optional<Nested>>); +static_assert(!QTypeTraits::has_operator_less_than_v<std::optional<Nested>>); +static_assert(QTypeTraits::has_operator_equal_v<std::optional<std::tuple<int, Nested>>>); +static_assert(!QTypeTraits::has_operator_less_than_v<std::optional<std::tuple<int, Nested>>>); +static_assert(QTypeTraits::has_operator_equal_v<std::optional<std::tuple<int, Nested>>>); +static_assert(!QTypeTraits::has_operator_less_than_v<std::optional<std::tuple<int, Nested>>>); + +static_assert(QTypeTraits::has_operator_equal_v<std::optional<Nested2>>); +static_assert(!QTypeTraits::has_operator_less_than_v<std::optional<Nested2>>); +static_assert(QTypeTraits::has_operator_equal_v<std::optional<std::tuple<int, Nested2>>>); +static_assert(!QTypeTraits::has_operator_less_than_v<std::optional<std::tuple<int, Nested2>>>); +static_assert(QTypeTraits::has_operator_equal_v<std::optional<std::tuple<int, Nested2>>>); +static_assert(!QTypeTraits::has_operator_less_than_v<std::optional<std::tuple<int, Nested2>>>); + } struct BaseGenericType @@ -376,6 +398,7 @@ public: int Bar::failureCount = 0; +#if QT_CONFIG(thread) class MetaTypeTorturer: public QThread { Q_OBJECT @@ -411,43 +434,51 @@ protected: ++failureCount; qWarning() << name << "is not a registered metatype"; } - if (QMetaType::type(nm) != tp) { + if (QMetaType::fromName(nm).id() != tp) { ++failureCount; qWarning() << "Wrong metatype returned for" << name; } - void *buf1 = QMetaType::create(tp, 0); - void *buf2 = QMetaType::create(tp, buf1); - void *buf3 = info.create(tp, 0); - void *buf4 = info.create(tp, buf1); - QMetaType::construct(tp, space, 0); +#if QT_DEPRECATED_SINCE(6, 0) +QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED + void *buf1 = QMetaType::create(tp, nullptr); + void *buf2 = QMetaType::create(tp, buf1); + QMetaType::construct(tp, space, nullptr); QMetaType::destruct(tp, space); QMetaType::construct(tp, space, buf1); QMetaType::destruct(tp, space); - info.construct(space, 0); - info.destruct(space); - info.construct(space, buf1); - info.destruct(space); - if (!buf1) { ++failureCount; - qWarning() << "Null buffer returned by QMetaType::create(tp, 0)"; + qWarning() << "Null buffer returned by QMetaType::create(tp, nullptr)"; } if (!buf2) { ++failureCount; qWarning() << "Null buffer returned by QMetaType::create(tp, buf)"; } + + QMetaType::destroy(tp, buf1); + QMetaType::destroy(tp, buf2); +QT_WARNING_POP +#endif + + void *buf3 = info.create(nullptr); + void *buf4 = info.create(buf3); + + info.construct(space, nullptr); + info.destruct(space); + info.construct(space, buf3); + info.destruct(space); + if (!buf3) { ++failureCount; - qWarning() << "Null buffer returned by info.create(tp, 0)"; + qWarning() << "Null buffer returned by info.create(nullptr)"; } if (!buf4) { ++failureCount; - qWarning() << "Null buffer returned by infocreate(tp, buf)"; + qWarning() << "Null buffer returned by info.create(buf)"; } - QMetaType::destroy(tp, buf1); - QMetaType::destroy(tp, buf2); + info.destroy(buf3); info.destroy(buf4); } @@ -477,6 +508,7 @@ void tst_QMetaType::threadSafety() QCOMPARE(t3.failureCount, 0); QCOMPARE(Bar::failureCount, 0); } +#endif namespace TestSpace { @@ -495,7 +527,7 @@ void tst_QMetaType::namespaces() QCOMPARE(qvariant_cast<TestSpace::Foo>(v).d, 11.12); int qungTfuId = qRegisterMetaType<ADD_TESTSPACE(QungTfu)>(); - QCOMPARE(QMetaType::typeName(qungTfuId), "TestSpace::QungTfu"); + QCOMPARE(QMetaType(qungTfuId).name(), "TestSpace::QungTfu"); } void tst_QMetaType::id() @@ -509,13 +541,13 @@ void tst_QMetaType::qMetaTypeId() { QCOMPARE(::qMetaTypeId<QString>(), int(QMetaType::QString)); QCOMPARE(::qMetaTypeId<int>(), int(QMetaType::Int)); - QCOMPARE(::qMetaTypeId<TestSpace::Foo>(), QMetaType::type("TestSpace::Foo")); + QCOMPARE(::qMetaTypeId<TestSpace::Foo>(), QMetaType::fromType<TestSpace::Foo>().id()); - QCOMPARE(::qMetaTypeId<char>(), QMetaType::type("char")); - QCOMPARE(::qMetaTypeId<uchar>(), QMetaType::type("unsigned char")); - QCOMPARE(::qMetaTypeId<signed char>(), QMetaType::type("signed char")); + QCOMPARE(::qMetaTypeId<char>(), QMetaType::fromType<char>().id()); + QCOMPARE(::qMetaTypeId<uchar>(), QMetaType::fromType<unsigned char>().id()); + QCOMPARE(::qMetaTypeId<signed char>(), QMetaType::fromType<signed char>().id()); QVERIFY(::qMetaTypeId<signed char>() != ::qMetaTypeId<char>()); - QCOMPARE(::qMetaTypeId<qint8>(), QMetaType::type("qint8")); + QCOMPARE(::qMetaTypeId<qint8>(), QMetaType::fromType<qint8>().id()); } void tst_QMetaType::properties() @@ -527,14 +559,14 @@ void tst_QMetaType::properties() QCOMPARE(v.typeName(), "QVariantList"); QList<QVariant> values = v.toList(); - QCOMPARE(values.count(), 2); + QCOMPARE(values.size(), 2); QCOMPARE(values.at(0).toInt(), 42); values << 43 << "world"; QVERIFY(setProperty("prop", values)); v = property("prop"); - QCOMPARE(v.toList().count(), 4); + QCOMPARE(v.toList().size(), 4); } void tst_QMetaType::normalizedTypes() @@ -542,13 +574,13 @@ void tst_QMetaType::normalizedTypes() int WhityIntId = ::qMetaTypeId<Whity<int> >(); int WhityDoubleId = ::qMetaTypeId<Whity<double> >(); - QCOMPARE(QMetaType::type("Whity<int>"), WhityIntId); - QCOMPARE(QMetaType::type(" Whity < int > "), WhityIntId); - QCOMPARE(QMetaType::type("Whity<int >"), WhityIntId); + QCOMPARE(QMetaType::fromName("Whity<int>").id(), WhityIntId); + QCOMPARE(QMetaType::fromName(" Whity < int > ").id(), WhityIntId); + QCOMPARE(QMetaType::fromName("Whity<int >").id(), WhityIntId); - QCOMPARE(QMetaType::type("Whity<double>"), WhityDoubleId); - QCOMPARE(QMetaType::type(" Whity< double > "), WhityDoubleId); - QCOMPARE(QMetaType::type("Whity<double >"), WhityDoubleId); + QCOMPARE(QMetaType::fromName("Whity<double>").id(), WhityDoubleId); + QCOMPARE(QMetaType::fromName(" Whity< double > ").id(), WhityDoubleId); + QCOMPARE(QMetaType::fromName("Whity<double >").id(), WhityDoubleId); QCOMPARE(qRegisterMetaType<Whity<int> >(" Whity < int > "), WhityIntId); QCOMPARE(qRegisterMetaType<Whity<int> >("Whity<int>"), WhityIntId); @@ -626,7 +658,7 @@ void tst_QMetaType::typeName() QSKIP("The test doesn't link against QtWidgets."); ignoreInvalidMetaTypeWarning(aType); - const char *rawname = QMetaType::typeName(aType); + const char *rawname = QMetaType(aType).name(); QString name = QString::fromLatin1(rawname); QCOMPARE(name, aTypeName); @@ -667,10 +699,8 @@ void tst_QMetaType::type() if (aType >= QMetaType::FirstWidgetsType) QSKIP("The test doesn't link against QtWidgets."); - // QMetaType::type(QByteArray) - QCOMPARE(QMetaType::type(aTypeName), aType); - // QMetaType::type(const char *) - QCOMPARE(QMetaType::type(aTypeName.constData()), aType); + QCOMPARE(QMetaType::fromName(aTypeName).id(), aType); + QCOMPARE(QMetaType::fromName(aTypeName.constData()).id(), aType); } void tst_QMetaType::type_fromSubString_data() @@ -695,7 +725,7 @@ void tst_QMetaType::type_fromSubString() QFETCH(int, size); QFETCH(int, expectedType); QByteArray ba = QByteArray::fromRawData(types + offset, size); - QCOMPARE(QMetaType::type(ba), expectedType); + QCOMPARE(QMetaType::fromName(ba).id(), expectedType); } namespace { @@ -722,7 +752,7 @@ void tst_QMetaType::create_data() QTest::addColumn<int>("type"); QTest::newRow("unknown-type") << int(QMetaType::UnknownType); #define ADD_METATYPE_TEST_ROW(MetaTypeName, MetaTypeId, RealType) \ - QTest::newRow(QMetaType::typeName(QMetaType::MetaTypeName)) << int(QMetaType::MetaTypeName); + QTest::newRow(QMetaType(QMetaType::MetaTypeName).name()) << int(QMetaType::MetaTypeName); FOR_EACH_CORE_METATYPE(ADD_METATYPE_TEST_ROW) #undef ADD_METATYPE_TEST_ROW } @@ -731,23 +761,36 @@ template<int ID> static void testCreateHelper() { typedef typename MetaEnumToType<ID>::Type Type; - QMetaType info(ID); + auto expected = std::unique_ptr<Type>(DefaultValueFactory<ID>::create()); +#if QT_DEPRECATED_SINCE(6, 0) +QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED void *actual1 = QMetaType::create(ID); - void *actual2 = info.create(); - Type *expected = DefaultValueFactory<ID>::create(); + auto cleanup1 = qScopeGuard([actual1]() { + QMetaType::destroy(ID, actual1); + }); QCOMPARE(*static_cast<Type *>(actual1), *expected); +QT_WARNING_POP +#endif // QT_DEPRECATED_SINCE(6, 0) + QMetaType info(ID); + void *actual2 = info.create(); + auto cleanup2 = qScopeGuard([&info, actual2]() { + info.destroy(actual2); + }); QCOMPARE(*static_cast<Type *>(actual2), *expected); - delete expected; - - QMetaType::destroy(ID, actual1); - info.destroy(actual2); } template<> void testCreateHelper<QMetaType::Void>() { - void *actual = QMetaType::create(QMetaType::Void); - QMetaType::destroy(QMetaType::Void, actual); +#if QT_DEPRECATED_SINCE(6, 0) +QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED + void *actual1 = QMetaType::create(QMetaType::Void); + QMetaType::destroy(QMetaType::Void, actual1); +QT_WARNING_POP +#endif // QT_DEPRECATED_SINCE(6, 0) + QMetaType info(QMetaType::Void); + void *actual2 = info.create(); + info.destroy(actual2); } @@ -782,15 +825,22 @@ template<int ID> static void testCreateCopyHelper() { typedef typename MetaEnumToType<ID>::Type Type; - Type *expected = TestValueFactory<ID>::create(); - QMetaType info(ID); - void *actual1 = QMetaType::create(ID, expected); - void *actual2 = info.create(expected); + auto expected = std::unique_ptr<Type>(TestValueFactory<ID>::create()); +#if QT_DEPRECATED_SINCE(6, 0) +QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED + void *actual1 = QMetaType::create(ID, expected.get()); + auto cleanup1 = qScopeGuard([actual1]() { + QMetaType::destroy(ID, actual1); + }); QCOMPARE(*static_cast<Type *>(actual1), *expected); +QT_WARNING_POP +#endif // QT_DEPRECATED_SINCE(6, 0) + QMetaType info(ID); + void *actual2 = info.create(expected.get()); + auto cleanup2 = qScopeGuard([&info, actual2]() { + info.destroy(actual2); + }); QCOMPARE(*static_cast<Type *>(actual2), *expected); - QMetaType::destroy(ID, actual1); - info.destroy(actual2); - delete expected; } template<> @@ -798,9 +848,22 @@ void testCreateCopyHelper<QMetaType::Void>() { typedef MetaEnumToType<QMetaType::Void>::Type Type; Type *expected = TestValueFactory<QMetaType::Void>::create(); - void *actual = QMetaType::create(QMetaType::Void, expected); - QCOMPARE(static_cast<Type *>(actual), expected); - QMetaType::destroy(QMetaType::Void, actual); + QCOMPARE(expected, nullptr); // we do not need to delete it +#if QT_DEPRECATED_SINCE(6, 0) +QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED + void *actual1 = QMetaType::create(QMetaType::Void, expected); + auto cleanup1 = qScopeGuard([actual1]() { + QMetaType::destroy(QMetaType::Void, actual1); + }); + QCOMPARE(static_cast<Type *>(actual1), expected); +QT_WARNING_POP +#endif // QT_DEPRECATED_SINCE(6, 0) + QMetaType info(QMetaType::Void); + void *actual2 = info.create(expected); + auto cleanup2 = qScopeGuard([&info, actual2]() { + info.destroy(actual2); + }); + QCOMPARE(static_cast<Type *>(actual2), expected); } void tst_QMetaType::createCopy_data() @@ -864,7 +927,8 @@ void tst_QMetaType::sizeOf() QFETCH(int, type); QFETCH(size_t, size); ignoreInvalidMetaTypeWarning(type); - QCOMPARE(size_t(QMetaType::sizeOf(type)), size); + QMetaType metaType(type); + QCOMPARE(size_t(metaType.sizeOf()), size); } void tst_QMetaType::sizeOfStaticLess_data() @@ -983,7 +1047,7 @@ template <typename T> void addFlagsRow(const char *name, int id = qMetaTypeId<T> QTest::newRow(name) << id << bool(QTypeInfo<T>::isRelocatable) - << bool(!std::is_trivially_default_constructible_v<T>) + << bool(!std::is_default_constructible_v<T> || !QTypeInfo<T>::isValueInitializationBitwiseZero) << bool(!std::is_trivially_copy_constructible_v<T>) << bool(!std::is_trivially_destructible_v<T>) << bool(QtPrivate::IsPointerToTypeDerivedFromQObject<T>::Value) @@ -1156,7 +1220,7 @@ void tst_QMetaType::flagsBinaryCompatibility6_0_data() QTest::addColumn<quint32>("flags"); QFile file(QFINDTESTDATA("typeFlags.bin")); - file.open(QIODevice::ReadOnly); + QVERIFY(file.open(QIODevice::ReadOnly)); QList<quint32> buffer; QDataStream ds(&file); ds >> buffer; @@ -1167,7 +1231,7 @@ void tst_QMetaType::flagsBinaryCompatibility6_0_data() if (id > QMetaType::LastCoreType) continue; // We do not link against QtGui, so we do longer consider such type as registered QVERIFY2(QMetaType::isRegistered(id), "A type could not be removed in BC way"); - QTest::newRow(QMetaType::typeName(id)) << id << flags; + QTest::newRow(QMetaType(id).name()) << id << flags; } } @@ -1176,7 +1240,7 @@ void tst_QMetaType::flagsBinaryCompatibility6_0() QFETCH(quint32, id); QFETCH(quint32, flags); - const auto currentFlags = QMetaType::typeFlags(id); + const auto currentFlags = QMetaType(id).flags(); auto expectedFlags = QMetaType::TypeFlags(flags); // Only compare the values that were already defined in 5.0. @@ -1197,42 +1261,61 @@ template<int ID> static void testConstructHelper() { typedef typename MetaEnumToType<ID>::Type Type; + auto expected = std::unique_ptr<Type>(DefaultValueFactory<ID>::create()); QMetaType info(ID); int size = info.sizeOf(); +#if QT_DEPRECATED_SINCE(6, 0) +QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED void *storage1 = qMallocAligned(size, alignof(Type)); - void *actual1 = QMetaType::construct(ID, storage1, /*copy=*/0); - void *storage2 = qMallocAligned(size, alignof(Type)); - void *actual2 = info.construct(storage2, /*copy=*/0); + void *actual1 = QMetaType::construct(ID, storage1, /*copy=*/nullptr); + auto cleanup1 = qScopeGuard([storage1, actual1]() { + QMetaType::destruct(ID, actual1); + qFreeAligned(storage1); + }); QCOMPARE(actual1, storage1); - QCOMPARE(actual2, storage2); - Type *expected = DefaultValueFactory<ID>::create(); QCOMPARE(*static_cast<Type *>(actual1), *expected); + QCOMPARE(QMetaType::construct(ID, nullptr, /*copy=*/nullptr), nullptr); + QMetaType::destruct(ID, nullptr); +QT_WARNING_POP +#endif // QT_DEPRECATED_SINCE(6, 0) + void *storage2 = qMallocAligned(size, alignof(Type)); + void *actual2 = info.construct(storage2, /*copy=*/nullptr); + auto cleanup2 = qScopeGuard([&info, storage2, actual2]() { + info.destruct(actual2); + qFreeAligned(storage2); + }); + QCOMPARE(actual2, storage2); QCOMPARE(*static_cast<Type *>(actual2), *expected); - delete expected; - QMetaType::destruct(ID, actual1); - qFreeAligned(storage1); - info.destruct(actual2); - qFreeAligned(storage2); - - QVERIFY(QMetaType::construct(ID, 0, /*copy=*/0) == 0); - QMetaType::destruct(ID, 0); - - QVERIFY(info.construct(0, /*copy=*/0) == 0); - info.destruct(0); + QCOMPARE(info.construct(nullptr, /*copy=*/nullptr), nullptr); + info.destruct(nullptr); } template<> void testConstructHelper<QMetaType::Void>() { - /*int size = */ QMetaType::sizeOf(QMetaType::Void); - void *storage = 0; - void *actual = QMetaType::construct(QMetaType::Void, storage, /*copy=*/0); - QCOMPARE(actual, storage); - QMetaType::destruct(QMetaType::Void, actual); - qFreeAligned(storage); - - QVERIFY(QMetaType::construct(QMetaType::Void, 0, /*copy=*/0) == 0); - QMetaType::destruct(QMetaType::Void, 0); +#if QT_DEPRECATED_SINCE(6, 0) +QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED + void *storage1 = nullptr; + void *actual1 = QMetaType::construct(QMetaType::Void, storage1, /*copy=*/nullptr); + auto cleanup1 = qScopeGuard([storage1, actual1]() { + QMetaType::destruct(QMetaType::Void, actual1); + qFreeAligned(storage1); + }); + QCOMPARE(actual1, storage1); + QCOMPARE(QMetaType::construct(QMetaType::Void, nullptr, /*copy=*/nullptr), nullptr); + QMetaType::destruct(QMetaType::Void, nullptr); +QT_WARNING_POP +#endif // QT_DEPRECATED_SINCE(6, 0) + QMetaType info(QMetaType::Void); + void *storage2 = nullptr; + void *actual2 = info.construct(storage2, /*copy=*/nullptr); + auto cleanup2 = qScopeGuard([&info, storage2, actual2]() { + info.destruct(actual2); + qFreeAligned(storage2); + }); + QCOMPARE(actual2, storage2); + QVERIFY(info.construct(nullptr, /*copy=*/nullptr) == nullptr); + info.destruct(nullptr); } void tst_QMetaType::construct() @@ -1261,11 +1344,137 @@ FOR_EACH_CORE_METATYPE(RETURN_CONSTRUCT_FUNCTION) TypeTestFunctionGetter::get(type)(); } + +namespace TriviallyConstructibleTests { + +enum Enum0 {}; +enum class Enum1 {}; + +static_assert(QTypeInfo<int>::isValueInitializationBitwiseZero); +static_assert(QTypeInfo<double>::isValueInitializationBitwiseZero); +static_assert(QTypeInfo<Enum0>::isValueInitializationBitwiseZero); +static_assert(QTypeInfo<Enum1>::isValueInitializationBitwiseZero); +static_assert(QTypeInfo<int *>::isValueInitializationBitwiseZero); +static_assert(QTypeInfo<void *>::isValueInitializationBitwiseZero); +static_assert(QTypeInfo<std::nullptr_t>::isValueInitializationBitwiseZero); + +struct A {}; +struct B { B() {} }; +struct C { ~C() {} }; +struct D { D(int) {} }; +struct E { E() {} ~E() {} }; +struct F { int i; }; +struct G { G() : i(0) {} int i; }; +struct H { constexpr H() : i(0) {} int i; }; +struct I { I() : i(42) {} int i; }; +struct J { constexpr J() : i(42) {} int i; }; +struct K { K() : i(0) {} ~K() {} int i; }; + +static_assert(!QTypeInfo<A>::isValueInitializationBitwiseZero); +static_assert(!QTypeInfo<B>::isValueInitializationBitwiseZero); +static_assert(!QTypeInfo<C>::isValueInitializationBitwiseZero); +static_assert(!QTypeInfo<D>::isValueInitializationBitwiseZero); +static_assert(!QTypeInfo<E>::isValueInitializationBitwiseZero); +static_assert(!QTypeInfo<F>::isValueInitializationBitwiseZero); +static_assert(!QTypeInfo<G>::isValueInitializationBitwiseZero); +static_assert(!QTypeInfo<H>::isValueInitializationBitwiseZero); +static_assert(!QTypeInfo<I>::isValueInitializationBitwiseZero); +static_assert(!QTypeInfo<J>::isValueInitializationBitwiseZero); +static_assert(!QTypeInfo<K>::isValueInitializationBitwiseZero); + +} // namespace TriviallyConstructibleTests + +// Value-initializing these trivially constructible types cannot be achieved by +// memset(0) into their storage. For instance, on Itanium, a pointer to a data +// member needs to be value-initialized by setting it to -1. + +// Fits into QVariant +struct TrivialTypeNotZeroInitableSmall { + int TrivialTypeNotZeroInitableSmall::*pdm; +}; + +static_assert(std::is_trivially_default_constructible_v<TrivialTypeNotZeroInitableSmall>); +static_assert(!QTypeInfo<TrivialTypeNotZeroInitableSmall>::isValueInitializationBitwiseZero); +static_assert(sizeof(TrivialTypeNotZeroInitableSmall) < sizeof(QVariant)); // also checked more thoroughly below + +// Does not fit into QVariant internal storage +struct TrivialTypeNotZeroInitableBig { + int a; + double b; + char c; + int array[42]; + void (TrivialTypeNotZeroInitableBig::*pmf)(); + int TrivialTypeNotZeroInitableBig::*pdm; +}; + +static_assert(std::is_trivially_default_constructible_v<TrivialTypeNotZeroInitableBig>); +static_assert(!QTypeInfo<TrivialTypeNotZeroInitableSmall>::isValueInitializationBitwiseZero); +static_assert(sizeof(TrivialTypeNotZeroInitableBig) > sizeof(QVariant)); // also checked more thoroughly below + +void tst_QMetaType::defaultConstructTrivial_QTBUG_109594() +{ + // MSVC miscompiles value-initialization of pointers to data members, + // https://developercommunity.visualstudio.com/t/Pointer-to-data-member-is-not-initialize/10238905 + { + QMetaType mt = QMetaType::fromType<TrivialTypeNotZeroInitableSmall>(); + QVERIFY(mt.isDefaultConstructible()); + auto ptr = static_cast<TrivialTypeNotZeroInitableSmall *>(mt.create()); + const auto cleanup = qScopeGuard([=] { + mt.destroy(ptr); + }); +#ifdef Q_CC_MSVC_ONLY + QEXPECT_FAIL("", "MSVC compiler bug", Continue); +#endif + QCOMPARE(ptr->pdm, nullptr); + + QVariant v(mt); + QVERIFY(QVariant::Private::canUseInternalSpace(mt.iface())); + auto obj = v.value<TrivialTypeNotZeroInitableSmall>(); +#ifdef Q_CC_MSVC_ONLY + QEXPECT_FAIL("", "MSVC compiler bug", Continue); +#endif + QCOMPARE(obj.pdm, nullptr); + } + + { + QMetaType mt = QMetaType::fromType<TrivialTypeNotZeroInitableBig>(); + QVERIFY(mt.isDefaultConstructible()); + auto ptr = static_cast<TrivialTypeNotZeroInitableBig *>(mt.create()); + const auto cleanup = qScopeGuard([=] { + mt.destroy(ptr); + }); + QCOMPARE(ptr->a, 0); + QCOMPARE(ptr->b, 0.0); + QCOMPARE(ptr->c, '\0'); + QCOMPARE(ptr->pmf, nullptr); + for (int i : ptr->array) + QCOMPARE(i, 0); +#ifdef Q_CC_MSVC_ONLY + QEXPECT_FAIL("", "MSVC compiler bug", Continue); +#endif + QCOMPARE(ptr->pdm, nullptr); + + QVariant v(mt); + QVERIFY(!QVariant::Private::canUseInternalSpace(mt.iface())); + auto obj = v.value<TrivialTypeNotZeroInitableBig>(); + QCOMPARE(obj.a, 0); + QCOMPARE(obj.b, 0.0); + QCOMPARE(obj.c, '\0'); + QCOMPARE(obj.pmf, nullptr); + for (int i : obj.array) + QCOMPARE(i, 0); +#ifdef Q_CC_MSVC_ONLY + QEXPECT_FAIL("", "MSVC compiler bug", Continue); +#endif + QCOMPARE(obj.pdm, nullptr); + } +} + void tst_QMetaType::typedConstruct() { auto testMetaObjectWriteOnGadget = [](QVariant &gadget, const QList<GadgetPropertyType> &properties) { - auto metaObject = QMetaType::metaObjectForType(gadget.userType()); + auto metaObject = QMetaType(gadget.userType()).metaObject(); QVERIFY(metaObject != nullptr); QCOMPARE(metaObject->methodCount(), 0); QCOMPARE(metaObject->propertyCount(), properties.size()); @@ -1279,7 +1488,7 @@ void tst_QMetaType::typedConstruct() auto testMetaObjectReadOnGadget = [](QVariant gadget, const QList<GadgetPropertyType> &properties) { - auto metaObject = QMetaType::metaObjectForType(gadget.userType()); + auto metaObject = QMetaType(gadget.userType()).metaObject(); QVERIFY(metaObject != nullptr); QCOMPARE(metaObject->methodCount(), 0); QCOMPARE(metaObject->propertyCount(), properties.size()); @@ -1287,7 +1496,7 @@ void tst_QMetaType::typedConstruct() auto prop = metaObject->property(i); QCOMPARE(properties[i].name, prop.name()); QCOMPARE(properties[i].type, prop.typeName()); - if (!QMetaType::typeFlags(prop.userType()).testFlag(QMetaType::IsGadget)) + if (!QMetaType(prop.userType()).flags().testFlag(QMetaType::IsGadget)) QCOMPARE(properties[i].testData, prop.readOnGadget(gadget.constData())); } }; @@ -1299,7 +1508,7 @@ void tst_QMetaType::typedConstruct() }; registerGadget("DynamicGadget1", dynamicGadget1); - QVariant testGadget1(QMetaType(QMetaType::type("DynamicGadget1"))); + QVariant testGadget1(QMetaType::fromName("DynamicGadget1")); testMetaObjectWriteOnGadget(testGadget1, dynamicGadget1); testMetaObjectReadOnGadget(testGadget1, dynamicGadget1); @@ -1311,10 +1520,10 @@ void tst_QMetaType::typedConstruct() {"DynamicGadget1", "dynamicGadget1_prop", testGadget1} }; registerGadget("DynamicGadget2", dynamicGadget2); - QVariant testGadget2(QMetaType(QMetaType::type("DynamicGadget2"))); + QVariant testGadget2(QMetaType::fromName("DynamicGadget2")); testMetaObjectWriteOnGadget(testGadget2, dynamicGadget2); testMetaObjectReadOnGadget(testGadget2, dynamicGadget2); - auto g2mo = QMetaType::metaObjectForType(testGadget2.userType()); + auto g2mo = QMetaType(testGadget2.userType()).metaObject(); auto dynamicGadget1_prop = g2mo->property(g2mo->indexOfProperty("dynamicGadget1_prop")); testMetaObjectReadOnGadget(dynamicGadget1_prop.readOnGadget(testGadget2.constData()), dynamicGadget1); @@ -1346,7 +1555,7 @@ void tst_QMetaType::typedConstruct() s_managedTypes[podTypeId] = qMakePair(dynamicGadgetProperties, std::shared_ptr<QMetaObject>{}); // Test POD - QCOMPARE(podTypeId, QMetaType::type(podTypeName)); + QCOMPARE(podTypeId, QMetaType::fromName(podTypeName).id()); QVariant podVariant{QMetaType(podTypeId)}; QCOMPARE(myPodTesData, static_cast<const GenericPODType *>(reinterpret_cast<const BaseGenericType *>(podVariant.constData()))->podData); @@ -1360,27 +1569,32 @@ template<int ID> static void testConstructCopyHelper() { typedef typename MetaEnumToType<ID>::Type Type; - Type *expected = TestValueFactory<ID>::create(); + auto expected = std::unique_ptr<Type>(TestValueFactory<ID>::create()); QMetaType info(ID); - int size = QMetaType::sizeOf(ID); +#if QT_DEPRECATED_SINCE(6, 0) +QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED + const int size = QMetaType::sizeOf(ID); QCOMPARE(info.sizeOf(), size); void *storage1 = qMallocAligned(size, alignof(Type)); - void *actual1 = QMetaType::construct(ID, storage1, expected); - void *storage2 = qMallocAligned(size, alignof(Type)); - void *actual2 = info.construct(storage2, expected); + void *actual1 = QMetaType::construct(ID, storage1, expected.get()); + auto cleanup1 = qScopeGuard([storage1, actual1]() { + QMetaType::destruct(ID, actual1); + qFreeAligned(storage1); + }); QCOMPARE(actual1, storage1); - QCOMPARE(actual2, storage2); QCOMPARE(*static_cast<Type *>(actual1), *expected); + QCOMPARE(QMetaType::construct(ID, nullptr, nullptr), nullptr); +QT_WARNING_POP +#endif // QT_DEPRECATED_SINCE(6, 0) + void *storage2 = qMallocAligned(info.sizeOf(), alignof(Type)); + void *actual2 = info.construct(storage2, expected.get()); + auto cleanup2 = qScopeGuard([&info, storage2, actual2]() { + info.destruct(actual2); + qFreeAligned(storage2); + }); + QCOMPARE(actual2, storage2); QCOMPARE(*static_cast<Type *>(actual2), *expected); - QMetaType::destruct(ID, actual1); - qFreeAligned(storage1); - info.destruct(actual2); - qFreeAligned(storage2); - - QVERIFY(QMetaType::construct(ID, 0, expected) == 0); - QVERIFY(info.construct(0, expected) == 0); - - delete expected; + QCOMPARE(info.construct(nullptr, expected.get()), nullptr); } template<> @@ -1388,14 +1602,28 @@ void testConstructCopyHelper<QMetaType::Void>() { typedef MetaEnumToType<QMetaType::Void>::Type Type; Type *expected = TestValueFactory<QMetaType::Void>::create(); - /* int size = */QMetaType::sizeOf(QMetaType::Void); - void *storage = 0; - void *actual = QMetaType::construct(QMetaType::Void, storage, expected); - QCOMPARE(actual, storage); - QMetaType::destruct(QMetaType::Void, actual); - qFreeAligned(storage); - - QVERIFY(QMetaType::construct(QMetaType::Void, 0, expected) == 0); + QCOMPARE(expected, nullptr); // we do not need to delete it +#if QT_DEPRECATED_SINCE(6, 0) +QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED + void *storage1 = nullptr; + void *actual1 = QMetaType::construct(QMetaType::Void, storage1, expected); + auto cleanup1 = qScopeGuard([storage1, actual1]() { + QMetaType::destruct(QMetaType::Void, actual1); + qFreeAligned(storage1); + }); + QCOMPARE(actual1, storage1); + QCOMPARE(QMetaType::construct(QMetaType::Void, nullptr, nullptr), nullptr); +QT_WARNING_POP +#endif // QT_DEPRECATED_SINCE(6, 0) + QMetaType info(QMetaType::Void); + void *storage2 = nullptr; + void *actual2 = info.construct(storage2, expected); + auto cleanup2 = qScopeGuard([&info, storage2, actual2]() { + info.destruct(actual2); + qFreeAligned(storage2); + }); + QCOMPARE(actual2, storage2); + QCOMPARE(info.construct(nullptr, expected), nullptr); } void tst_QMetaType::constructCopy_data() @@ -1444,7 +1672,7 @@ void tst_QMetaType::selfCompare_data() QTest::newRow("unknown-type") << int(QMetaType::UnknownType) << orderingFor(QMetaType::UnknownType); #define ADD_METATYPE_TEST_ROW(MetaTypeName, MetaTypeId, RealType) \ - QTest::newRow(QMetaType::typeName(QMetaType::MetaTypeName)) << int(QMetaType::MetaTypeName) << orderingFor(QMetaType::MetaTypeName); + QTest::newRow(QMetaType(QMetaType::MetaTypeName).name()) << int(QMetaType::MetaTypeName) << orderingFor(QMetaType::MetaTypeName); FOR_EACH_CORE_METATYPE(ADD_METATYPE_TEST_ROW) #undef ADD_METATYPE_TEST_ROW } @@ -1486,26 +1714,26 @@ Q_DECLARE_METATYPE(CustomString) //this line is useless void tst_QMetaType::typedefs() { - QCOMPARE(QMetaType::type("long long"), int(QMetaType::LongLong)); - QCOMPARE(QMetaType::type("unsigned long long"), int(QMetaType::ULongLong)); - QCOMPARE(QMetaType::type("qint8"), int(QMetaType::SChar)); - QCOMPARE(QMetaType::type("quint8"), int(QMetaType::UChar)); - QCOMPARE(QMetaType::type("qint16"), int(QMetaType::Short)); - QCOMPARE(QMetaType::type("quint16"), int(QMetaType::UShort)); - QCOMPARE(QMetaType::type("qint32"), int(QMetaType::Int)); - QCOMPARE(QMetaType::type("quint32"), int(QMetaType::UInt)); - QCOMPARE(QMetaType::type("qint64"), int(QMetaType::LongLong)); - QCOMPARE(QMetaType::type("quint64"), int(QMetaType::ULongLong)); + QCOMPARE(QMetaType::fromName("long long").id(), int(QMetaType::LongLong)); + QCOMPARE(QMetaType::fromName("unsigned long long").id(), int(QMetaType::ULongLong)); + QCOMPARE(QMetaType::fromName("qint8").id(), int(QMetaType::SChar)); + QCOMPARE(QMetaType::fromName("quint8").id(), int(QMetaType::UChar)); + QCOMPARE(QMetaType::fromName("qint16").id(), int(QMetaType::Short)); + QCOMPARE(QMetaType::fromName("quint16").id(), int(QMetaType::UShort)); + QCOMPARE(QMetaType::fromName("qint32").id(), int(QMetaType::Int)); + QCOMPARE(QMetaType::fromName("quint32").id(), int(QMetaType::UInt)); + QCOMPARE(QMetaType::fromName("qint64").id(), int(QMetaType::LongLong)); + QCOMPARE(QMetaType::fromName("quint64").id(), int(QMetaType::ULongLong)); // make sure the qreal typeId is the type id of the type it's defined to - QCOMPARE(QMetaType::type("qreal"), ::qMetaTypeId<qreal>()); + QCOMPARE(QMetaType::fromName("qreal").id(), ::qMetaTypeId<qreal>()); qRegisterMetaType<CustomString>("CustomString"); - QCOMPARE(QMetaType::type("CustomString"), ::qMetaTypeId<CustomString>()); + QCOMPARE(QMetaType::fromName("CustomString").id(), ::qMetaTypeId<CustomString>()); typedef Whity<double> WhityDouble; qRegisterMetaType<WhityDouble>("WhityDouble"); - QCOMPARE(QMetaType::type("WhityDouble"), ::qMetaTypeId<WhityDouble>()); + QCOMPARE(QMetaType::fromName("WhityDouble").id(), ::qMetaTypeId<WhityDouble>()); } struct RegisterTypeType {}; @@ -1536,7 +1764,7 @@ void tst_QMetaType::registerType() QCOMPARE(qRegisterMetaType<MyString>("MyString"), int(QMetaType::QString)); QCOMPARE(qRegisterMetaType<MyString>("MyString"), int(QMetaType::QString)); - QCOMPARE(QMetaType::type("MyString"), int(QMetaType::QString)); + QCOMPARE(QMetaType::fromType<MyString>().id(), int(QMetaType::QString)); // Alias to custom type typedef CustomMovable MyMovable; @@ -1545,12 +1773,12 @@ void tst_QMetaType::registerType() QCOMPARE(qRegisterMetaType<MyMovable>("MyMovable"), movableId); QCOMPARE(qRegisterMetaType<MyMovable>("MyMovable"), movableId); - QCOMPARE(QMetaType::type("MyMovable"), movableId); + QCOMPARE(QMetaType::fromType<MyMovable>().id(), movableId); QCOMPARE(qRegisterMetaType<MyFoo>("MyFoo"), fooId); QCOMPARE(qRegisterMetaType<MyFoo>("MyFoo"), fooId); - QCOMPARE(QMetaType::type("MyFoo"), fooId); + QCOMPARE(QMetaType::fromType<MyFoo>().id(), fooId); // this portion of the test can only be run once static bool typeWasRegistered = false; @@ -1611,25 +1839,77 @@ Q_DECLARE_METATYPE(isEnumTest_Enum1) void tst_QMetaType::isEnum() { int type0 = qRegisterMetaType<int>("int"); - QVERIFY((QMetaType::typeFlags(type0) & QMetaType::IsEnumeration) == 0); + QVERIFY((QMetaType(type0).flags() & QMetaType::IsEnumeration) == 0); int type1 = qRegisterMetaType<isEnumTest_Enum0>("isEnumTest_Enum0"); - QVERIFY((QMetaType::typeFlags(type1) & QMetaType::IsEnumeration) == QMetaType::IsEnumeration); + QVERIFY((QMetaType(type1).flags() & QMetaType::IsEnumeration) == QMetaType::IsEnumeration); int type2 = qRegisterMetaType<isEnumTest_Struct0>("isEnumTest_Struct0"); - QVERIFY((QMetaType::typeFlags(type2) & QMetaType::IsEnumeration) == 0); + QVERIFY((QMetaType(type2).flags() & QMetaType::IsEnumeration) == 0); int type3 = qRegisterMetaType<isEnumTest_Enum0 *>("isEnumTest_Enum0 *"); - QVERIFY((QMetaType::typeFlags(type3) & QMetaType::IsEnumeration) == 0); + QVERIFY((QMetaType(type3).flags() & QMetaType::IsEnumeration) == 0); int type4 = qRegisterMetaType<isEnumTest_Struct0::A>("isEnumTest_Struct0::A"); - QVERIFY((QMetaType::typeFlags(type4) & QMetaType::IsEnumeration) == QMetaType::IsEnumeration); + QVERIFY((QMetaType(type4).flags() & QMetaType::IsEnumeration) == QMetaType::IsEnumeration); int type5 = ::qMetaTypeId<isEnumTest_Struct1>(); - QVERIFY((QMetaType::typeFlags(type5) & QMetaType::IsEnumeration) == 0); + QVERIFY((QMetaType(type5).flags() & QMetaType::IsEnumeration) == 0); int type6 = ::qMetaTypeId<isEnumTest_Enum1>(); - QVERIFY((QMetaType::typeFlags(type6) & QMetaType::IsEnumeration) == QMetaType::IsEnumeration); + QVERIFY((QMetaType(type6).flags() & QMetaType::IsEnumeration) == QMetaType::IsEnumeration); +} + +enum E1 : unsigned char {}; +enum E2 : qlonglong {}; +enum class E3 : unsigned short {}; + +namespace myflags { + + Q_NAMESPACE + + enum Flag1 : int { A, B }; + enum Flag2 : short { X, Y }; + + Q_DECLARE_FLAGS(Flags1, myflags::Flag1); + Q_FLAG_NS(Flags1) + Q_DECLARE_FLAGS(Flags2, myflags::Flag2); + Q_FLAG_NS(Flags2) + +} + +template <typename T> +using getUnderlyingTypeNormalized = std::conditional_t< + std::is_signed_v<std::underlying_type_t<T>>, + typename QIntegerForSize<sizeof(T)>::Signed, + typename QIntegerForSize<sizeof(T)>::Unsigned +>; + +void tst_QMetaType::underlyingType_data() +{ + QTest::addColumn<QMetaType>("source"); + QTest::addColumn<QMetaType>("underlying"); + + QTest::newRow("invalid") << QMetaType() << QMetaType(); + QTest::newRow("plain") << QMetaType::fromType<isEnumTest_Enum1>() + << QMetaType::fromType<getUnderlyingTypeNormalized<isEnumTest_Enum1>>(); + QTest::newRow("uchar") << QMetaType::fromType<E1>() + << QMetaType::fromType<getUnderlyingTypeNormalized<E1>>(); + QTest::newRow("long") << QMetaType::fromType<E2>() + << QMetaType::fromType<getUnderlyingTypeNormalized<E2>>(); + QTest::newRow("class_ushort") << QMetaType::fromType<E3>() + << QMetaType::fromType<getUnderlyingTypeNormalized<E3>>(); + QTest::newRow("flags_int") << QMetaType::fromType<myflags::Flags1>() + << QMetaType::fromType<int>(); + QTest::newRow("flags_short") << QMetaType::fromType<myflags::Flags2>() + << QMetaType::fromType<int>(); // sic, not short! +} + +void tst_QMetaType::underlyingType() +{ + QFETCH(QMetaType, source); + QFETCH(QMetaType, underlying); + QCOMPARE(source.underlyingType(), underlying); } void tst_QMetaType::isRegisteredStaticLess_data() @@ -1916,7 +2196,7 @@ void tst_QMetaType::automaticTemplateRegistration_1() sp.data()->setObjectName("Test name"); \ QVariant v = QVariant::fromValue(sp); \ QCOMPARE(v.typeName(), #SMARTPOINTER "<" #ELEMENT_TYPE ">"); \ - QVERIFY(QMetaType::typeFlags(::qMetaTypeId<SMARTPOINTER < ELEMENT_TYPE > >()) & QMetaType::FLAG_TEST); \ + QVERIFY(QMetaType(::qMetaTypeId<SMARTPOINTER < ELEMENT_TYPE > >()).flags() & QMetaType::FLAG_TEST); \ SMARTPOINTER < QObject > extractedPtr = FROMVARIANTFUNCTION<QObject>(v); \ QCOMPARE(extractedPtr.data()->objectName(), sp.data()->objectName()); \ } @@ -1934,7 +2214,7 @@ void tst_QMetaType::automaticTemplateRegistration_1() sp.data()->setObjectName("Test name"); \ QVariant v = QVariant::fromValue(sp); \ QCOMPARE(v.typeName(), #SMARTPOINTER "<" #ELEMENT_TYPE ">"); \ - QVERIFY(QMetaType::typeFlags(::qMetaTypeId<SMARTPOINTER < ELEMENT_TYPE > >()) & QMetaType::FLAG_TEST); \ + QVERIFY(QMetaType(::qMetaTypeId<SMARTPOINTER < ELEMENT_TYPE > >()).flags() & QMetaType::FLAG_TEST); \ SMARTPOINTER < QObject > extractedPtr = FROMVARIANTFUNCTION<QObject>(v); \ QCOMPARE(extractedPtr.data()->objectName(), sp.data()->objectName()); \ } @@ -1954,7 +2234,7 @@ void tst_QMetaType::automaticTemplateRegistration_1() sp.toStrongRef()->setObjectName("Test name"); \ QVariant v = QVariant::fromValue(sp); \ QCOMPARE(v.typeName(), "QWeakPointer<" #ELEMENT_TYPE ">"); \ - QVERIFY(QMetaType::typeFlags(::qMetaTypeId<QWeakPointer < ELEMENT_TYPE > >()) & QMetaType::FLAG_TEST); \ + QVERIFY(QMetaType(::qMetaTypeId<QWeakPointer < ELEMENT_TYPE > >()).flags() & QMetaType::FLAG_TEST); \ } TEST_WEAK_SMARTPOINTER(QObject, WeakPointerToQObject) @@ -2007,38 +2287,39 @@ void tst_QMetaType::saveAndLoadBuiltin() QFETCH(int, type); QFETCH(bool, isStreamable); - void *value = QMetaType::create(type); + QMetaType metaType(type); + void *value = metaType.create(); QByteArray ba; QDataStream stream(&ba, QIODevice::ReadWrite); - QCOMPARE(QMetaType::save(stream, type, value), isStreamable); + QCOMPARE(metaType.save(stream, value), isStreamable); QCOMPARE(stream.status(), QDataStream::Ok); if (isStreamable) { - QVERIFY(QMetaType(type).hasRegisteredDataStreamOperators()); - QVERIFY(QMetaType::load(stream, type, value)); // Hmmm, shouldn't it return false? + QVERIFY(metaType.hasRegisteredDataStreamOperators()); + QVERIFY(metaType.load(stream, value)); // Hmmm, shouldn't it return false? // std::nullptr_t is nullary: it doesn't actually read anything if (type != QMetaType::Nullptr) QCOMPARE(stream.status(), QDataStream::ReadPastEnd); } else { - QVERIFY(!QMetaType(type).hasRegisteredDataStreamOperators()); + QVERIFY(!metaType.hasRegisteredDataStreamOperators()); } stream.device()->seek(0); stream.resetStatus(); - QCOMPARE(QMetaType::load(stream, type, value), isStreamable); + QCOMPARE(metaType.load(stream, value), isStreamable); QCOMPARE(stream.status(), QDataStream::Ok); if (isStreamable) { - QVERIFY(QMetaType::load(stream, type, value)); // Hmmm, shouldn't it return false? + QVERIFY(metaType.load(stream, value)); // Hmmm, shouldn't it return false? // std::nullptr_t is nullary: it doesn't actually read anything if (type != QMetaType::Nullptr) QCOMPARE(stream.status(), QDataStream::ReadPastEnd); } - QMetaType::destroy(type, value); + metaType.destroy(value); } struct CustomStreamableType @@ -2067,25 +2348,27 @@ void tst_QMetaType::saveAndLoadCustom() t.a = 123; int id = ::qMetaTypeId<CustomStreamableType>(); + QMetaType metaType(id); + QByteArray ba; QDataStream stream(&ba, QIODevice::ReadWrite); - QVERIFY(QMetaType::save(stream, id, &t)); + QVERIFY(metaType.save(stream, &t)); QCOMPARE(stream.status(), QDataStream::Ok); CustomStreamableType t2; t2.a = -1; - QVERIFY(QMetaType::load(stream, id, &t2)); // Hmmm, shouldn't it return false? + QVERIFY(metaType.load(stream, &t2)); // Hmmm, shouldn't it return false? QCOMPARE(stream.status(), QDataStream::ReadPastEnd); QCOMPARE(t2.a, -1); stream.device()->seek(0); stream.resetStatus(); - QVERIFY(QMetaType::load(stream, id, &t2)); + QVERIFY(metaType.load(stream, &t2)); QCOMPARE(stream.status(), QDataStream::Ok); QCOMPARE(t2.a, t.a); - QVERIFY(QMetaType::load(stream, id, &t2)); // Hmmm, shouldn't it return false? + QVERIFY(metaType.load(stream, &t2)); // Hmmm, shouldn't it return false? QCOMPARE(stream.status(), QDataStream::ReadPastEnd); } @@ -2146,7 +2429,6 @@ void tst_QMetaType::metaObject() QFETCH(bool, isGadgetPtr); QFETCH(bool, isQObjectPtr); - QCOMPARE(QMetaType::metaObjectForType(type), result); QMetaType mt(type); QCOMPARE(mt.metaObject(), result); QCOMPARE(!!(mt.flags() & QMetaType::IsGadget), isGadget); diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.h b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.h index 84ba7af294..bcd2fe2def 100644 --- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.h +++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.h @@ -1,5 +1,5 @@ // Copyright (C) 2022 The Qt Company Ltd. -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include <QTest> #include "tst_qmetatype_common.h" @@ -45,7 +45,9 @@ private: private slots: void defined(); +#if QT_CONFIG(thread) void threadSafety(); +#endif void namespaces(); void id(); void qMetaTypeId(); @@ -75,6 +77,7 @@ private slots: void flagsBinaryCompatibility6_0(); void construct_data(); void construct(); + void defaultConstructTrivial_QTBUG_109594(); void typedConstruct(); void constructCopy_data(); void constructCopy(); @@ -88,6 +91,8 @@ private slots: void isRegisteredStaticLess(); void isNotRegistered(); void isEnum(); + void underlyingType_data(); + void underlyingType(); void automaticTemplateRegistration_1(); void automaticTemplateRegistration_2(); // defined in tst_qmetatype3.cpp void saveAndLoadBuiltin_data(); @@ -106,6 +111,7 @@ private slots: void customDebugStream(); void unknownType(); void fromType(); + void compareCompiles(); void operatorEq_data(); void operatorEq(); void operatorEq2_data(); @@ -115,6 +121,15 @@ private slots: void typesWithInaccessibleDTors(); void voidIsNotUnknown(); void typeNameNormalization(); + void typeNameInQtPrivate(); + + // Tests for deprecated APIs +#if QT_DEPRECATED_SINCE(6, 0) + void testDeprecatedGetters_data() { type_data(); } + void testDeprecatedGetters(); + void testDeprecatedLoadSave_data() { saveAndLoadBuiltin_data(); } + void testDeprecatedLoadSave(); +#endif }; template <typename T> @@ -262,7 +277,7 @@ Q_DECLARE_METATYPE(CustomMovable); const QVariant v = QVariant::fromValue(t); \ QByteArray tn = createTypeName(#CONTAINER "<", #__VA_ARGS__); \ const int expectedType = ::qMetaTypeId<CONTAINER< __VA_ARGS__ > >(); \ - const int type = QMetaType::type(tn); \ + const int type = QMetaType::fromName(tn).id(); \ QCOMPARE(type, expectedType); \ QCOMPARE((QMetaType::fromType<CONTAINER< __VA_ARGS__ >>().id()), expectedType); \ } diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype2.cpp b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype2.cpp index 265ec3095f..661c1f6072 100644 --- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype2.cpp +++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype2.cpp @@ -1,10 +1,11 @@ // Copyright (C) 2021 The Qt Company Ltd. -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include "tst_qmetatype.h" #include "tst_qmetatype_libs.h" #include <QtCore/private/qmetaobjectbuilder_p.h> +#include <QtTest/private/qcomparisontesthelper_p.h> void tst_QMetaType::constRefs() { @@ -30,6 +31,30 @@ struct ConvertFunctor } }; +template<typename T> +struct OptionalWrapper +{ + std::optional<T> operator()(const T& t) const + { + if (!CustomConvertibleType::s_ok) + return std::nullopt; + + return t; + } +}; + +template<typename From> +struct ConvertFunctorWithOptional +{ + std::optional<CustomConvertibleType> operator()(const From& f) const + { + if (!CustomConvertibleType::s_ok) + return std::nullopt; + + return CustomConvertibleType(QVariant::fromValue(f)); + } +}; + template<typename From, typename To> bool hasRegisteredConverterFunction() { @@ -81,6 +106,7 @@ void customTypeNotYetConvertible() testCustomTypeNotYetConvertible<QLineF, CustomConvertibleType>(); testCustomTypeNotYetConvertible<QChar, CustomConvertibleType>(); testCustomTypeNotYetConvertible<CustomConvertibleType, CustomConvertibleType2>(); + testCustomTypeNotYetConvertible<CustomConvertibleType, std::optional<CustomConvertibleType>>(); } void registerCustomTypeConversions() @@ -99,20 +125,22 @@ void registerCustomTypeConversions() QVERIFY((QMetaType::registerConverter<CustomConvertibleType, QLine>(&CustomConvertibleType::convert<QLine>))); QVERIFY((QMetaType::registerConverter<CustomConvertibleType, QLineF>(&CustomConvertibleType::convertOk<QLineF>))); QVERIFY((QMetaType::registerConverter<CustomConvertibleType, QChar>(&CustomConvertibleType::convert<QChar>))); - QVERIFY((QMetaType::registerConverter<QString, CustomConvertibleType>(ConvertFunctor<QString>()))); + QVERIFY((QMetaType::registerConverter<QString, CustomConvertibleType>(ConvertFunctorWithOptional<QString>()))); QVERIFY((QMetaType::registerConverter<bool, CustomConvertibleType>(ConvertFunctor<bool>()))); - QVERIFY((QMetaType::registerConverter<int, CustomConvertibleType>(ConvertFunctor<int>()))); + QVERIFY((QMetaType::registerConverter<int, CustomConvertibleType>(ConvertFunctorWithOptional<int>()))); QVERIFY((QMetaType::registerConverter<double, CustomConvertibleType>(ConvertFunctor<double>()))); - QVERIFY((QMetaType::registerConverter<float, CustomConvertibleType>(ConvertFunctor<float>()))); + QVERIFY((QMetaType::registerConverter<float, CustomConvertibleType>(ConvertFunctorWithOptional<float>()))); QVERIFY((QMetaType::registerConverter<QRect, CustomConvertibleType>(ConvertFunctor<QRect>()))); - QVERIFY((QMetaType::registerConverter<QRectF, CustomConvertibleType>(ConvertFunctor<QRectF>()))); + QVERIFY((QMetaType::registerConverter<QRectF, CustomConvertibleType>(ConvertFunctorWithOptional<QRectF>()))); QVERIFY((QMetaType::registerConverter<QPoint, CustomConvertibleType>(ConvertFunctor<QPoint>()))); - QVERIFY((QMetaType::registerConverter<QPointF, CustomConvertibleType>(ConvertFunctor<QPointF>()))); + QVERIFY((QMetaType::registerConverter<QPointF, CustomConvertibleType>(ConvertFunctorWithOptional<QPointF>()))); QVERIFY((QMetaType::registerConverter<QSize, CustomConvertibleType>(ConvertFunctor<QSize>()))); - QVERIFY((QMetaType::registerConverter<QSizeF, CustomConvertibleType>(ConvertFunctor<QSizeF>()))); + QVERIFY((QMetaType::registerConverter<QSizeF, CustomConvertibleType>(ConvertFunctorWithOptional<QSizeF>()))); QVERIFY((QMetaType::registerConverter<QLine, CustomConvertibleType>(ConvertFunctor<QLine>()))); - QVERIFY((QMetaType::registerConverter<QLineF, CustomConvertibleType>(ConvertFunctor<QLineF>()))); + QVERIFY((QMetaType::registerConverter<QLineF, CustomConvertibleType>(ConvertFunctorWithOptional<QLineF>()))); QVERIFY((QMetaType::registerConverter<QChar, CustomConvertibleType>(ConvertFunctor<QChar>()))); + QVERIFY((QMetaType::registerConverter<CustomConvertibleType, std::optional<CustomConvertibleType>>(OptionalWrapper<CustomConvertibleType>()))); + QVERIFY((QMetaType::registerConverter<CustomConvertibleType, CustomConvertibleType2>())); QTest::ignoreMessage(QtWarningMsg, "Type conversion already registered from type CustomConvertibleType to type CustomConvertibleType2"); QVERIFY((!QMetaType::registerConverter<CustomConvertibleType, CustomConvertibleType2>())); @@ -171,7 +199,7 @@ void tst_QMetaType::convertCustomType() QCOMPARE(v.toString(), ok ? testQString : QString()); QCOMPARE(v.value<QString>(), ok ? testQString : QString()); QVERIFY(CustomConvertibleType::s_value.canConvert<CustomConvertibleType>()); - QCOMPARE((CustomConvertibleType::s_value.value<CustomConvertibleType>().m_foo.toString()), testQString); + QCOMPARE((CustomConvertibleType::s_value.value<CustomConvertibleType>().m_foo.toString()), ok ? testQString : QString()); QFETCH(bool, testBool); CustomConvertibleType::s_value = testBool; @@ -183,7 +211,7 @@ void tst_QMetaType::convertCustomType() CustomConvertibleType::s_value = testInt; QCOMPARE(v.toInt(), ok ? testInt : 0); QCOMPARE(v.value<int>(), ok ? testInt : 0); - QCOMPARE((CustomConvertibleType::s_value.value<CustomConvertibleType>().m_foo.toInt()), testInt); + QCOMPARE((CustomConvertibleType::s_value.value<CustomConvertibleType>().m_foo.toInt()), ok ? testInt : 0); QFETCH(double, testDouble); CustomConvertibleType::s_value = testDouble; @@ -195,7 +223,7 @@ void tst_QMetaType::convertCustomType() CustomConvertibleType::s_value = testFloat; QCOMPARE(v.toFloat(), ok ? testFloat : 0.0); QCOMPARE(v.value<float>(), ok ? testFloat : 0.0); - QCOMPARE((CustomConvertibleType::s_value.value<CustomConvertibleType>().m_foo.toFloat()), testFloat); + QCOMPARE((CustomConvertibleType::s_value.value<CustomConvertibleType>().m_foo.toFloat()), ok ? testFloat : 0); QFETCH(QRect, testQRect); CustomConvertibleType::s_value = testQRect; @@ -207,7 +235,7 @@ void tst_QMetaType::convertCustomType() CustomConvertibleType::s_value = testQRectF; QCOMPARE(v.toRectF(), ok ? testQRectF : QRectF()); QCOMPARE(v.value<QRectF>(), ok ? testQRectF : QRectF()); - QCOMPARE((CustomConvertibleType::s_value.value<CustomConvertibleType>().m_foo.toRectF()), testQRectF); + QCOMPARE((CustomConvertibleType::s_value.value<CustomConvertibleType>().m_foo.toRectF()), ok ? testQRectF : QRectF()); QFETCH(QPoint, testQPoint); CustomConvertibleType::s_value = testQPoint; @@ -219,7 +247,7 @@ void tst_QMetaType::convertCustomType() CustomConvertibleType::s_value = testQPointF; QCOMPARE(v.toPointF(), ok ? testQPointF : QPointF()); QCOMPARE(v.value<QPointF>(), ok ? testQPointF : QPointF()); - QCOMPARE((CustomConvertibleType::s_value.value<CustomConvertibleType>().m_foo.toPointF()), testQPointF); + QCOMPARE((CustomConvertibleType::s_value.value<CustomConvertibleType>().m_foo.toPointF()), ok ? testQPointF : QPointF()); QFETCH(QSize, testQSize); CustomConvertibleType::s_value = testQSize; @@ -231,7 +259,7 @@ void tst_QMetaType::convertCustomType() CustomConvertibleType::s_value = testQSizeF; QCOMPARE(v.toSizeF(), ok ? testQSizeF : QSizeF()); QCOMPARE(v.value<QSizeF>(), ok ? testQSizeF : QSizeF()); - QCOMPARE((CustomConvertibleType::s_value.value<CustomConvertibleType>().m_foo.toSizeF()), testQSizeF); + QCOMPARE((CustomConvertibleType::s_value.value<CustomConvertibleType>().m_foo.toSizeF()), ok ? testQSizeF : QSizeF()); QFETCH(QLine, testQLine); CustomConvertibleType::s_value = testQLine; @@ -243,7 +271,7 @@ void tst_QMetaType::convertCustomType() CustomConvertibleType::s_value = testQLineF; QCOMPARE(v.toLineF(), ok ? testQLineF : QLineF()); QCOMPARE(v.value<QLineF>(), ok ? testQLineF : QLineF()); - QCOMPARE((CustomConvertibleType::s_value.value<CustomConvertibleType>().m_foo.toLineF()), testQLineF); + QCOMPARE((CustomConvertibleType::s_value.value<CustomConvertibleType>().m_foo.toLineF()), ok ? testQLineF : QLineF()); QFETCH(QChar, testQChar); CustomConvertibleType::s_value = testQChar; @@ -252,9 +280,21 @@ void tst_QMetaType::convertCustomType() QFETCH(CustomConvertibleType, testCustom); v = QVariant::fromValue(testCustom); - QVERIFY(v.canConvert(::qMetaTypeId<CustomConvertibleType2>())); + QVERIFY(v.canConvert(QMetaType(::qMetaTypeId<CustomConvertibleType2>()))); QCOMPARE(v.value<CustomConvertibleType2>().m_foo, testCustom.m_foo); + // Check that converters that actually convert to std::optional<T> are not + // taken to indicate success or failure of the conversion. In these cases, + // the conversion must always succeed, even if the converter has returned a + // nullopt. + v = QVariant::fromValue(testCustom); + QVERIFY(v.canConvert(QMetaType::fromType<std::optional<CustomConvertibleType>>())); + QVERIFY(v.convert(QMetaType::fromType<std::optional<CustomConvertibleType>>())); + QCOMPARE(v.value<std::optional<CustomConvertibleType>>().has_value(), ok); + if (ok) { + QCOMPARE(v.value<std::optional<CustomConvertibleType>>().value().m_foo, testCustom.m_foo); + } + QFETCH(DerivedGadgetType, testDerived); v = QVariant::fromValue(testDerived); QCOMPARE(v.metaType(), QMetaType::fromType<DerivedGadgetType>()); @@ -379,6 +419,11 @@ struct CharTemplate } y; }; +void tst_QMetaType::compareCompiles() +{ + QTestPrivate::testEqualityOperatorsCompile<QMetaType>(); +} + void tst_QMetaType::operatorEq_data() { QTest::addColumn<QMetaType>("typeA"); @@ -408,10 +453,7 @@ void tst_QMetaType::operatorEq() QFETCH(QMetaType, typeB); QFETCH(bool, eq); - QCOMPARE(typeA == typeB, eq); - QCOMPARE(typeB == typeA, eq); - QCOMPARE(typeA != typeB, !eq); - QCOMPARE(typeB != typeA, !eq); + QT_TEST_EQUALITY_OPS(typeA, typeB, eq); #if !defined(Q_OS_WIN) && !defined(Q_OS_INTEGRITY) // for built-in types or locally-defined types, this must also hold true @@ -448,10 +490,10 @@ FOR_EACH_CORE_METATYPE(GET_METATYPE_FROM_TYPE) QCOMPARE(fromId2.id(), type); // confirm that they're all equal - QCOMPARE(fromId1, fromId2); - QCOMPARE(fromType1, fromType2); - QCOMPARE(fromType1, fromId1); - QCOMPARE(fromType2, fromId2); + QT_TEST_EQUALITY_OPS(fromId1, fromId2, true); + QT_TEST_EQUALITY_OPS(fromType1, fromType2, true); + QT_TEST_EQUALITY_OPS(fromType1, fromId1, true); + QT_TEST_EQUALITY_OPS(fromType2, fromId2, true); #if !defined(Q_OS_WIN) && !defined(Q_OS_INTEGRITY) // for built-in types (other than void), this must be true @@ -502,7 +544,7 @@ void tst_QMetaType::operatorEqAcrossLibs() // DO THIS FIRST: // if this isn't a built-in type, then the QMetaTypeInterface::typeId is // initially set to 0 - QCOMPARE(lib1Type, lib2Type); + QT_TEST_EQUALITY_OPS(lib1Type, lib2Type, true); int actualTypeId = localType.id(); bool builtinTypeExpected = builtinTypeId != QMetaType::UnknownType; @@ -520,8 +562,8 @@ void tst_QMetaType::operatorEqAcrossLibs() QCOMPARE(lib2Type.id(), actualTypeId); QCOMPARE(QByteArray(lib1Type.name()), QByteArray(localType.name())); QCOMPARE(QByteArray(lib2Type.name()), QByteArray(localType.name())); - QCOMPARE(lib1Type, localType); - QCOMPARE(lib2Type, localType); + QT_TEST_EQUALITY_OPS(lib1Type, localType, true); + QT_TEST_EQUALITY_OPS(lib2Type, localType, true); #if !defined(Q_OS_WIN) && !defined(Q_OS_INTEGRITY) if (actualTypeId < QMetaType::FirstGuiType && actualTypeId != QMetaType::Void) { @@ -601,6 +643,83 @@ void tst_QMetaType::typeNameNormalization() } } +QT_BEGIN_NAMESPACE +namespace QtPrivate { struct tst_QMetaType_TestType {}; } +QT_END_NAMESPACE + +void tst_QMetaType::typeNameInQtPrivate() +{ + using T = QT_PREPEND_NAMESPACE(QtPrivate::tst_QMetaType_TestType); + + // some compilers (GCC) are known to suppress the namespace prefix if the + // type and the function where it is expanded on are on the same namespace + static constexpr char expectedName[] = "QtPrivate::tst_QMetaType_TestType"; + QMetaType mt = QMetaType::fromType<T>(); + QCOMPARE(mt.name(), expectedName); +} + +#if QT_DEPRECATED_SINCE(6, 0) +void tst_QMetaType::testDeprecatedGetters() +{ + QFETCH(int, aType); + QFETCH(QByteArray, aTypeName); + + if (aType >= QMetaType::FirstWidgetsType) + QSKIP("The test doesn't link against QtWidgets."); + + // QMetaType::type("name") -> QMetaType::fromName("name").id() + QT_IGNORE_DEPRECATIONS(QCOMPARE(QMetaType::type(aTypeName), + QMetaType::fromName(aTypeName).id());) + // QMetaType::typeName(int) -> QMetaType(int).name() + QT_IGNORE_DEPRECATIONS(QCOMPARE(QLatin1String(QMetaType::typeName(aType)), + QLatin1String(QMetaType(aType).name()));) + // QMetaType::typeFlags(int) -> QMetaType(int).flags() + QT_IGNORE_DEPRECATIONS(QCOMPARE(QMetaType::typeFlags(aType), + QMetaType(aType).flags());) + // QMetaType::metaObjectForType(int) -> QMetaType(int).metaObject() + QT_IGNORE_DEPRECATIONS(QCOMPARE(QMetaType::metaObjectForType(aType), + QMetaType(aType).metaObject());) +} + +void tst_QMetaType::testDeprecatedLoadSave() +{ + QFETCH(int, type); + QFETCH(bool, isStreamable); + + if (!isStreamable) + return; + + QMetaType metaType(type); + void *value = metaType.create(); + auto cleanup = qScopeGuard([&metaType, value]() { + metaType.destroy(value); + }); + + QByteArray ba; + QDataStream stream(&ba, QIODevice::ReadWrite); + + // Write using deprecated API + QT_IGNORE_DEPRECATIONS(QVERIFY(QMetaType::save(stream, type, value));) + QCOMPARE(stream.status(), QDataStream::Ok); + + // Read using non-deprecated API + stream.device()->seek(0); + QVERIFY(metaType.load(stream, value)); + QCOMPARE(stream.status(), QDataStream::Ok); + + // Write using non-deprecated API + stream.device()->seek(0); + ba.clear(); + QVERIFY(metaType.save(stream, value)); + QCOMPARE(stream.status(), QDataStream::Ok); + + // Read using deprecated API + stream.device()->seek(0); + QT_IGNORE_DEPRECATIONS(QVERIFY(QMetaType::load(stream, type, value));) + QCOMPARE(stream.status(), QDataStream::Ok); +} +#endif // QT_DEPRECATED_SINCE(6, 0) + // Compile-time test, it should be possible to register function pointer types class Undefined; diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype3.cpp b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype3.cpp index 95577e16da..779044589c 100644 --- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype3.cpp +++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype3.cpp @@ -1,5 +1,5 @@ // Copyright (C) 2021 The Qt Company Ltd. -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #include "tst_qmetatype.h" diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype_common.h b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype_common.h index 3324cb5b32..ea59b5cd02 100644 --- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype_common.h +++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype_common.h @@ -1,5 +1,5 @@ // Copyright (C) 2022 The Qt Company Ltd. -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only // Used by both tst_qmetatype and tst_qsettings @@ -129,6 +129,9 @@ template<> struct TestValueFactory<QMetaType::UChar> { template<> struct TestValueFactory<QMetaType::Float> { static float *create() { return new float(FLT_MIN); } }; +template<> struct TestValueFactory<QMetaType::Float16> { + static auto create() { return new qfloat16(std::numeric_limits<qfloat16>::min()); } +}; template<> struct TestValueFactory<QMetaType::QObjectStar> { static QObject * *create() { return new QObject *(0); } }; diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype_libs.h b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype_libs.h index 908e80f9a8..673fc9083c 100644 --- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype_libs.h +++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype_libs.h @@ -1,5 +1,5 @@ // Copyright (C) 2022 Intel Corporation -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only WITH Qt-GPL-exception-1.0 +// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only #ifndef TST_QMETATYPE_LIBS_H #define TST_QMETATYPE_LIBS_H |