diff options
Diffstat (limited to 'tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp')
-rw-r--r-- | tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp | 206 |
1 files changed, 203 insertions, 3 deletions
diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp index b611fb146c..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 @@ -1025,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) @@ -1198,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; @@ -1322,6 +1344,132 @@ 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) @@ -1712,6 +1860,58 @@ void tst_QMetaType::isEnum() 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() { isRegistered_data(); |