1berry/qtbase
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

tst_qmetatype: port away from deprecated calls

Browse Source 
The most common changes are:
* Replace QMetaType::type("name") with QMetaType::fromName("name").id()
  or QMetaType::fromType<Type>().id()
* QMetaType::typeName(int) -> QMetaType(int).name()
* QMetaType::typeFlags(int) -> QMetaType(int).flags()
* QMetaType::metaObjectForType(int) -> QMetaType(int).metaObject()
* The static QMetaType::{load,save} methods are replaced with
  non-static versions
* The static QMetaType::{create,destroy,construct, destruct} methods
  are guarded by QT_DEPRECATED_SINCE calls. The tests are also
  extended with non-static calls where they were missing. Fixed
  potential memory-leaks in these tests.

Add separate unit-tests for deprecated APIs and guard them with
QT_DEPRECATED_SINCE

As a drive-by: use nullptr instead of 0 in some places

Task-number: QTBUG-104858
Change-Id: I4b0cdd29bc197c186b835002372240aae3098c33
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
This commit is contained in:
Ivan Solovev 2022-08-16 17:42:54 +02:00
parent 35a50491e7
commit 91eec59b87
4 changed files with 304 additions and 156 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
tests/auto/corelib/kernel/qmetatype/CMakeLists.txt
View File

