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

tst_qvariant: port away from deprecated methods

Browse Source 
The most common changes are:
* guard the tests for deprecated APIs with QT_DEPRECATED_SINCE
* QVariant(QVariant::Type) ctor -> QVariant(QMetaType) ctor
* QVariant::type() -> QVariant::typeId()
* QVariant::canConvert(int) -> QVariant::canConvert(QMetaType)
* QVariant::convert(int) -> QVariant::convert(QMetaType)
* QVariant::Type -> QMetaType::Type

Task-number: QTBUG-104858
Change-Id: I00584acb24d29b461faa1115f8f8d36a0b443883
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
This commit is contained in:
Ivan Solovev 2022-08-16 18:58:54 +02:00
parent 91eec59b87
commit ad12d779cc
2 changed files with 184 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -16,8 +16,6 @@ set(qvariant_resource_files
qt_internal_add_test(tst_qvariant
SOURCES
tst_qvariant.cpp
DEFINES
QT_DISABLE_DEPRECATED_UP_TO=0
INCLUDE_DIRECTORIES
../../../other/qvariant_common
LIBRARIES

334
tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
View File

@ -190,9 +190,11 @@ private slots:
void operator_eq_eq_data();
void operator_eq_eq();
#if QT_DEPRECATED_SINCE(6, 0)
void typeName_data();
void typeName();
void typeToName();
#endif
void streamInvalidVariant();
@ -247,8 +249,10 @@ private slots:
void forwardDeclare();
void debugStream_data();
void debugStream();
#if QT_DEPRECATED_SINCE(6, 0)
void debugStreamType_data();
void debugStreamType();
#endif
void loadQt4Stream_data();
void loadQt4Stream();
@ -316,22 +320,22 @@ void tst_QVariant::constructor()
QVariant varll2(varll);
QCOMPARE(varll2, varll);
QVariant var3(QVariant::String);
QVariant var3 {QMetaType::fromType<QString>()};
QCOMPARE(var3.typeName(), "QString");
QVERIFY(var3.isNull());
QVERIFY(var3.isValid());
QVariant var4(QVariant::Invalid);
QCOMPARE(var4.type(), QVariant::Invalid);
QVariant var4 {QMetaType()};
QCOMPARE(var4.typeId(), QMetaType::UnknownType);
QVERIFY(var4.isNull());
QVERIFY(!var4.isValid());
QVariant var5(QLatin1String("hallo"));
QCOMPARE(var5.type(), QVariant::String);
QCOMPARE(var5.typeId(), QMetaType::QString);
QCOMPARE(var5.typeName(), "QString");
QVariant var6(qlonglong(0));
QCOMPARE(var6.type(), QVariant::LongLong);
QCOMPARE(var6.typeId(), QMetaType::LongLong);
QCOMPARE(var6.typeName(), "qlonglong");
QVariant var7 = 5;
@ -360,10 +364,10 @@ void tst_QVariant::constructor_invalid()
QFETCH(uint, typeId);
{
QTest::ignoreMessage(QtWarningMsg, QRegularExpression("^Trying to construct an instance of an invalid type"));
QVariant variant(static_cast<QVariant::Type>(typeId));
QVariant variant {QMetaType(typeId)};
QVERIFY(!variant.isValid());
QVERIFY(variant.isNull());
QCOMPARE(int(variant.type()), int(QMetaType::UnknownType));
QCOMPARE(variant.typeId(), int(QMetaType::UnknownType));
QCOMPARE(variant.userType(), int(QMetaType::UnknownType));
}
{
@ -377,9 +381,9 @@ void tst_QVariant::constructor_invalid()
void tst_QVariant::copy_constructor()
{
QVariant var7(QVariant::Int);
QVariant var7 {QMetaType::fromType<int>()};
QVariant var8(var7);
QCOMPARE(var8.type(), QVariant::Int);
QCOMPARE(var8.typeId(), QMetaType::Int);
QVERIFY(var8.isNull());
}
@ -399,7 +403,7 @@ void tst_QVariant::isNull()
QVariant var3( QString( "blah" ) );
QVERIFY( !var3.isNull() );
var3 = QVariant(QVariant::String);
var3 = QVariant(QMetaType::fromType<QString>());
QVERIFY( var3.isNull() );
QVariant var4( 0 );
@ -412,12 +416,12 @@ void tst_QVariant::isNull()
QVERIFY( !var6.isNull() );
var6 = QVariant();
QVERIFY( var6.isNull() );
var6.convert( QVariant::String );
var6.convert(QMetaType::fromType<QString>());
QVERIFY( var6.isNull() );
QVariant varLL( (qlonglong)0 );
QVERIFY( !varLL.isNull() );
QVariant var8(QMetaType(QMetaType::Nullptr), nullptr);
QVariant var8(QMetaType::fromType<std::nullptr_t>(), nullptr);
QVERIFY(var8.isNull());
var8 = QVariant::fromValue<std::nullptr_t>(nullptr);
QVERIFY(var8.isNull());
@ -426,12 +430,12 @@ void tst_QVariant::isNull()
var9 = QVariant::fromValue<QJsonValue>(QJsonValue(QJsonValue::Null));
QVERIFY(!var9.isNull());
QVariant var10(QMetaType(QMetaType::VoidStar), nullptr);
QVariant var10(QMetaType::fromType<void*>(), nullptr);
QVERIFY(var10.isNull());
var10 = QVariant::fromValue<void*>(nullptr);
QVERIFY(var10.isNull());
QVariant var11(QMetaType(QMetaType::QObjectStar), nullptr);
QVariant var11(QMetaType::fromType<QObject*>(), nullptr);
QVERIFY(var11.isNull());
var11 = QVariant::fromValue<QObject*>(nullptr);
QVERIFY(var11.isNull());
@ -446,9 +450,9 @@ void tst_QVariant::swap()
{
QVariant v1 = 1, v2 = 2.0;
v1.swap(v2);
QCOMPARE(v1.type(),QVariant::Double);
QCOMPARE(v1.typeId(), QMetaType::Double);
QCOMPARE(v1.toDouble(),2.0);
QCOMPARE(v2.type(),QVariant::Int);
QCOMPARE(v2.typeId(), QMetaType::Int);
QCOMPARE(v2.toInt(),1);
}
@ -560,11 +564,15 @@ void tst_QVariant::canConvert()
TST_QVARIANT_CANCONVERT_COMPARE_DATA
#if QT_DEPRECATED_SINCE(6, 0)
QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED
// Invalid type ids
QCOMPARE(val.canConvert(-1), false);
QCOMPARE(val.canConvert(-23), false);
QCOMPARE(val.canConvert(-23876), false);
QCOMPARE(val.canConvert(23876), false);
QT_WARNING_POP
#endif // QT_DEPRECATED_SINCE(6, 0)
}
void tst_QVariant::convert()
@ -620,12 +628,19 @@ void tst_QVariant::toInt_data()
QTest::newRow("undefined-QJsonValue") << QVariant(QJsonValue(QJsonValue::Undefined)) << 0 << false;
}
#if QT_DEPRECATED_SINCE(6, 0)
# define EXEC_DEPRECATED_CALL(x) QT_IGNORE_DEPRECATIONS(x)
#else
# define EXEC_DEPRECATED_CALL(x)
#endif
void tst_QVariant::toInt()
{
QFETCH( QVariant, value );
QFETCH( int, result );
QFETCH( bool, valueOK );
QVERIFY( value.isValid() == value.canConvert( QVariant::Int ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.isValid() == value.canConvert( QVariant::Int ) );)
QVERIFY( value.isValid() == value.canConvert(QMetaType::fromType<int>()) );
bool ok;
int i = value.toInt( &ok );
QCOMPARE( i, result );
@ -674,7 +689,8 @@ void tst_QVariant::toUInt()
QFETCH( uint, result );
QFETCH( bool, valueOK );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::UInt ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::UInt ) );)
QVERIFY( value.canConvert(QMetaType::fromType<uint>()) );
bool ok;
uint i = value.toUInt( &ok );
@ -698,7 +714,8 @@ void tst_QVariant::toSize()
QFETCH( QVariant, value );
QFETCH( QSize, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Size ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::Size ) );)
QVERIFY( value.canConvert(QMetaType::fromType<QSize>()) );
QSize i = value.toSize();
QCOMPARE( i, result );
@ -719,7 +736,8 @@ void tst_QVariant::toSizeF()
QFETCH( QVariant, value );
QFETCH( QSizeF, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::SizeF ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::SizeF ) );)
QVERIFY( value.canConvert(QMetaType::fromType<QSizeF>()) );
QSizeF i = value.toSizeF();
QCOMPARE( i, result );
@ -740,7 +758,8 @@ void tst_QVariant::toLine()
QFETCH( QVariant, value );
QFETCH( QLine, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Line ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::Line ) );)
QVERIFY( value.canConvert(QMetaType::fromType<QLine>()) );
QLine i = value.toLine();
QCOMPARE( i, result );
@ -761,7 +780,8 @@ void tst_QVariant::toLineF()
QFETCH( QVariant, value );
QFETCH( QLineF, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::LineF ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::LineF ) );)
QVERIFY( value.canConvert(QMetaType::fromType<QLineF>()) );
QLineF i = value.toLineF();
QCOMPARE( i, result );
@ -783,7 +803,8 @@ void tst_QVariant::toPoint()
QFETCH( QVariant, value );
QFETCH( QPoint, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Point ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::Point ) );)
QVERIFY( value.canConvert(QMetaType::fromType<QPoint>()) );
QPoint i = value.toPoint();
QCOMPARE( i, result );
}
@ -804,7 +825,8 @@ void tst_QVariant::toRect()
QFETCH( QVariant, value );
QFETCH( QRect, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Rect ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::Rect ) );)
QVERIFY( value.canConvert(QMetaType::fromType<QRect>()) );
QRect i = value.toRect();
QCOMPARE( i, result );
}
@ -822,7 +844,8 @@ void tst_QVariant::toChar()
QFETCH( QVariant, value );
QFETCH( QChar, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Char ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::Char ) );)
QVERIFY( value.canConvert(QMetaType::fromType<QChar>()) );
QChar i = value.toChar();
QCOMPARE( i, result );
@ -860,7 +883,8 @@ void tst_QVariant::toBool()
QFETCH( QVariant, value );
QFETCH( bool, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Bool ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::Bool ) );)
QVERIFY( value.canConvert(QMetaType::fromType<bool>()) );
bool i = value.toBool();
QCOMPARE( i, result );
@ -879,7 +903,8 @@ void tst_QVariant::toPointF()
QFETCH( QVariant, value );
QFETCH( QPointF, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::PointF ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::PointF ) );)
QVERIFY( value.canConvert(QMetaType::fromType<QPointF>()) );
QPointF d = value.toPointF();
QCOMPARE( d, result );
}
@ -899,7 +924,8 @@ void tst_QVariant::toRectF()
QFETCH( QVariant, value );
QFETCH( QRectF, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::RectF ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::RectF ) );)
QVERIFY( value.canConvert(QMetaType::fromType<QRectF>()) );
QRectF d = value.toRectF();
QCOMPARE( d, result );
}
@ -926,7 +952,8 @@ void tst_QVariant::toDouble()
QFETCH( double, result );
QFETCH( bool, valueOK );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Double ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::Double ) );)
QVERIFY( value.canConvert(QMetaType::fromType<double>()) );
bool ok;
double d = value.toDouble( &ok );
QCOMPARE( d, result );
@ -955,7 +982,8 @@ void tst_QVariant::toFloat()
QFETCH(float, result);
QFETCH(bool, valueOK);
QVERIFY(value.isValid());
QVERIFY(value.canConvert(QMetaType::Float));
EXEC_DEPRECATED_CALL(QVERIFY(value.canConvert(QMetaType::Float));)
QVERIFY(value.canConvert(QMetaType::fromType<float>()));
bool ok;
float d = value.toFloat(&ok);
QCOMPARE(d, result);
@ -1006,7 +1034,8 @@ void tst_QVariant::toLongLong()
QFETCH( qlonglong, result );
QFETCH( bool, valueOK );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::LongLong ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::LongLong ) );)
QVERIFY( value.canConvert(QMetaType::fromType<qlonglong>()) );
bool ok;
qlonglong ll = value.toLongLong( &ok );
QCOMPARE( ll, result );
@ -1061,7 +1090,8 @@ void tst_QVariant::toULongLong()
QFETCH( qulonglong, result );
QFETCH( bool, valueOK );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::ULongLong ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::ULongLong ) );)
QVERIFY( value.canConvert(QMetaType::fromType<qulonglong>()) );
bool ok;
qulonglong ll = value.toULongLong( &ok );
QCOMPARE( ll, result );
@ -1101,12 +1131,13 @@ void tst_QVariant::toByteArray()
QFETCH( QVariant, value );
QFETCH( QByteArray, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::ByteArray ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::ByteArray ) );)
QVERIFY( value.canConvert(QMetaType::fromType<QByteArray>()) );
QByteArray ba = value.toByteArray();
QCOMPARE( ba.isNull(), result.isNull() );
QCOMPARE( ba, result );
QVERIFY( value.convert( QVariant::ByteArray ) );
QVERIFY( value.convert(QMetaType::fromType<QByteArray>()) );
QCOMPARE( value.toByteArray(), result );
}
@ -1143,12 +1174,13 @@ void tst_QVariant::toString()
QFETCH( QVariant, value );
QFETCH( QString, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::String ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::String ) );)
QVERIFY( value.canConvert(QMetaType::fromType<QString>()) );
QString str = value.toString();
QCOMPARE( str.isNull(), result.isNull() );
QCOMPARE( str, result );
QVERIFY( value.convert( QVariant::String ) );
QVERIFY( value.convert(QMetaType::fromType<QString>()) );
QCOMPARE( value.toString(), result );
}
@ -1167,7 +1199,8 @@ void tst_QVariant::toDate()
QFETCH( QVariant, value );
QFETCH( QDate, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Date ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::Date ) );)
QVERIFY( value.canConvert(QMetaType::fromType<QDate>()) );
QCOMPARE( value.toDate(), result );
}
@ -1187,7 +1220,8 @@ void tst_QVariant::toTime()
QFETCH( QVariant, value );
QFETCH( QTime, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Time ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::Time ) );)
QVERIFY( value.canConvert(QMetaType::fromType<QTime>()) );
QCOMPARE( value.toTime(), result );
}
@ -1211,10 +1245,13 @@ void tst_QVariant::toDateTime()
QFETCH( QVariant, value );
QFETCH( QDateTime, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::DateTime ) );
EXEC_DEPRECATED_CALL(QVERIFY( value.canConvert( QVariant::DateTime ) );)
QVERIFY( value.canConvert(QMetaType::fromType<QDateTime>()) );
QCOMPARE( value.toDateTime(), result );
}
#undef EXEC_DEPRECATED_CALL
void tst_QVariant::toLocale()
{
QVariant variant;
@ -1270,16 +1307,16 @@ void tst_QVariant::writeToReadFromDataStream_data()
}
QTest::newRow( "invalid" ) << QVariant() << true;
QTest::newRow( "bitarray_invalid" ) << QVariant(QVariant::BitArray) << true;
QTest::newRow( "bitarray_invalid" ) << QVariant(QMetaType::fromType<QBitArray>()) << true;
QTest::newRow( "bitarray_empty" ) << QVariant( QBitArray() ) << false;
QBitArray bitarray( 3 );
bitarray[0] = 0;
bitarray[1] = 1;
bitarray[2] = 0;
QTest::newRow( "bitarray_valid" ) << QVariant( bitarray ) << false;
QTest::newRow( "bytearray_invalid" ) << QVariant(QVariant::ByteArray) << true;
QTest::newRow( "bytearray_invalid" ) << QVariant(QMetaType::fromType<QByteArray>()) << true;
QTest::newRow( "bytearray_empty" ) << QVariant( QByteArray() ) << false;
QTest::newRow( "int_invalid") << QVariant(QVariant::Int) << true;
QTest::newRow( "int_invalid") << QVariant(QMetaType::fromType<int>()) << true;
QByteArray bytearray(5, ' ');
bytearray[0] = 'T';
bytearray[1] = 'e';
@ -1287,10 +1324,10 @@ void tst_QVariant::writeToReadFromDataStream_data()
bytearray[3] = 't';
bytearray[4] = '\0';
QTest::newRow( "bytearray_valid" ) << QVariant( bytearray ) << false;
QTest::newRow( "date_invalid" ) << QVariant(QVariant::Date) << true;
QTest::newRow( "date_invalid" ) << QVariant(QMetaType::fromType<QDate>()) << true;
QTest::newRow( "date_empty" ) << QVariant( QDate() ) << false;
QTest::newRow( "date_valid" ) << QVariant( QDate( 2002, 07, 06 ) ) << false;
QTest::newRow( "datetime_invalid" ) << QVariant(QVariant::DateTime) << true;
QTest::newRow( "datetime_invalid" ) << QVariant(QMetaType::fromType<QDateTime>()) << true;
QTest::newRow( "datetime_empty" ) << QVariant( QDateTime() ) << false;
QTest::newRow( "datetime_valid" ) << QVariant( QDateTime( QDate( 2002, 07, 06 ), QTime( 14, 0, 0 ) ) ) << false;
QTest::newRow( "double_valid" ) << QVariant( 123.456 ) << false;
@ -1302,22 +1339,22 @@ void tst_QVariant::writeToReadFromDataStream_data()
vMap.insert( "double", QVariant( 3.45 ) );
vMap.insert( "float", QVariant( 3.45f ) );
QTest::newRow( "map_valid" ) << QVariant( vMap ) << false;
QTest::newRow( "point_invalid" ) << QVariant(QVariant::Point) << true;
QTest::newRow( "point_invalid" ) << QVariant(QMetaType::fromType<QPoint>()) << true;
QTest::newRow( "point_empty" ) << QVariant::fromValue( QPoint() ) << false;
QTest::newRow( "point_valid" ) << QVariant::fromValue( QPoint( 10, 10 ) ) << false;
QTest::newRow( "rect_invalid" ) << QVariant(QVariant::Rect) << true;
QTest::newRow( "rect_invalid" ) << QVariant(QMetaType::fromType<QRect>()) << true;
QTest::newRow( "rect_empty" ) << QVariant( QRect() ) << false;
QTest::newRow( "rect_valid" ) << QVariant( QRect( 10, 10, 20, 20 ) ) << false;
QTest::newRow( "size_invalid" ) << QVariant(QVariant::Size) << true;
QTest::newRow( "size_invalid" ) << QVariant(QMetaType::fromType<QSize>()) << true;
QTest::newRow( "size_empty" ) << QVariant( QSize( 0, 0 ) ) << false;
QTest::newRow( "size_valid" ) << QVariant( QSize( 10, 10 ) ) << false;
QTest::newRow( "string_invalid" ) << QVariant(QVariant::String) << true;
QTest::newRow( "string_invalid" ) << QVariant(QMetaType::fromType<QString>()) << true;
QTest::newRow( "string_empty" ) << QVariant( QString() ) << false;
QTest::newRow( "string_valid" ) << QVariant( QString( "Test" ) ) << false;
QStringList stringlist;
stringlist << "One" << "Two" << "Three";
QTest::newRow( "stringlist_valid" ) << QVariant( stringlist ) << false;
QTest::newRow( "time_invalid" ) << QVariant(QVariant::Time) << true;
QTest::newRow( "time_invalid" ) << QVariant(QMetaType::fromType<QTime>()) << true;
QTest::newRow( "time_empty" ) << QVariant( QTime() ) << false;
QTest::newRow( "time_valid" ) << QVariant( QTime( 14, 0, 0 ) ) << false;
QTest::newRow( "uint_valid" ) << QVariant( (uint)123 ) << false;
@ -1327,27 +1364,27 @@ void tst_QVariant::writeToReadFromDataStream_data()
QTest::newRow( "regularexpression_empty" ) << QVariant(QRegularExpression()) << false;
// types known to QMetaType, but not part of QVariant::Type
QTest::newRow("QMetaType::Long invalid") << QVariant(QMetaType(QMetaType::Long), nullptr) << true;
QTest::newRow("QMetaType::Long invalid") << QVariant(QMetaType::fromType<long>(), nullptr) << true;
long longInt = -1l;
QTest::newRow("QMetaType::Long") << QVariant(QMetaType(QMetaType::Long), &longInt) << false;
QTest::newRow("QMetaType::Short invalid") << QVariant(QMetaType(QMetaType::Short), nullptr) << true;
QTest::newRow("QMetaType::Long") << QVariant(QMetaType::fromType<long>(), &longInt) << false;
QTest::newRow("QMetaType::Short invalid") << QVariant(QMetaType::fromType<short>(), nullptr) << true;
short shortInt = 1;
QTest::newRow("QMetaType::Short") << QVariant(QMetaType(QMetaType::Short), &shortInt) << false;
QTest::newRow("QMetaType::Char invalid") << QVariant(QMetaType(QMetaType::Char), nullptr) << true;
QTest::newRow("QMetaType::Short") << QVariant(QMetaType::fromType<short>(), &shortInt) << false;
QTest::newRow("QMetaType::Char invalid") << QVariant(QMetaType::fromType<QChar>(), nullptr) << true;
char ch = 'c';
QTest::newRow("QMetaType::Char") << QVariant(QMetaType(QMetaType::Char), &ch) << false;
QTest::newRow("QMetaType::ULong invalid") << QVariant(QMetaType(QMetaType::ULong), nullptr) << true;
QTest::newRow("QMetaType::Char") << QVariant(QMetaType::fromType<char>(), &ch) << false;
QTest::newRow("QMetaType::ULong invalid") << QVariant(QMetaType::fromType<ulong>(), nullptr) << true;
ulong ulongInt = 1ul;
QTest::newRow("QMetaType::ULong") << QVariant(QMetaType(QMetaType::ULong), &ulongInt) << false;
QTest::newRow("QMetaType::UShort invalid") << QVariant(QMetaType(QMetaType::UShort), nullptr) << true;
QTest::newRow("QMetaType::ULong") << QVariant(QMetaType::fromType<ulong>(), &ulongInt) << false;
QTest::newRow("QMetaType::UShort invalid") << QVariant(QMetaType::fromType<ushort>(), nullptr) << true;
ushort ushortInt = 1u;
QTest::newRow("QMetaType::UShort") << QVariant(QMetaType(QMetaType::UShort), &ushortInt) << false;
QTest::newRow("QMetaType::UChar invalid") << QVariant(QMetaType(QMetaType::UChar), nullptr) << true;
QTest::newRow("QMetaType::UShort") << QVariant(QMetaType::fromType<ushort>(), &ushortInt) << false;
QTest::newRow("QMetaType::UChar invalid") << QVariant(QMetaType::fromType<uchar>(), nullptr) << true;
uchar uch = 0xf0;
QTest::newRow("QMetaType::UChar") << QVariant(QMetaType(QMetaType::UChar), &uch) << false;
QTest::newRow("QMetaType::Float invalid") << QVariant(QMetaType(QMetaType::Float), nullptr) << true;
QTest::newRow("QMetaType::UChar") << QVariant(QMetaType::fromType<uchar>(), &uch) << false;
QTest::newRow("QMetaType::Float invalid") << QVariant(QMetaType::fromType<float>(), nullptr) << true;
float f = 1.234f;
QTest::newRow("QMetaType::Float") << QVariant(QMetaType(QMetaType::Float), &f) << false;
QTest::newRow("QMetaType::Float") << QVariant(QMetaType::fromType<float>(), &f) << false;
CustomStreamableClass custom = {123};
QTest::newRow("Custom type") << QVariant::fromValue(custom) << false;
}
@ -1369,10 +1406,11 @@ void tst_QVariant::writeToReadFromDataStream()
// Since only a few won't match since the serial numbers are different
// I won't bother adding another bool in the data test.
const int writeType = writeVariant.userType();
if (writeType == qMetaTypeId<CustomStreamableClass>())
QCOMPARE(qvariant_cast<CustomStreamableClass>(readVariant), qvariant_cast<CustomStreamableClass>(writeVariant));
else if ( writeType != QVariant::Invalid && writeType != QVariant::Bitmap && writeType != QVariant::Pixmap
&& writeType != QVariant::Image) {
if (writeType == qMetaTypeId<CustomStreamableClass>()) {
QCOMPARE(qvariant_cast<CustomStreamableClass>(readVariant),
qvariant_cast<CustomStreamableClass>(writeVariant));
} else if ( writeType != QMetaType::UnknownType && writeType != QMetaType::QBitmap
&& writeType != QMetaType::QPixmap && writeType != QMetaType::QImage) {
switch (writeType) {
default:
QCOMPARE( readVariant, writeVariant );
@ -1447,7 +1485,7 @@ void tst_QVariant::checkDataStream()
// constructed. However, it might be worth considering changing that behavior
// in the future.
// QCOMPARE(in.status(), QDataStream::ReadCorruptData);
QCOMPARE(v.type(), QVariant::Invalid);
QCOMPARE(v.typeId(), QMetaType::UnknownType);
}
void tst_QVariant::operator_eq_eq_data()
@ -1464,7 +1502,7 @@ void tst_QVariant::operator_eq_eq_data()
// Int
QTest::newRow( "int1int1" ) << i1 << i1 << true;
QTest::newRow( "int1int0" ) << i1 << i0 << false;
QTest::newRow( "nullint" ) << i0 << QVariant(QVariant::Int) << true;
QTest::newRow( "nullint" ) << i0 << QVariant(QMetaType::fromType<int>()) << true;
// LongLong and ULongLong
QVariant ll1( (qlonglong)1 );
@ -1708,6 +1746,8 @@ void tst_QVariant::operator_eq_eq()
QCOMPARE( left == right, equal );
}
#if QT_DEPRECATED_SINCE(6, 0)
QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED
void tst_QVariant::typeName_data()
{
QTest::addColumn<int>("type");
@ -1804,6 +1844,8 @@ void tst_QVariant::typeToName()
QCOMPARE(QVariant::nameToType("Q_LLONG"), QVariant::Invalid);
QCOMPARE(QVariant::nameToType("Q_ULLONG"), QVariant::Invalid);
}
QT_WARNING_POP
#endif // QT_DEPRECATED_SINCE(6, 0)
void tst_QVariant::streamInvalidVariant()
{
@ -1814,7 +1856,7 @@ void tst_QVariant::streamInvalidVariant()
QVariant writeVariant;
QVariant readVariant;
QVERIFY( writeVariant.type() == QVariant::Invalid );
QVERIFY( writeVariant.typeId() == QMetaType::UnknownType );
QByteArray data;
QDataStream writeStream( &data, QIODevice::WriteOnly );
@ -1826,7 +1868,7 @@ void tst_QVariant::streamInvalidVariant()
QVERIFY( readX == writeX );
// Two invalid QVariant's aren't necessarily the same, so == will
// return false if one is invalid, so check the type() instead
QVERIFY( readVariant.type() == QVariant::Invalid );
QVERIFY( readVariant.typeId() == QMetaType::UnknownType );
QVERIFY( readY == writeY );
}
@ -1872,7 +1914,7 @@ void tst_QVariant::userType()
QVariant userVar;
userVar.setValue(data);
QCOMPARE(userVar.type(), QVariant::UserType);
QVERIFY(userVar.typeId() > QMetaType::User);
QCOMPARE(userVar.userType(), qMetaTypeId<MyType>());
QCOMPARE(userVar.typeName(), "MyType");
QVERIFY(!userVar.isNull());
@ -1901,7 +1943,7 @@ void tst_QVariant::userType()
QVariant userVar;
userVar.setValue(&data);
QCOMPARE(userVar.type(), QVariant::UserType);
QVERIFY(userVar.typeId() > QMetaType::User);
QCOMPARE(userVar.userType(), qMetaTypeId<MyType*>());
QCOMPARE(userVar.typeName(), "MyType*");
QVERIFY(!userVar.isNull());
@ -2013,37 +2055,37 @@ void tst_QVariant::basicUserType()
QVariant v;
{
int i = 7;
v = QVariant(QMetaType(QMetaType::Int), &i);
v = QVariant(QMetaType::fromType<int>(), &i);
}
QCOMPARE(v.type(), QVariant::Int);
QCOMPARE(v.typeId(), QMetaType::Int);
QCOMPARE(v.toInt(), 7);
{
QString s("foo");
v = QVariant(QMetaType(QMetaType::QString), &s);
v = QVariant(QMetaType::fromType<QString>(), &s);
}
QCOMPARE(v.type(), QVariant::String);
QCOMPARE(v.typeId(), QMetaType::QString);
QCOMPARE(v.toString(), QString("foo"));
{
double d = 4.4;
v = QVariant(QMetaType(QMetaType::Double), &d);
v = QVariant(QMetaType::fromType<double>(), &d);
}
QCOMPARE(v.type(), QVariant::Double);
QCOMPARE(v.typeId(), QMetaType::Double);
QCOMPARE(v.toDouble(), 4.4);
{
float f = 4.5f;
v = QVariant(QMetaType(QMetaType::Float), &f);
v = QVariant(QMetaType::fromType<float>(), &f);
}
QCOMPARE(v.userType(), int(QMetaType::Float));
QCOMPARE(v.toDouble(), 4.5);
{
QByteArray ba("bar");
v = QVariant(QMetaType(QMetaType::QByteArray), &ba);
v = QVariant(QMetaType::fromType<QByteArray>(), &ba);
}
QCOMPARE(v.type(), QVariant::ByteArray);
QCOMPARE(v.typeId(), QMetaType::QByteArray);
QCOMPARE(v.toByteArray(), QByteArray("bar"));
}
@ -2208,7 +2250,7 @@ void tst_QVariant::saveLoadCustomTypes()
QVariant v = QVariant(tp, &i);
QCOMPARE(v.userType(), tp.id());
QCOMPARE(v.type(), QVariant::UserType);
QVERIFY(v.typeId() > QMetaType::User);
{
QDataStream stream(&data, QIODevice::WriteOnly);
stream << v;
@ -2221,7 +2263,7 @@ void tst_QVariant::saveLoadCustomTypes()
stream >> v;
}
QCOMPARE(int(v.userType()), QMetaType::type("Blah"));
QCOMPARE(int(v.userType()), QMetaType::fromName("Blah").id());
int value = *(int*)v.constData();
QCOMPARE(value, 42);
}
@ -2320,7 +2362,7 @@ void tst_QVariant::qvariant_cast_QObject_data()
QTest::addColumn<bool>("isNull");
QObject *obj = new QObject;
obj->setObjectName(QString::fromLatin1("Hello"));
QTest::newRow("from QObject") << QVariant(QMetaType(QMetaType::QObjectStar), &obj) << true << false;
QTest::newRow("from QObject") << QVariant(QMetaType::fromType<QObject*>(), &obj) << true << false;
QTest::newRow("from QObject2") << QVariant::fromValue(obj) << true << false;
QTest::newRow("from String") << QVariant(QLatin1String("1, 2, 3")) << false << false;
QTest::newRow("from int") << QVariant((int) 123) << false << false;
@ -2355,18 +2397,18 @@ void tst_QVariant::qvariant_cast_QObject()
if (!isNull)
QCOMPARE(o->objectName(), QString::fromLatin1("Hello"));
QVERIFY(data.canConvert<QObject*>());
QVERIFY(data.canConvert(QMetaType::QObjectStar));
QVERIFY(data.canConvert(::qMetaTypeId<QObject*>()));
QVERIFY(data.canConvert(QMetaType::fromType<QObject*>()));
QVERIFY(data.canConvert(QMetaType(::qMetaTypeId<QObject*>())));
QCOMPARE(data.value<QObject*>() == nullptr, isNull);
QVERIFY(data.convert(QMetaType::QObjectStar));
QVERIFY(data.convert(QMetaType::fromType<QObject*>()));
QCOMPARE(data.userType(), int(QMetaType::QObjectStar));
} else {
QVERIFY(!data.canConvert<QObject*>());
QVERIFY(!data.canConvert(QMetaType::QObjectStar));
QVERIFY(!data.canConvert(::qMetaTypeId<QObject*>()));
QVERIFY(!data.canConvert(QMetaType::fromType<QObject*>()));
QVERIFY(!data.canConvert(QMetaType(::qMetaTypeId<QObject*>())));
QVERIFY(!data.value<QObject*>());
QVERIFY(data.userType() != QMetaType::QObjectStar);
QVERIFY(!data.convert(QMetaType::QObjectStar));
QVERIFY(!data.convert(QMetaType::fromType<QObject*>()));
}
}
@ -2407,7 +2449,7 @@ void tst_QVariant::qvariant_cast_QObject_derived()
QObject *object = new CustomQObjectDerivedNoMetaType(this);
QVariant data = QVariant::fromValue(object);
QVERIFY(data.canConvert<CustomQObjectDerivedNoMetaType*>());
QVERIFY(data.convert(qMetaTypeId<CustomQObjectDerivedNoMetaType*>()));
QVERIFY(data.convert(QMetaType(qMetaTypeId<CustomQObjectDerivedNoMetaType*>())));
QCOMPARE(data.value<CustomQObjectDerivedNoMetaType*>(), object);
QCOMPARE(data.isNull(), false);
}
@ -2487,7 +2529,7 @@ void tst_QVariant::qvariant_cast_QObject_wrapper()
QObjectWrapper wrapper(object);
QVariant v = QVariant::fromValue(wrapper);
QCOMPARE(v.value<QObject*>(), object);
v.convert(qMetaTypeId<QObject*>());
v.convert(QMetaType(qMetaTypeId<QObject*>()));
QCOMPARE(v.value<QObject*>(), object);
MyNS::SequentialContainer<int> sc;
@ -2786,7 +2828,7 @@ void tst_QVariant::variantToDateTimeWithoutWarnings() const
{
QVariant v1(QLatin1String("xyz"));
v1.convert(QVariant::DateTime);
v1.convert(QMetaType::fromType<QDateTime>());
QVariant v2(QLatin1String("xyz"));
QDateTime dt1(v2.toDateTime());
@ -2800,7 +2842,7 @@ void tst_QVariant::invalidDateTime() const
{
QVariant variant(QString::fromLatin1("Invalid date time string"));
QVERIFY(!variant.toDateTime().isValid());
QVERIFY(!variant.convert(QVariant::DateTime));
QVERIFY(!variant.convert(QMetaType::fromType<QDateTime>()));
}
struct MyClass
@ -2841,22 +2883,22 @@ void tst_QVariant::invalidDate() const
{
QString foo("Hello");
QVariant variant(foo);
QVERIFY(!variant.convert(QVariant::Date));
QVERIFY(!variant.convert(QMetaType::fromType<QDate>()));
variant = foo;
QVERIFY(!variant.convert(QVariant::DateTime));
QVERIFY(!variant.convert(QMetaType::fromType<QDateTime>()));
variant = foo;
QVERIFY(!variant.convert(QVariant::Time));
QVERIFY(!variant.convert(QMetaType::fromType<QTime>()));
variant = foo;
QVERIFY(!variant.convert(QVariant::Int));
QVERIFY(!variant.convert(QMetaType::fromType<int>()));
variant = foo;
QVERIFY(!variant.convert(QVariant::Double));
QVERIFY(!variant.convert(QMetaType::fromType<double>()));
variant = foo;
QVERIFY(!variant.convert(QVariant::Type(QMetaType::Float)));
QVERIFY(!variant.convert(QMetaType::fromType<float>()));
}
struct WontCompare
@ -3040,7 +3082,7 @@ void tst_QVariant::convertByteArrayToBool() const
QFETCH(QByteArray, output);
const QVariant variant(input);
QCOMPARE(variant.type(), QVariant::Bool);
QCOMPARE(variant.typeId(), QMetaType::Bool);
QCOMPARE(variant.toBool(), input);
QVERIFY(variant.canConvert<bool>());
@ -3208,13 +3250,13 @@ void tst_QVariant::fpStringRoundtrip() const
QFETCH(QVariant, number);
QVariant converted = number;
QVERIFY(converted.convert(QVariant::String));
QVERIFY(converted.convert(number.type()));
QVERIFY(converted.convert(QMetaType::fromType<QString>()));
QVERIFY(converted.convert(QMetaType(number.typeId())));
QCOMPARE(converted, number);
converted = number;
QVERIFY(converted.convert(QVariant::ByteArray));
QVERIFY(converted.convert(number.type()));
QVERIFY(converted.convert(QMetaType::fromType<QByteArray>()));
QVERIFY(converted.convert(QMetaType(number.typeId())));
QCOMPARE(converted, number);
}
@ -3252,7 +3294,7 @@ void tst_QVariant::numericalConvert()
}
switch (v.userType())
{
case QVariant::Double:
case QMetaType::Double:
QCOMPARE(v.toString() , QString::number(num, 'g', QLocale::FloatingPointShortest));
break;
case QMetaType::Float:
@ -3317,10 +3359,8 @@ template<class T> void playWithVariant(const T &orig, bool isNull, const QString
QCOMPARE(v.toBool(), toBool);
QCOMPARE(qvariant_cast<T>(v), orig);
if (qMetaTypeId<T>() != qMetaTypeId<QVariant>()) {
if (qMetaTypeId<T>() != qMetaTypeId<QVariant>())
QCOMPARE(v.userType(), qMetaTypeId<T>());
QCOMPARE(QVariant::typeToName(QVariant::Type(v.userType())), QMetaType::typeName(qMetaTypeId<T>()));
}
}
#define PLAY_WITH_VARIANT(Orig, IsNull, ToString, ToDouble, ToBool) \
@ -3598,11 +3638,11 @@ void tst_QVariant::movabilityTest()
// prepare destination memory space to which variant will be moved
QVariant buffer[1];
QCOMPARE(buffer[0].type(), QVariant::Invalid);
QCOMPARE(buffer[0].typeId(), QMetaType::UnknownType);
buffer[0].~QVariant();
memcpy(static_cast<void *>(buffer), static_cast<void *>(&variant), sizeof(QVariant));
QCOMPARE(buffer[0].type(), QVariant::UserType);
QVERIFY(buffer[0].typeId() > QMetaType::User);
QCOMPARE(buffer[0].userType(), qMetaTypeId<MyNotMovable>());
MyNotMovable tmp(buffer[0].value<MyNotMovable>());
@ -3614,24 +3654,24 @@ void tst_QVariant::movabilityTest()
void tst_QVariant::variantInVariant()
{
QVariant var1 = 5;
QCOMPARE(var1.type(), QVariant::Int);
QCOMPARE(var1.typeId(), QMetaType::Int);
QVariant var2 = var1;
QCOMPARE(var2, var1);
QCOMPARE(var2.type(), QVariant::Int);
QCOMPARE(var2.typeId(), QMetaType::Int);
QVariant var3 = QVariant::fromValue(var1);
QCOMPARE(var3, var1);
QCOMPARE(var3.type(), QVariant::Int);
QCOMPARE(var3.typeId(), QMetaType::Int);
QVariant var4 = qvariant_cast<QVariant>(var1);
QCOMPARE(var4, var1);
QCOMPARE(var4.type(), QVariant::Int);
QCOMPARE(var4.typeId(), QMetaType::Int);
QVariant var5;
var5 = var1;
QCOMPARE(var5, var1);
QCOMPARE(var5.type(), QVariant::Int);
QCOMPARE(var5.typeId(), QMetaType::Int);
QVariant var6;
var6.setValue(var1);
QCOMPARE(var6, var1);
QCOMPARE(var6.type(), QVariant::Int);
QCOMPARE(var6.typeId(), QMetaType::Int);
QCOMPARE(QVariant::fromValue(var1), QVariant::fromValue(var2));
QCOMPARE(qvariant_cast<QVariant>(var3), QVariant::fromValue(var4));
@ -3639,7 +3679,7 @@ void tst_QVariant::variantInVariant()
QString str("hello");
QVariant var8 = qvariant_cast<QVariant>(QVariant::fromValue(QVariant::fromValue(str)));
QCOMPARE((int)var8.type(), (int)QVariant::String);
QCOMPARE(var8.typeId(), QMetaType::QString);
QCOMPARE(qvariant_cast<QString>(QVariant(qvariant_cast<QVariant>(var8))), str);
QVariant var9(QMetaType::fromType<QVariant>(), &var1);
@ -3742,11 +3782,11 @@ void tst_QVariant::modelIndexConversion()
{
QVariant modelIndexVariant = QModelIndex();
QVERIFY(modelIndexVariant.canConvert<QPersistentModelIndex>());
QVERIFY(modelIndexVariant.convert(QMetaType::QPersistentModelIndex));
QCOMPARE(modelIndexVariant.type(), QVariant::PersistentModelIndex);
QVERIFY(modelIndexVariant.canConvert(QMetaType::QModelIndex));
QVERIFY(modelIndexVariant.convert(QMetaType::QModelIndex));
QCOMPARE(modelIndexVariant.type(), QVariant::ModelIndex);
QVERIFY(modelIndexVariant.convert(QMetaType::fromType<QPersistentModelIndex>()));
QCOMPARE(modelIndexVariant.typeId(), QMetaType::QPersistentModelIndex);
QVERIFY(modelIndexVariant.canConvert(QMetaType::fromType<QModelIndex>()));
QVERIFY(modelIndexVariant.convert(QMetaType::fromType<QModelIndex>()));
QCOMPARE(modelIndexVariant.typeId(), QMetaType::QModelIndex);
}
class Forward;
@ -3840,15 +3880,15 @@ void tst_QVariant::loadQVariantFromDataStream(QDataStream::Version version)
QVariant loadedVariant;
stream >> typeName >> loadedVariant;
const int id = QMetaType::type(typeName.toLatin1());
const int id = QMetaType::fromName(typeName.toLatin1()).id();
if (id == QMetaType::Void) {
// Void type is not supported by QVariant
return;
}
QVariant constructedVariant(static_cast<QVariant::Type>(id));
QVariant constructedVariant {QMetaType(id)};
QCOMPARE(constructedVariant.userType(), id);
QCOMPARE(QMetaType::typeName(loadedVariant.userType()), typeName.toLatin1().constData());
QCOMPARE(QMetaType(loadedVariant.userType()).name(), typeName.toLatin1().constData());
QCOMPARE(loadedVariant.userType(), constructedVariant.userType());
}
@ -3863,7 +3903,7 @@ void tst_QVariant::saveQVariantFromDataStream(QDataStream::Version version)
QString typeName;
dataFileStream >> typeName;
QByteArray data = file.readAll();
const int id = QMetaType::type(typeName.toLatin1());
const int id = QMetaType::fromName(typeName.toLatin1()).id();
if (id == QMetaType::Void) {
// Void type is not supported by QVariant
return;
@ -3874,7 +3914,7 @@ void tst_QVariant::saveQVariantFromDataStream(QDataStream::Version version)
QDataStream stream(&buffer);
stream.setVersion(version);
QVariant constructedVariant(static_cast<QVariant::Type>(id));
QVariant constructedVariant {QMetaType(id)};
QCOMPARE(constructedVariant.userType(), id);
stream << constructedVariant;
@ -3892,11 +3932,11 @@ void tst_QVariant::debugStream_data()
QTest::addColumn<QVariant>("variant");
QTest::addColumn<int>("typeId");
for (int id = 0; id < QMetaType::LastCoreType + 1; ++id) {
const char *tagName = QMetaType::typeName(id);
const char *tagName = QMetaType(id).name();
if (!tagName)
continue;
if (id != QMetaType::Void) {
QTest::newRow(tagName) << QVariant(static_cast<QVariant::Type>(id)) << id;
QTest::newRow(tagName) << QVariant(QMetaType(id)) << id;
}
}
QTest::newRow("QBitArray(111)") << QVariant(QBitArray(3, true)) << qMetaTypeId<QBitArray>();
@ -3916,6 +3956,7 @@ void tst_QVariant::debugStream()
QVERIFY(msgHandler.testPassed());
}
#if QT_DEPRECATED_SINCE(6, 0)
struct MessageHandlerType : public MessageHandler
{
MessageHandlerType(const int typeId)
@ -3926,9 +3967,11 @@ struct MessageHandlerType : public MessageHandler
// Format itself is not important, but basic data as a type name should be included in the output
ok = msg.startsWith("QVariant::");
QVERIFY2(ok, (QString::fromLatin1("Message is not started correctly: '") + msg + '\'').toLatin1().constData());
QT_WARNING_PUSH QT_WARNING_DISABLE_DEPRECATED
ok &= (currentId == QMetaType::UnknownType
? msg.contains("Invalid")
: msg.contains(QMetaType::typeName(currentId)));
QT_WARNING_POP
QVERIFY2(ok, (QString::fromLatin1("Message doesn't contain type name: '") + msg + '\'').toLatin1().constData());
}
};
@ -3944,9 +3987,10 @@ void tst_QVariant::debugStreamType()
QFETCH(int, typeId);
MessageHandlerType msgHandler(typeId);
qDebug() << QVariant::Type(typeId);
QT_IGNORE_DEPRECATIONS(qDebug() << QVariant::Type(typeId);)
QVERIFY(msgHandler.testPassed());
}
#endif // QT_DEPRECATED_SINCE(6, 0)
void tst_QVariant::implicitConstruction()
{
@ -4278,16 +4322,6 @@ void testSequentialIteration()
QCOMPARE(numSeen, (int)std::distance(sequence.begin(), sequence.end()));
QCOMPARE(containerIter, containerEnd);
containerIter = sequence.begin();
numSeen = 0;
Q_FOREACH (const QVariant &v, listIter) {
QVERIFY(ContainerAPI<Container>::compare(v, *containerIter));
QVERIFY(ContainerAPI<Container>::compare(v, varList.at(numSeen)));
++containerIter;
++numSeen;
}
QCOMPARE(numSeen, (int)std::distance(sequence.begin(), sequence.end()));
numSeen = 0;
containerIter = sequence.begin();
for (QVariant v : listIter) {
@ -4622,7 +4656,7 @@ template<typename Enum> void testVariant(Enum value, bool *ok)
QCOMPARE(var.value<quint64>(), static_cast<quint64>(value));
QVariant var2 = var;
QVERIFY(var2.convert(QMetaType::Int));
QVERIFY(var2.convert(QMetaType::fromType<int>()));
QCOMPARE(var2.value<int>(), static_cast<int>(value));
// unary + to silence gcc warning
@ -4724,12 +4758,12 @@ void tst_QVariant::metaEnums()
void tst_QVariant::nullConvert()
{
// null variant with no initialized value
QVariant nullVar(QVariant::String);
QVariant nullVar {QMetaType::fromType<QString>()};
QVERIFY(nullVar.isValid());
QVERIFY(nullVar.isNull());
// We can not convert a variant with no value
QVERIFY(!nullVar.convert(QVariant::Url));
QCOMPARE(nullVar.type(), QVariant::Url);
QVERIFY(!nullVar.convert(QMetaType::fromType<QUrl>()));
QCOMPARE(nullVar.typeId(), QMetaType::QUrl);
QVERIFY(nullVar.isNull());
}
@ -4870,12 +4904,12 @@ void tst_QVariant::fromStdVariant()
intorbool_t stdvar = 5;
QVariant qvar = QVariant::fromStdVariant(stdvar);
QVERIFY(!qvar.isNull());
QCOMPARE(qvar.type(), QVariant::Int);
QCOMPARE(qvar.typeId(), QMetaType::Int);
QCOMPARE(qvar.value<int>(), std::get<int>(stdvar));
stdvar = true;
qvar = QVariant::fromStdVariant(stdvar);
QVERIFY(!qvar.isNull());
QCOMPARE(qvar.type(), QVariant::Bool);
QCOMPARE(qvar.typeId(), QMetaType::Bool);
QCOMPARE(qvar.value<bool>(), std::get<bool>(stdvar));
}
{
@ -4885,14 +4919,14 @@ void tst_QVariant::fromStdVariant()
stdvar = -4;
qvar = QVariant::fromStdVariant(stdvar);
QVERIFY(!qvar.isNull());
QCOMPARE(qvar.type(), QVariant::Int);
QCOMPARE(qvar.typeId(), QMetaType::Int);
QCOMPARE(qvar.value<int>(), std::get<int>(stdvar));
}
{
std::variant<int, bool, QChar> stdvar = QChar::fromLatin1(' ');
QVariant qvar = QVariant::fromStdVariant(stdvar);
QVERIFY(!qvar.isNull());
QCOMPARE(qvar.type(), QVariant::Char);
QCOMPARE(qvar.typeId(), QMetaType::QChar);
QCOMPARE(qvar.value<QChar>(), std::get<QChar>(stdvar));
}
}