@ -43,8 +43,6 @@ qt_internal_add_test(tst_qmetatype
SOURCES SOURCES
tst_qmetatype.h tst_qmetatype.cpp tst_qmetatype2.cpp tst_qmetatype.h tst_qmetatype.cpp tst_qmetatype2.cpp
tst_qmetatype3.cpp tst_qmetatype3.cpp
DEFINES
QT_DISABLE_DEPRECATED_UP_TO=0
INCLUDE_DIRECTORIES INCLUDE_DIRECTORIES
../../../other/qvariant_common ../../../other/qvariant_common
LIBRARIES LIBRARIES

380
tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
View File

@ -411,43 +411,51 @@ protected:
++failureCount; ++failureCount;
qWarning() << name << "is not a registered metatype"; qWarning() << name << "is not a registered metatype";
} }
if (QMetaType::type(nm) != tp) { if (QMetaType::fromName(nm).id() != tp) {
++failureCount; ++failureCount;
qWarning() << "Wrong metatype returned for" << name; 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::destruct(tp, space);
QMetaType::construct(tp, space, buf1); QMetaType::construct(tp, space, buf1);
QMetaType::destruct(tp, space); QMetaType::destruct(tp, space);
info.construct(space, 0);
info.destruct(space);
info.construct(space, buf1);
info.destruct(space);
if (!buf1) { if (!buf1) {
++failureCount; ++failureCount;
qWarning() << "Null buffer returned by QMetaType::create(tp, 0)"; qWarning() << "Null buffer returned by QMetaType::create(tp, nullptr)";
} }
if (!buf2) { if (!buf2) {
++failureCount; ++failureCount;
qWarning() << "Null buffer returned by QMetaType::create(tp, buf)"; 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) { if (!buf3) {
++failureCount; ++failureCount;
qWarning() << "Null buffer returned by info.create(tp, 0)"; qWarning() << "Null buffer returned by info.create(nullptr)";
} }
if (!buf4) { if (!buf4) {
++failureCount; ++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(buf3);
info.destroy(buf4); info.destroy(buf4);
} }
@ -495,7 +503,7 @@ void tst_QMetaType::namespaces()
QCOMPARE(qvariant_cast<TestSpace::Foo>(v).d, 11.12); QCOMPARE(qvariant_cast<TestSpace::Foo>(v).d, 11.12);
int qungTfuId = qRegisterMetaType<ADD_TESTSPACE(QungTfu)>(); int qungTfuId = qRegisterMetaType<ADD_TESTSPACE(QungTfu)>();
QCOMPARE(QMetaType::typeName(qungTfuId), "TestSpace::QungTfu"); QCOMPARE(QMetaType(qungTfuId).name(), "TestSpace::QungTfu");
} }
void tst_QMetaType::id() void tst_QMetaType::id()
@ -509,13 +517,13 @@ void tst_QMetaType::qMetaTypeId()
{ {
QCOMPARE(::qMetaTypeId<QString>(), int(QMetaType::QString)); QCOMPARE(::qMetaTypeId<QString>(), int(QMetaType::QString));
QCOMPARE(::qMetaTypeId<int>(), int(QMetaType::Int)); 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<char>(), QMetaType::fromType<char>().id());
QCOMPARE(::qMetaTypeId<uchar>(), QMetaType::type("unsigned char")); QCOMPARE(::qMetaTypeId<uchar>(), QMetaType::fromType<unsigned char>().id());
QCOMPARE(::qMetaTypeId<signed char>(), QMetaType::type("signed char")); QCOMPARE(::qMetaTypeId<signed char>(), QMetaType::fromType<signed char>().id());
QVERIFY(::qMetaTypeId<signed char>() != ::qMetaTypeId<char>()); QVERIFY(::qMetaTypeId<signed char>() != ::qMetaTypeId<char>());
QCOMPARE(::qMetaTypeId<qint8>(), QMetaType::type("qint8")); QCOMPARE(::qMetaTypeId<qint8>(), QMetaType::fromType<qint8>().id());
} }
void tst_QMetaType::properties() void tst_QMetaType::properties()
@ -542,13 +550,13 @@ void tst_QMetaType::normalizedTypes()
int WhityIntId = ::qMetaTypeId<Whity<int> >(); int WhityIntId = ::qMetaTypeId<Whity<int> >();
int WhityDoubleId = ::qMetaTypeId<Whity<double> >(); int WhityDoubleId = ::qMetaTypeId<Whity<double> >();
QCOMPARE(QMetaType::type("Whity<int>"), WhityIntId); QCOMPARE(QMetaType::fromName("Whity<int>").id(), WhityIntId);
QCOMPARE(QMetaType::type(" Whity < int > "), WhityIntId); QCOMPARE(QMetaType::fromName(" Whity < int > ").id(), WhityIntId);
QCOMPARE(QMetaType::type("Whity<int >"), WhityIntId); QCOMPARE(QMetaType::fromName("Whity<int >").id(), WhityIntId);
QCOMPARE(QMetaType::type("Whity<double>"), WhityDoubleId); QCOMPARE(QMetaType::fromName("Whity<double>").id(), WhityDoubleId);
QCOMPARE(QMetaType::type(" Whity< double > "), WhityDoubleId); QCOMPARE(QMetaType::fromName(" Whity< double > ").id(), WhityDoubleId);
QCOMPARE(QMetaType::type("Whity<double >"), WhityDoubleId); QCOMPARE(QMetaType::fromName("Whity<double >").id(), WhityDoubleId);
QCOMPARE(qRegisterMetaType<Whity<int> >(" Whity < int > "), WhityIntId); QCOMPARE(qRegisterMetaType<Whity<int> >(" Whity < int > "), WhityIntId);
QCOMPARE(qRegisterMetaType<Whity<int> >("Whity<int>"), WhityIntId); QCOMPARE(qRegisterMetaType<Whity<int> >("Whity<int>"), WhityIntId);
@ -626,7 +634,7 @@ void tst_QMetaType::typeName()
QSKIP("The test doesn't link against QtWidgets."); QSKIP("The test doesn't link against QtWidgets.");
ignoreInvalidMetaTypeWarning(aType); ignoreInvalidMetaTypeWarning(aType);
const char *rawname = QMetaType::typeName(aType); const char *rawname = QMetaType(aType).name();
QString name = QString::fromLatin1(rawname); QString name = QString::fromLatin1(rawname);
QCOMPARE(name, aTypeName); QCOMPARE(name, aTypeName);
@ -667,10 +675,8 @@ void tst_QMetaType::type()
if (aType >= QMetaType::FirstWidgetsType) if (aType >= QMetaType::FirstWidgetsType)
QSKIP("The test doesn't link against QtWidgets."); QSKIP("The test doesn't link against QtWidgets.");
// QMetaType::type(QByteArray) QCOMPARE(QMetaType::fromName(aTypeName).id(), aType);
QCOMPARE(QMetaType::type(aTypeName), aType); QCOMPARE(QMetaType::fromName(aTypeName.constData()).id(), aType);
// QMetaType::type(const char *)
QCOMPARE(QMetaType::type(aTypeName.constData()), aType);
} }
void tst_QMetaType::type_fromSubString_data() void tst_QMetaType::type_fromSubString_data()
@ -695,7 +701,7 @@ void tst_QMetaType::type_fromSubString()
QFETCH(int, size); QFETCH(int, size);
QFETCH(int, expectedType); QFETCH(int, expectedType);
QByteArray ba = QByteArray::fromRawData(types + offset, size); QByteArray ba = QByteArray::fromRawData(types + offset, size);
QCOMPARE(QMetaType::type(ba), expectedType); QCOMPARE(QMetaType::fromName(ba).id(), expectedType);
} }
namespace { namespace {
@ -722,7 +728,7 @@ void tst_QMetaType::create_data()
QTest::addColumn<int>("type"); QTest::addColumn<int>("type");
QTest::newRow("unknown-type") << int(QMetaType::UnknownType); QTest::newRow("unknown-type") << int(QMetaType::UnknownType);
#define ADD_METATYPE_TEST_ROW(MetaTypeName, MetaTypeId, RealType) \ #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) FOR_EACH_CORE_METATYPE(ADD_METATYPE_TEST_ROW)
#undef ADD_METATYPE_TEST_ROW #undef ADD_METATYPE_TEST_ROW
} }
@ -731,23 +737,36 @@ template<int ID>
static void testCreateHelper() static void testCreateHelper()
{ {
typedef typename MetaEnumToType<ID>::Type Type; 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 *actual1 = QMetaType::create(ID);
void *actual2 = info.create(); auto cleanup1 = qScopeGuard([actual1]() {
Type *expected = DefaultValueFactory<ID>::create();
QCOMPARE(*static_cast<Type *>(actual1), *expected);
QCOMPARE(*static_cast<Type *>(actual2), *expected);
delete expected;
QMetaType::destroy(ID, 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); info.destroy(actual2);
});
QCOMPARE(*static_cast<Type *>(actual2), *expected);
} }
template<> template<>
void testCreateHelper<QMetaType::Void>() void testCreateHelper<QMetaType::Void>()
{ {
void *actual = QMetaType::create(QMetaType::Void); #if QT_DEPRECATED_SINCE(6, 0)
QMetaType::destroy(QMetaType::Void, actual); 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 +801,22 @@ template<int ID>
static void testCreateCopyHelper() static void testCreateCopyHelper()
{ {
typedef typename MetaEnumToType<ID>::Type Type; typedef typename MetaEnumToType<ID>::Type Type;
Type *expected = TestValueFactory<ID>::create(); auto expected = std::unique_ptr<Type>(TestValueFactory<ID>::create());
QMetaType info(ID); #if QT_DEPRECATED_SINCE(6, 0)
void *actual1 = QMetaType::create(ID, expected); QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED
void *actual2 = info.create(expected); void *actual1 = QMetaType::create(ID, expected.get());
QCOMPARE(*static_cast<Type *>(actual1), *expected); auto cleanup1 = qScopeGuard([actual1]() {
QCOMPARE(*static_cast<Type *>(actual2), *expected);
QMetaType::destroy(ID, 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); info.destroy(actual2);
delete expected; });
QCOMPARE(*static_cast<Type *>(actual2), *expected);
} }
template<> template<>
@ -798,9 +824,22 @@ void testCreateCopyHelper<QMetaType::Void>()
{ {
typedef MetaEnumToType<QMetaType::Void>::Type Type; typedef MetaEnumToType<QMetaType::Void>::Type Type;
Type *expected = TestValueFactory<QMetaType::Void>::create(); Type *expected = TestValueFactory<QMetaType::Void>::create();
void *actual = QMetaType::create(QMetaType::Void, expected); QCOMPARE(expected, nullptr); // we do not need to delete it
QCOMPARE(static_cast<Type *>(actual), expected); #if QT_DEPRECATED_SINCE(6, 0)
QMetaType::destroy(QMetaType::Void, actual); 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() void tst_QMetaType::createCopy_data()
@ -864,7 +903,8 @@ void tst_QMetaType::sizeOf()
QFETCH(int, type); QFETCH(int, type);
QFETCH(size_t, size); QFETCH(size_t, size);
ignoreInvalidMetaTypeWarning(type); ignoreInvalidMetaTypeWarning(type);
QCOMPARE(size_t(QMetaType::sizeOf(type)), size); QMetaType metaType(type);
QCOMPARE(size_t(metaType.sizeOf()), size);
} }
void tst_QMetaType::sizeOfStaticLess_data() void tst_QMetaType::sizeOfStaticLess_data()
@ -1167,7 +1207,7 @@ void tst_QMetaType::flagsBinaryCompatibility6_0_data()
if (id > QMetaType::LastCoreType) if (id > QMetaType::LastCoreType)
continue; // We do not link against QtGui, so we do longer consider such type as registered 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"); 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 +1216,7 @@ void tst_QMetaType::flagsBinaryCompatibility6_0()
QFETCH(quint32, id); QFETCH(quint32, id);
QFETCH(quint32, flags); QFETCH(quint32, flags);
const auto currentFlags = QMetaType::typeFlags(id); const auto currentFlags = QMetaType(id).flags();
auto expectedFlags = QMetaType::TypeFlags(flags); auto expectedFlags = QMetaType::TypeFlags(flags);
// Only compare the values that were already defined in 5.0. // Only compare the values that were already defined in 5.0.
@ -1197,42 +1237,61 @@ template<int ID>
static void testConstructHelper() static void testConstructHelper()
{ {
typedef typename MetaEnumToType<ID>::Type Type; typedef typename MetaEnumToType<ID>::Type Type;
auto expected = std::unique_ptr<Type>(DefaultValueFactory<ID>::create());
QMetaType info(ID); QMetaType info(ID);
int size = info.sizeOf(); int size = info.sizeOf();
#if QT_DEPRECATED_SINCE(6, 0)
QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED
void *storage1 = qMallocAligned(size, alignof(Type)); void *storage1 = qMallocAligned(size, alignof(Type));
void *actual1 = QMetaType::construct(ID, storage1, /*copy=*/0); void *actual1 = QMetaType::construct(ID, storage1, /*copy=*/nullptr);
void *storage2 = qMallocAligned(size, alignof(Type)); auto cleanup1 = qScopeGuard([storage1, actual1]() {
void *actual2 = info.construct(storage2, /*copy=*/0);
QCOMPARE(actual1, storage1);
QCOMPARE(actual2, storage2);
Type *expected = DefaultValueFactory<ID>::create();
QCOMPARE(*static_cast<Type *>(actual1), *expected);
QCOMPARE(*static_cast<Type *>(actual2), *expected);
delete expected;
QMetaType::destruct(ID, actual1); QMetaType::destruct(ID, actual1);
qFreeAligned(storage1); qFreeAligned(storage1);
});
QCOMPARE(actual1, storage1);
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); info.destruct(actual2);
qFreeAligned(storage2); qFreeAligned(storage2);
});
QVERIFY(QMetaType::construct(ID, 0, /*copy=*/0) == 0); QCOMPARE(actual2, storage2);
QMetaType::destruct(ID, 0); QCOMPARE(*static_cast<Type *>(actual2), *expected);
QCOMPARE(info.construct(nullptr, /*copy=*/nullptr), nullptr);
QVERIFY(info.construct(0, /*copy=*/0) == 0); info.destruct(nullptr);
info.destruct(0);
} }
template<> template<>
void testConstructHelper<QMetaType::Void>() void testConstructHelper<QMetaType::Void>()
{ {
/*int size = */ QMetaType::sizeOf(QMetaType::Void); #if QT_DEPRECATED_SINCE(6, 0)
void *storage = 0; QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED
void *actual = QMetaType::construct(QMetaType::Void, storage, /*copy=*/0); void *storage1 = nullptr;
QCOMPARE(actual, storage); void *actual1 = QMetaType::construct(QMetaType::Void, storage1, /*copy=*/nullptr);
QMetaType::destruct(QMetaType::Void, actual); auto cleanup1 = qScopeGuard([storage1, actual1]() {
qFreeAligned(storage); QMetaType::destruct(QMetaType::Void, actual1);
qFreeAligned(storage1);
QVERIFY(QMetaType::construct(QMetaType::Void, 0, /*copy=*/0) == 0); });
QMetaType::destruct(QMetaType::Void, 0); 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() void tst_QMetaType::construct()
@ -1265,7 +1324,7 @@ void tst_QMetaType::typedConstruct()
{ {
auto testMetaObjectWriteOnGadget = [](QVariant &gadget, const QList<GadgetPropertyType> &properties) auto testMetaObjectWriteOnGadget = [](QVariant &gadget, const QList<GadgetPropertyType> &properties)
{ {
auto metaObject = QMetaType::metaObjectForType(gadget.userType()); auto metaObject = QMetaType(gadget.userType()).metaObject();
QVERIFY(metaObject != nullptr); QVERIFY(metaObject != nullptr);
QCOMPARE(metaObject->methodCount(), 0); QCOMPARE(metaObject->methodCount(), 0);
QCOMPARE(metaObject->propertyCount(), properties.size()); QCOMPARE(metaObject->propertyCount(), properties.size());
@ -1279,7 +1338,7 @@ void tst_QMetaType::typedConstruct()
auto testMetaObjectReadOnGadget = [](QVariant gadget, const QList<GadgetPropertyType> &properties) auto testMetaObjectReadOnGadget = [](QVariant gadget, const QList<GadgetPropertyType> &properties)
{ {
auto metaObject = QMetaType::metaObjectForType(gadget.userType()); auto metaObject = QMetaType(gadget.userType()).metaObject();
QVERIFY(metaObject != nullptr); QVERIFY(metaObject != nullptr);
QCOMPARE(metaObject->methodCount(), 0); QCOMPARE(metaObject->methodCount(), 0);
QCOMPARE(metaObject->propertyCount(), properties.size()); QCOMPARE(metaObject->propertyCount(), properties.size());
@ -1287,7 +1346,7 @@ void tst_QMetaType::typedConstruct()
auto prop = metaObject->property(i); auto prop = metaObject->property(i);
QCOMPARE(properties[i].name, prop.name()); QCOMPARE(properties[i].name, prop.name());
QCOMPARE(properties[i].type, prop.typeName()); 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())); QCOMPARE(properties[i].testData, prop.readOnGadget(gadget.constData()));
} }
}; };
@ -1299,7 +1358,7 @@ void tst_QMetaType::typedConstruct()
}; };
registerGadget("DynamicGadget1", dynamicGadget1); registerGadget("DynamicGadget1", dynamicGadget1);
QVariant testGadget1(QMetaType(QMetaType::type("DynamicGadget1"))); QVariant testGadget1(QMetaType::fromName("DynamicGadget1"));
testMetaObjectWriteOnGadget(testGadget1, dynamicGadget1); testMetaObjectWriteOnGadget(testGadget1, dynamicGadget1);
testMetaObjectReadOnGadget(testGadget1, dynamicGadget1); testMetaObjectReadOnGadget(testGadget1, dynamicGadget1);
@ -1311,10 +1370,10 @@ void tst_QMetaType::typedConstruct()
{"DynamicGadget1", "dynamicGadget1_prop", testGadget1} {"DynamicGadget1", "dynamicGadget1_prop", testGadget1}
}; };
registerGadget("DynamicGadget2", dynamicGadget2); registerGadget("DynamicGadget2", dynamicGadget2);
QVariant testGadget2(QMetaType(QMetaType::type("DynamicGadget2"))); QVariant testGadget2(QMetaType::fromName("DynamicGadget2"));
testMetaObjectWriteOnGadget(testGadget2, dynamicGadget2); testMetaObjectWriteOnGadget(testGadget2, dynamicGadget2);
testMetaObjectReadOnGadget(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")); auto dynamicGadget1_prop = g2mo->property(g2mo->indexOfProperty("dynamicGadget1_prop"));
testMetaObjectReadOnGadget(dynamicGadget1_prop.readOnGadget(testGadget2.constData()), dynamicGadget1); testMetaObjectReadOnGadget(dynamicGadget1_prop.readOnGadget(testGadget2.constData()), dynamicGadget1);
@ -1346,7 +1405,7 @@ void tst_QMetaType::typedConstruct()
s_managedTypes[podTypeId] = qMakePair(dynamicGadgetProperties, std::shared_ptr<QMetaObject>{}); s_managedTypes[podTypeId] = qMakePair(dynamicGadgetProperties, std::shared_ptr<QMetaObject>{});
// Test POD // Test POD
QCOMPARE(podTypeId, QMetaType::type(podTypeName)); QCOMPARE(podTypeId, QMetaType::fromName(podTypeName).id());
QVariant podVariant{QMetaType(podTypeId)}; QVariant podVariant{QMetaType(podTypeId)};
QCOMPARE(myPodTesData, static_cast<const GenericPODType *>(reinterpret_cast<const BaseGenericType *>(podVariant.constData()))->podData); QCOMPARE(myPodTesData, static_cast<const GenericPODType *>(reinterpret_cast<const BaseGenericType *>(podVariant.constData()))->podData);
@ -1360,27 +1419,32 @@ template<int ID>
static void testConstructCopyHelper() static void testConstructCopyHelper()
{ {
typedef typename MetaEnumToType<ID>::Type Type; typedef typename MetaEnumToType<ID>::Type Type;
Type *expected = TestValueFactory<ID>::create(); auto expected = std::unique_ptr<Type>(TestValueFactory<ID>::create());
QMetaType info(ID); 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); QCOMPARE(info.sizeOf(), size);
void *storage1 = qMallocAligned(size, alignof(Type)); void *storage1 = qMallocAligned(size, alignof(Type));
void *actual1 = QMetaType::construct(ID, storage1, expected); void *actual1 = QMetaType::construct(ID, storage1, expected.get());
void *storage2 = qMallocAligned(size, alignof(Type)); auto cleanup1 = qScopeGuard([storage1, actual1]() {
void *actual2 = info.construct(storage2, expected);
QCOMPARE(actual1, storage1);
QCOMPARE(actual2, storage2);
QCOMPARE(*static_cast<Type *>(actual1), *expected);
QCOMPARE(*static_cast<Type *>(actual2), *expected);
QMetaType::destruct(ID, actual1); QMetaType::destruct(ID, actual1);
qFreeAligned(storage1); qFreeAligned(storage1);
});
QCOMPARE(actual1, storage1);
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); info.destruct(actual2);
qFreeAligned(storage2); qFreeAligned(storage2);
});
QVERIFY(QMetaType::construct(ID, 0, expected) == 0); QCOMPARE(actual2, storage2);
QVERIFY(info.construct(0, expected) == 0); QCOMPARE(*static_cast<Type *>(actual2), *expected);
QCOMPARE(info.construct(nullptr, expected.get()), nullptr);
delete expected;
} }
template<> template<>
@ -1388,14 +1452,28 @@ void testConstructCopyHelper<QMetaType::Void>()
{ {
typedef MetaEnumToType<QMetaType::Void>::Type Type; typedef MetaEnumToType<QMetaType::Void>::Type Type;
Type *expected = TestValueFactory<QMetaType::Void>::create(); Type *expected = TestValueFactory<QMetaType::Void>::create();
/* int size = */QMetaType::sizeOf(QMetaType::Void); QCOMPARE(expected, nullptr); // we do not need to delete it
void *storage = 0; #if QT_DEPRECATED_SINCE(6, 0)
void *actual = QMetaType::construct(QMetaType::Void, storage, expected); QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED
QCOMPARE(actual, storage); void *storage1 = nullptr;
QMetaType::destruct(QMetaType::Void, actual); void *actual1 = QMetaType::construct(QMetaType::Void, storage1, expected);
qFreeAligned(storage); auto cleanup1 = qScopeGuard([storage1, actual1]() {
QMetaType::destruct(QMetaType::Void, actual1);
QVERIFY(QMetaType::construct(QMetaType::Void, 0, expected) == 0); 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() void tst_QMetaType::constructCopy_data()
@ -1444,7 +1522,7 @@ void tst_QMetaType::selfCompare_data()
QTest::newRow("unknown-type") << int(QMetaType::UnknownType) << orderingFor(QMetaType::UnknownType); QTest::newRow("unknown-type") << int(QMetaType::UnknownType) << orderingFor(QMetaType::UnknownType);
#define ADD_METATYPE_TEST_ROW(MetaTypeName, MetaTypeId, RealType) \ #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) FOR_EACH_CORE_METATYPE(ADD_METATYPE_TEST_ROW)
#undef ADD_METATYPE_TEST_ROW #undef ADD_METATYPE_TEST_ROW
} }
@ -1486,26 +1564,26 @@ Q_DECLARE_METATYPE(CustomString) //this line is useless
void tst_QMetaType::typedefs() void tst_QMetaType::typedefs()
{ {
QCOMPARE(QMetaType::type("long long"), int(QMetaType::LongLong)); QCOMPARE(QMetaType::fromName("long long").id(), int(QMetaType::LongLong));
QCOMPARE(QMetaType::type("unsigned long long"), int(QMetaType::ULongLong)); QCOMPARE(QMetaType::fromName("unsigned long long").id(), int(QMetaType::ULongLong));
QCOMPARE(QMetaType::type("qint8"), int(QMetaType::SChar)); QCOMPARE(QMetaType::fromName("qint8").id(), int(QMetaType::SChar));
QCOMPARE(QMetaType::type("quint8"), int(QMetaType::UChar)); QCOMPARE(QMetaType::fromName("quint8").id(), int(QMetaType::UChar));
QCOMPARE(QMetaType::type("qint16"), int(QMetaType::Short)); QCOMPARE(QMetaType::fromName("qint16").id(), int(QMetaType::Short));
QCOMPARE(QMetaType::type("quint16"), int(QMetaType::UShort)); QCOMPARE(QMetaType::fromName("quint16").id(), int(QMetaType::UShort));
QCOMPARE(QMetaType::type("qint32"), int(QMetaType::Int)); QCOMPARE(QMetaType::fromName("qint32").id(), int(QMetaType::Int));
QCOMPARE(QMetaType::type("quint32"), int(QMetaType::UInt)); QCOMPARE(QMetaType::fromName("quint32").id(), int(QMetaType::UInt));
QCOMPARE(QMetaType::type("qint64"), int(QMetaType::LongLong)); QCOMPARE(QMetaType::fromName("qint64").id(), int(QMetaType::LongLong));
QCOMPARE(QMetaType::type("quint64"), int(QMetaType::ULongLong)); QCOMPARE(QMetaType::fromName("quint64").id(), int(QMetaType::ULongLong));
// make sure the qreal typeId is the type id of the type it's defined to // 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"); qRegisterMetaType<CustomString>("CustomString");
QCOMPARE(QMetaType::type("CustomString"), ::qMetaTypeId<CustomString>()); QCOMPARE(QMetaType::fromName("CustomString").id(), ::qMetaTypeId<CustomString>());
typedef Whity<double> WhityDouble; typedef Whity<double> WhityDouble;
qRegisterMetaType<WhityDouble>("WhityDouble"); qRegisterMetaType<WhityDouble>("WhityDouble");
QCOMPARE(QMetaType::type("WhityDouble"), ::qMetaTypeId<WhityDouble>()); QCOMPARE(QMetaType::fromName("WhityDouble").id(), ::qMetaTypeId<WhityDouble>());
} }
struct RegisterTypeType {}; struct RegisterTypeType {};
@ -1536,7 +1614,7 @@ void tst_QMetaType::registerType()
QCOMPARE(qRegisterMetaType<MyString>("MyString"), int(QMetaType::QString)); QCOMPARE(qRegisterMetaType<MyString>("MyString"), int(QMetaType::QString));
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 // Alias to custom type
typedef CustomMovable MyMovable; typedef CustomMovable MyMovable;
@ -1545,12 +1623,12 @@ void tst_QMetaType::registerType()
QCOMPARE(qRegisterMetaType<MyMovable>("MyMovable"), movableId); QCOMPARE(qRegisterMetaType<MyMovable>("MyMovable"), movableId);
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(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 // this portion of the test can only be run once
static bool typeWasRegistered = false; static bool typeWasRegistered = false;
@ -1611,25 +1689,25 @@ Q_DECLARE_METATYPE(isEnumTest_Enum1)
void tst_QMetaType::isEnum() void tst_QMetaType::isEnum()
{ {
int type0 = qRegisterMetaType<int>("int"); 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"); 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"); 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 *"); 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"); 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>(); int type5 = ::qMetaTypeId<isEnumTest_Struct1>();
QVERIFY((QMetaType::typeFlags(type5) & QMetaType::IsEnumeration) == 0); QVERIFY((QMetaType(type5).flags() & QMetaType::IsEnumeration) == 0);
int type6 = ::qMetaTypeId<isEnumTest_Enum1>(); int type6 = ::qMetaTypeId<isEnumTest_Enum1>();
QVERIFY((QMetaType::typeFlags(type6) & QMetaType::IsEnumeration) == QMetaType::IsEnumeration); QVERIFY((QMetaType(type6).flags() & QMetaType::IsEnumeration) == QMetaType::IsEnumeration);
} }
void tst_QMetaType::isRegisteredStaticLess_data() void tst_QMetaType::isRegisteredStaticLess_data()
@ -1916,7 +1994,7 @@ void tst_QMetaType::automaticTemplateRegistration_1()
sp.data()->setObjectName("Test name"); \ sp.data()->setObjectName("Test name"); \
QVariant v = QVariant::fromValue(sp); \ QVariant v = QVariant::fromValue(sp); \
QCOMPARE(v.typeName(), #SMARTPOINTER "<" #ELEMENT_TYPE ">"); \ 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); \ SMARTPOINTER < QObject > extractedPtr = FROMVARIANTFUNCTION<QObject>(v); \
QCOMPARE(extractedPtr.data()->objectName(), sp.data()->objectName()); \ QCOMPARE(extractedPtr.data()->objectName(), sp.data()->objectName()); \
} }
@ -1934,7 +2012,7 @@ void tst_QMetaType::automaticTemplateRegistration_1()
sp.data()->setObjectName("Test name"); \ sp.data()->setObjectName("Test name"); \
QVariant v = QVariant::fromValue(sp); \ QVariant v = QVariant::fromValue(sp); \
QCOMPARE(v.typeName(), #SMARTPOINTER "<" #ELEMENT_TYPE ">"); \ 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); \ SMARTPOINTER < QObject > extractedPtr = FROMVARIANTFUNCTION<QObject>(v); \
QCOMPARE(extractedPtr.data()->objectName(), sp.data()->objectName()); \ QCOMPARE(extractedPtr.data()->objectName(), sp.data()->objectName()); \
} }
@ -1954,7 +2032,7 @@ void tst_QMetaType::automaticTemplateRegistration_1()
sp.toStrongRef()->setObjectName("Test name"); \ sp.toStrongRef()->setObjectName("Test name"); \
QVariant v = QVariant::fromValue(sp); \ QVariant v = QVariant::fromValue(sp); \
QCOMPARE(v.typeName(), "QWeakPointer<" #ELEMENT_TYPE ">"); \ 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) TEST_WEAK_SMARTPOINTER(QObject, WeakPointerToQObject)
@ -2007,38 +2085,39 @@ void tst_QMetaType::saveAndLoadBuiltin()
QFETCH(int, type); QFETCH(int, type);
QFETCH(bool, isStreamable); QFETCH(bool, isStreamable);
void *value = QMetaType::create(type); QMetaType metaType(type);
void *value = metaType.create();
QByteArray ba; QByteArray ba;
QDataStream stream(&ba, QIODevice::ReadWrite); QDataStream stream(&ba, QIODevice::ReadWrite);
QCOMPARE(QMetaType::save(stream, type, value), isStreamable); QCOMPARE(metaType.save(stream, value), isStreamable);
QCOMPARE(stream.status(), QDataStream::Ok); QCOMPARE(stream.status(), QDataStream::Ok);
if (isStreamable) { if (isStreamable) {
QVERIFY(QMetaType(type).hasRegisteredDataStreamOperators()); QVERIFY(metaType.hasRegisteredDataStreamOperators());
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 // std::nullptr_t is nullary: it doesn't actually read anything
if (type != QMetaType::Nullptr) if (type != QMetaType::Nullptr)
QCOMPARE(stream.status(), QDataStream::ReadPastEnd); QCOMPARE(stream.status(), QDataStream::ReadPastEnd);
} else { } else {
QVERIFY(!QMetaType(type).hasRegisteredDataStreamOperators()); QVERIFY(!metaType.hasRegisteredDataStreamOperators());
} }
stream.device()->seek(0); stream.device()->seek(0);
stream.resetStatus(); stream.resetStatus();
QCOMPARE(QMetaType::load(stream, type, value), isStreamable); QCOMPARE(metaType.load(stream, value), isStreamable);
QCOMPARE(stream.status(), QDataStream::Ok); QCOMPARE(stream.status(), QDataStream::Ok);
if (isStreamable) { 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 // std::nullptr_t is nullary: it doesn't actually read anything
if (type != QMetaType::Nullptr) if (type != QMetaType::Nullptr)
QCOMPARE(stream.status(), QDataStream::ReadPastEnd); QCOMPARE(stream.status(), QDataStream::ReadPastEnd);
} }
QMetaType::destroy(type, value); metaType.destroy(value);
} }
struct CustomStreamableType struct CustomStreamableType
@ -2067,25 +2146,27 @@ void tst_QMetaType::saveAndLoadCustom()
t.a = 123; t.a = 123;
int id = ::qMetaTypeId<CustomStreamableType>(); int id = ::qMetaTypeId<CustomStreamableType>();
QMetaType metaType(id);
QByteArray ba; QByteArray ba;
QDataStream stream(&ba, QIODevice::ReadWrite); QDataStream stream(&ba, QIODevice::ReadWrite);
QVERIFY(QMetaType::save(stream, id, &t)); QVERIFY(metaType.save(stream, &t));
QCOMPARE(stream.status(), QDataStream::Ok); QCOMPARE(stream.status(), QDataStream::Ok);
CustomStreamableType t2; CustomStreamableType t2;
t2.a = -1; 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(stream.status(), QDataStream::ReadPastEnd);
QCOMPARE(t2.a, -1); QCOMPARE(t2.a, -1);
stream.device()->seek(0); stream.device()->seek(0);
stream.resetStatus(); stream.resetStatus();
QVERIFY(QMetaType::load(stream, id, &t2)); QVERIFY(metaType.load(stream, &t2));
QCOMPARE(stream.status(), QDataStream::Ok); QCOMPARE(stream.status(), QDataStream::Ok);
QCOMPARE(t2.a, t.a); 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); QCOMPARE(stream.status(), QDataStream::ReadPastEnd);
} }
@ -2146,7 +2227,6 @@ void tst_QMetaType::metaObject()
QFETCH(bool, isGadgetPtr); QFETCH(bool, isGadgetPtr);
QFETCH(bool, isQObjectPtr); QFETCH(bool, isQObjectPtr);
QCOMPARE(QMetaType::metaObjectForType(type), result);
QMetaType mt(type); QMetaType mt(type);
QCOMPARE(mt.metaObject(), result); QCOMPARE(mt.metaObject(), result);
QCOMPARE(!!(mt.flags() & QMetaType::IsGadget), isGadget); QCOMPARE(!!(mt.flags() & QMetaType::IsGadget), isGadget);

10
tests/auto/corelib/kernel/qmetatype/tst_qmetatype.h
View File

@ -115,6 +115,14 @@ private slots:
void typesWithInaccessibleDTors(); void typesWithInaccessibleDTors();
void voidIsNotUnknown(); void voidIsNotUnknown();
void typeNameNormalization(); void typeNameNormalization();
// 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> template <typename T>
@ -262,7 +270,7 @@ Q_DECLARE_METATYPE(CustomMovable);
const QVariant v = QVariant::fromValue(t); \ const QVariant v = QVariant::fromValue(t); \
QByteArray tn = createTypeName(#CONTAINER "<", #__VA_ARGS__); \ QByteArray tn = createTypeName(#CONTAINER "<", #__VA_ARGS__); \
const int expectedType = ::qMetaTypeId<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(type, expectedType); \
QCOMPARE((QMetaType::fromType<CONTAINER< __VA_ARGS__ >>().id()), expectedType); \ QCOMPARE((QMetaType::fromType<CONTAINER< __VA_ARGS__ >>().id()), expectedType); \
} }

64
tests/auto/corelib/kernel/qmetatype/tst_qmetatype2.cpp
View File

@ -252,7 +252,7 @@ void tst_QMetaType::convertCustomType()
QFETCH(CustomConvertibleType, testCustom); QFETCH(CustomConvertibleType, testCustom);
v = QVariant::fromValue(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); QCOMPARE(v.value<CustomConvertibleType2>().m_foo, testCustom.m_foo);
QFETCH(DerivedGadgetType, testDerived); QFETCH(DerivedGadgetType, testDerived);
@ -601,6 +601,68 @@ void tst_QMetaType::typeNameNormalization()
} }
} }
#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 // Compile-time test, it should be possible to register function pointer types
class Undefined; class Undefined;