#include <qvariant.h>
#include <qbitarray.h>
-#include <qhostaddress.h>
#include <qdatetime.h>
#include <qmap.h>
#include <qiodevice.h>
#include <limits.h>
-Q_DECLARE_METATYPE(qlonglong)
-Q_DECLARE_METATYPE(qulonglong)
-Q_DECLARE_METATYPE(QPointF)
-Q_DECLARE_METATYPE(QRectF)
-Q_DECLARE_METATYPE(QSize)
-Q_DECLARE_METATYPE(QSizeF)
-Q_DECLARE_METATYPE(QLine)
-Q_DECLARE_METATYPE(QLineF)
-Q_DECLARE_METATYPE(QPoint)
-Q_DECLARE_METATYPE(QRect)
-Q_DECLARE_METATYPE(QPixmap)
-Q_DECLARE_METATYPE(QBrush)
-Q_DECLARE_METATYPE(QFont)
-Q_DECLARE_METATYPE(QColor)
-Q_DECLARE_METATYPE(QKeySequence)
+#include <QLinkedList>
+#include <QRegularExpression>
+#include <QDir>
+#include <QBuffer>
+#include <QFont>
+#include "qnumeric.h"
+
+#include "tst_qvariant_common.h"
class CustomNonQObject;
void constructor();
void copy_constructor();
+ void constructor_invalid_data();
+ void constructor_invalid();
void isNull();
void swap();
void saveLoadCustomTypes();
- void globalColor();
-
void variantMap();
void variantHash();
void saveQt5Stream();
void guiVariantAtExit();
- void widgetsVariantAtExit();
private:
void dataStream_data(QDataStream::Version version);
void loadQVariantFromDataStream(QDataStream::Version version);
QVector<QObject*> objectPointerTestData;
};
-Q_DECLARE_METATYPE(QDate)
-Q_DECLARE_METATYPE(QTime)
-Q_DECLARE_METATYPE(QDateTime)
-Q_DECLARE_METATYPE(QVariant)
-
const qlonglong intMax1 = (qlonglong)INT_MAX + 1;
const qulonglong uintMax1 = (qulonglong)UINT_MAX + 1;
QVERIFY(!var8.isNull());
}
+void tst_QVariant::constructor_invalid_data()
+{
+ QTest::addColumn<uint>("typeId");
+
+ QTest::newRow("-1") << uint(-1);
+ QTest::newRow("-122234567") << uint(-122234567);
+ QTest::newRow("0xfffffffff") << uint(0xfffffffff);
+ QTest::newRow("LastCoreType + 1") << uint(QMetaType::LastCoreType + 1);
+ QVERIFY(!QMetaType::isRegistered(QMetaType::LastCoreType + 1));
+}
+
+void tst_QVariant::constructor_invalid()
+{
+
+ QFETCH(uint, typeId);
+ {
+ MessageHandlerInvalidType msg;
+ QVariant variant(static_cast<QVariant::Type>(typeId));
+ QVERIFY(!variant.isValid());
+ QVERIFY(variant.userType() == QMetaType::UnknownType);
+ QVERIFY(msg.ok);
+ }
+ {
+ MessageHandlerInvalidType msg;
+ QVariant variant(typeId, /* copy */ 0);
+ QVERIFY(!variant.isValid());
+ QVERIFY(variant.userType() == QMetaType::UnknownType);
+ QVERIFY(msg.ok);
+ }
+}
+
void tst_QVariant::copy_constructor()
{
QVariant var7(QVariant::Int);
void tst_QVariant::canConvert_data()
{
- QTest::addColumn<QVariant>("val");
- QTest::addColumn<bool>("BitArrayCast");
- QTest::addColumn<bool>("BitmapCast");
- QTest::addColumn<bool>("BoolCast");
- QTest::addColumn<bool>("BrushCast");
- QTest::addColumn<bool>("ByteArrayCast");
- QTest::addColumn<bool>("ColorCast");
- QTest::addColumn<bool>("CursorCast");
- QTest::addColumn<bool>("DateCast");
- QTest::addColumn<bool>("DateTimeCast");
- QTest::addColumn<bool>("DoubleCast");
- QTest::addColumn<bool>("FontCast");
- QTest::addColumn<bool>("ImageCast");
- QTest::addColumn<bool>("IntCast");
- QTest::addColumn<bool>("InvalidCast");
- QTest::addColumn<bool>("KeySequenceCast");
- QTest::addColumn<bool>("ListCast");
- QTest::addColumn<bool>("LongLongCast");
- QTest::addColumn<bool>("MapCast");
- QTest::addColumn<bool>("PaletteCast");
- QTest::addColumn<bool>("PenCast");
- QTest::addColumn<bool>("PixmapCast");
- QTest::addColumn<bool>("PointCast");
- QTest::addColumn<bool>("RectCast");
- QTest::addColumn<bool>("RegionCast");
- QTest::addColumn<bool>("SizeCast");
- QTest::addColumn<bool>("SizePolicyCast");
- QTest::addColumn<bool>("StringCast");
- QTest::addColumn<bool>("StringListCast");
- QTest::addColumn<bool>("TimeCast");
- QTest::addColumn<bool>("UIntCast");
- QTest::addColumn<bool>("ULongLongCast");
+ TST_QVARIANT_CANCONVERT_DATATABLE_HEADERS
#ifdef Y
QVariant var(QBitArray(0));
QTest::newRow("BitArray")
<< var << Y << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N;
- var = qVariantFromValue(QBitmap());
+ var = QVariant::fromValue(QBitmap());
QTest::newRow("Bitmap")
<< var << N << Y << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N;
- var = qVariantFromValue(QBrush());
+ var = QVariant::fromValue(QBrush());
QTest::newRow("Brush")
<< var << N << N << N << Y << N << Y << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N;
var = QVariant(QByteArray());
QTest::newRow("ByteArray")
<< var << N << N << Y << N << Y << Y << N << N << N << Y << N << N << Y << N << N << N << Y << N << N << N << N << N << N << N << N << N << Y << N << N << Y << Y;
- var = qVariantFromValue(QColor());
+ var = QVariant::fromValue(QColor());
QTest::newRow("Color")
<< var << N << N << N << Y << Y << Y << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N;
#ifndef QT_NO_CURSOR
- var = qVariantFromValue(QCursor());
+ var = QVariant::fromValue(QCursor());
QTest::newRow("Cursor")
<< var << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N;
#endif
var = QVariant(0.1f);
QTest::newRow("Float")
<< var << N << N << Y << N << Y << N << N << N << N << Y << N << N << Y << N << N << N << Y << N << N << N << N << N << N << N << N << N << Y << N << N << Y << Y;
- var = qVariantFromValue(QFont());
+ var = QVariant::fromValue(QFont());
QTest::newRow("Font")
<< var << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N;
- var = qVariantFromValue(QIcon());
+ var = QVariant::fromValue(QIcon());
QTest::newRow("Icon")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N;
- var = qVariantFromValue(QImage());
+ var = QVariant::fromValue(QImage());
QTest::newRow("Image")
<< var << N << Y << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N;
var = QVariant((int)1);
var = QVariant();
QTest::newRow("Invalid")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N;
- var = qVariantFromValue(QKeySequence());
+ var = QVariant::fromValue(QKeySequence());
QTest::newRow("KeySequence")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << Y << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N;
var = QVariant(QList<QVariant>());
var = QVariant(QMap<QString,QVariant>());
QTest::newRow("Map")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N << N << N << N;
- var = qVariantFromValue(QPalette());
+ var = QVariant::fromValue(QPalette());
QTest::newRow("Palette")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N << N << N;
- var = qVariantFromValue(QPen());
+ var = QVariant::fromValue(QPen());
QTest::newRow("Pen")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N << N;
- var = qVariantFromValue(QPixmap());
+ var = QVariant::fromValue(QPixmap());
QTest::newRow("Pixmap")
<< var << N << Y << N << Y << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N << N << N;
- var = qVariantFromValue(QPolygon());
+ var = QVariant::fromValue(QPolygon());
QTest::newRow("PointArray")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N;
var = QVariant(QPoint());
var = QVariant(QRect());
QTest::newRow("Rect")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N << N;
- var = qVariantFromValue(QRegion());
+ var = QVariant::fromValue(QRegion());
QTest::newRow("Region")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N << N;
var = QVariant(QSize());
QTest::newRow("Size")
<< var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N << N;
- var = qVariantFromValue(QSizePolicy());
- QTest::newRow("SizePolicy")
- << var << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << N << Y << N << N << N << N << N;
var = QVariant(QString());
QTest::newRow("String")
<< var << N << N << Y << N << Y << Y << N << Y << Y << Y << Y << N << Y << N << Y << N << Y << N << N << N << N << N << N << N << N << N << Y << Y << Y << Y << Y;
var = QVariant((uint)1);
QTest::newRow("UInt")
<< var << N << N << Y << N << Y << N << N << N << N << Y << N << N << Y << N << N << N << Y << N << N << N << N << N << N << N << N << N << Y << N << N << Y << Y;
+ var = QVariant((int)1);
+ QTest::newRow("Int")
+ << var << N << N << Y << N << Y << N << N << N << N << Y << N << N << Y << N << Y << N << Y << N << N << N << N << N << N << N << N << N << Y << N << N << Y << Y;
var = QVariant((qulonglong)1);
QTest::newRow("ULongLong")
<< var << N << N << Y << N << Y << N << N << N << N << Y << N << N << Y << N << N << N << Y << N << N << N << N << N << N << N << N << N << Y << N << N << Y << Y;
+ var = QVariant::fromValue('a');
+ QTest::newRow("Char")
+ << var << N << N << Y << N << Y << N << N << N << N << Y << N << N << Y << N << N << N << Y << N << N << N << N << N << N << N << N << N << Y << N << N << Y << Y;
+ var = QVariant::fromValue<signed char>(-1);
+ QTest::newRow("SChar")
+ << var << N << N << Y << N << Y << N << N << N << N << Y << N << N << Y << N << N << N << Y << N << N << N << N << N << N << N << N << N << Y << N << N << Y << Y;
#undef N
#undef Y
void tst_QVariant::canConvert()
{
- QFETCH(QVariant, val);
- QFETCH(bool, BitArrayCast);
- QFETCH(bool, BitmapCast);
- QFETCH(bool, BoolCast);
- QFETCH(bool, BrushCast);
- QFETCH(bool, ByteArrayCast);
- QFETCH(bool, ColorCast);
- QFETCH(bool, CursorCast);
- QFETCH(bool, DateCast);
- QFETCH(bool, DateTimeCast);
- QFETCH(bool, DoubleCast);
- QFETCH(bool, FontCast);
- QFETCH(bool, ImageCast);
- QFETCH(bool, IntCast);
- QFETCH(bool, InvalidCast);
- QFETCH(bool, KeySequenceCast);
- QFETCH(bool, ListCast);
- QFETCH(bool, LongLongCast);
- QFETCH(bool, MapCast);
- QFETCH(bool, PaletteCast);
- QFETCH(bool, PenCast);
- QFETCH(bool, PixmapCast);
- QFETCH(bool, PointCast);
- QFETCH(bool, RectCast);
- QFETCH(bool, RegionCast);
- QFETCH(bool, SizeCast);
- QFETCH(bool, SizePolicyCast);
- QFETCH(bool, StringCast);
- QFETCH(bool, StringListCast);
- QFETCH(bool, TimeCast);
- QFETCH(bool, UIntCast);
- QFETCH(bool, ULongLongCast);
-
- QCOMPARE(val.canConvert(QVariant::BitArray), BitArrayCast);
- QCOMPARE(val.canConvert(QVariant::Bitmap), BitmapCast);
- QCOMPARE(val.canConvert(QVariant::Bool), BoolCast);
- QCOMPARE(val.canConvert(QVariant::Brush), BrushCast);
- QCOMPARE(val.canConvert(QVariant::ByteArray), ByteArrayCast);
- QCOMPARE(val.canConvert(QVariant::Color), ColorCast);
- QCOMPARE(val.canConvert(QVariant::Cursor), CursorCast);
- QCOMPARE(val.canConvert(QVariant::Date), DateCast);
- QCOMPARE(val.canConvert(QVariant::DateTime), DateTimeCast);
- QCOMPARE(val.canConvert(QVariant::Double), DoubleCast);
- QCOMPARE(val.canConvert(QVariant::Type(QMetaType::Float)), DoubleCast);
- QCOMPARE(val.canConvert(QVariant::Font), FontCast);
- QCOMPARE(val.canConvert(QVariant::Image), ImageCast);
- QCOMPARE(val.canConvert(QVariant::Int), IntCast);
- QCOMPARE(val.canConvert(QVariant::Invalid), InvalidCast);
- QCOMPARE(val.canConvert(QVariant::KeySequence), KeySequenceCast);
- QCOMPARE(val.canConvert(QVariant::List), ListCast);
- QCOMPARE(val.canConvert(QVariant::LongLong), LongLongCast);
- QCOMPARE(val.canConvert(QVariant::Map), MapCast);
- QCOMPARE(val.canConvert(QVariant::Palette), PaletteCast);
- QCOMPARE(val.canConvert(QVariant::Pen), PenCast);
- QCOMPARE(val.canConvert(QVariant::Pixmap), PixmapCast);
- QCOMPARE(val.canConvert(QVariant::Point), PointCast);
- QCOMPARE(val.canConvert(QVariant::Rect), RectCast);
- QCOMPARE(val.canConvert(QVariant::Region), RegionCast);
- QCOMPARE(val.canConvert(QVariant::Size), SizeCast);
- QCOMPARE(val.canConvert(QVariant::SizePolicy), SizePolicyCast);
- QCOMPARE(val.canConvert(QVariant::String), StringCast);
- QCOMPARE(val.canConvert(QVariant::StringList), StringListCast);
- QCOMPARE(val.canConvert(QVariant::Time), TimeCast);
- QCOMPARE(val.canConvert(QVariant::UInt), UIntCast);
- QCOMPARE(val.canConvert(QVariant::ULongLong), ULongLongCast);
+ TST_QVARIANT_CANCONVERT_FETCH_DATA
+
+ TST_QVARIANT_CANCONVERT_COMPARE_DATA
// Invalid type ids
QCOMPARE(val.canConvert(-1), false);
QTest::newRow( "invalid" ) << QVariant() << 0 << false;
QTest::newRow( "int" ) << QVariant( 123 ) << 123 << true;
+ QTest::newRow( "char" ) << QVariant::fromValue('a') << int('a') << true;
+ signed char signedChar = -13;
+ QTest::newRow( "signed char" ) << QVariant::fromValue(signedChar) << -13 << true;
QTest::newRow( "double" ) << QVariant( 3.1415927 ) << 3 << true;
QTest::newRow( "float" ) << QVariant( 3.1415927f ) << 3 << true;
QTest::newRow( "uint" ) << QVariant( 123u ) << 123 << true;
QTest::newRow( "signedint-string" ) << QVariant( QString("-123") ) << -123 << true;
QTest::newRow( "signedlonglong0" ) << QVariant( (qlonglong)-34 ) << -34 << true;
QTest::newRow( "QChar" ) << QVariant(QChar('a')) << int('a') << true;
- QTest::newRow( "keysequence" ) << qVariantFromValue( QKeySequence( Qt::Key_A ) ) << 65 << true;
+ QTest::newRow( "keysequence" ) << QVariant::fromValue( QKeySequence( Qt::Key_A ) ) << 65 << true;
QByteArray bytearray(4, ' ');
bytearray[0] = 'T';
bytearray[1] = 'e';
QTest::addColumn<bool>("valueOK");
QTest::newRow( "int" ) << QVariant( 123 ) << (uint)123 << true;
+ QTest::newRow( "char" ) << QVariant::fromValue('a') << uint('a') << true;
+ signed char signedChar = 12;
+ QTest::newRow( "signed char" ) << QVariant::fromValue(signedChar) << uint(12) << true;
QTest::newRow( "double" ) << QVariant( 3.1415927 ) << (uint)3 << true;
QTest::newRow( "float" ) << QVariant( 3.1415927f ) << (uint)3 << true;
QTest::newRow( "uint" ) << QVariant( 123u ) << (uint)123 << true;
QFETCH( QColor, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Color ) );
- QColor d = qVariantValue<QColor>(value);
+ QColor d = qvariant_cast<QColor>(value);
QCOMPARE( d, result );
}
QFETCH( QPixmap, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Pixmap ) );
- QPixmap d = qVariantValue<QPixmap>(value);
+ QPixmap d = qvariant_cast<QPixmap>(value);
QCOMPARE( d, result );
}
QFETCH( QImage, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Image ) );
- QImage d = qVariantValue<QImage>(value);
+ QImage d = qvariant_cast<QImage>(value);
QCOMPARE( d, result );
}
QFETCH( QBrush, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Brush ) );
- QBrush d = qVariantValue<QBrush>(value);
+ QBrush d = qvariant_cast<QBrush>(value);
QCOMPARE( d, result );
}
QFETCH( QFont, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::Font ) );
- QFont d = qVariantValue<QFont>(value);
+ QFont d = qvariant_cast<QFont>(value);
QCOMPARE( d, result );
}
QFETCH( QKeySequence, result );
QVERIFY( value.isValid() );
QVERIFY( value.canConvert( QVariant::KeySequence ) );
- QKeySequence d = qVariantValue<QKeySequence>(value);
+ QKeySequence d = qvariant_cast<QKeySequence>(value);
QCOMPARE( d, result );
}
QTest::newRow( "qdate" ) << QVariant( QDate( 2002, 1, 1 ) ) << QString( "2002-01-01" );
QTest::newRow( "qtime" ) << QVariant( QTime( 12, 34, 56 ) ) << QString( "12:34:56" );
QTest::newRow( "qdatetime" ) << QVariant( QDateTime( QDate( 2002, 1, 1 ), QTime( 12, 34, 56 ) ) ) << QString( "2002-01-01T12:34:56" );
- QTest::newRow( "qkeysequence" ) << qVariantFromValue( QKeySequence( Qt::CTRL + Qt::Key_A ) )
+ QTest::newRow( "qkeysequence" ) << QVariant::fromValue( QKeySequence( Qt::CTRL + Qt::Key_A ) )
#ifndef Q_OS_MAC
<< QString( "Ctrl+A" );
#else
#endif
QFont font( "times", 12 );
- QTest::newRow( "qfont" ) << qVariantFromValue( font ) << QString("times,12,-1,5,50,0,0,0,0,0");
- QTest::newRow( "qcolor" ) << qVariantFromValue( QColor( 10, 10, 10 ) ) << QString( "#0a0a0a" );
+ QTest::newRow( "qfont" ) << QVariant::fromValue( font ) << QString("times,12,-1,5,50,0,0,0,0,0");
+ QTest::newRow( "qcolor" ) << QVariant::fromValue( QColor( 10, 10, 10 ) ) << QString( "#0a0a0a" );
QTest::newRow( "llong" ) << QVariant( (qlonglong)Q_INT64_C(123456789012) ) <<
QString( "123456789012" );
}
void tst_QVariant::matrix()
{
QVariant variant;
- QMatrix matrix = qVariantValue<QMatrix>(variant);
+ QMatrix matrix = qvariant_cast<QMatrix>(variant);
QVERIFY(matrix.isIdentity());
- qVariantSetValue(variant, QMatrix().rotate(90));
- QCOMPARE(QMatrix().rotate(90), qVariantValue<QMatrix>(variant));
+ variant.setValue(QMatrix().rotate(90));
+ QCOMPARE(QMatrix().rotate(90), qvariant_cast<QMatrix>(variant));
void *mmatrix = QMetaType::create(QVariant::Matrix, 0);
QVERIFY(mmatrix);
void tst_QVariant::matrix4x4()
{
QVariant variant;
- QMatrix4x4 matrix = qVariantValue<QMatrix4x4>(variant);
+ QMatrix4x4 matrix = qvariant_cast<QMatrix4x4>(variant);
QVERIFY(matrix.isIdentity());
QMatrix4x4 m;
m.scale(2.0f);
- qVariantSetValue(variant, m);
- QCOMPARE(m, qVariantValue<QMatrix4x4>(variant));
+ variant.setValue(m);
+ QCOMPARE(m, qvariant_cast<QMatrix4x4>(variant));
void *mmatrix = QMetaType::create(QVariant::Matrix4x4, 0);
QVERIFY(mmatrix);
void tst_QVariant::transform()
{
QVariant variant;
- QTransform matrix = qVariantValue<QTransform>(variant);
+ QTransform matrix = qvariant_cast<QTransform>(variant);
QVERIFY(matrix.isIdentity());
- qVariantSetValue(variant, QTransform().rotate(90));
- QCOMPARE(QTransform().rotate(90), qVariantValue<QTransform>(variant));
+ variant.setValue(QTransform().rotate(90));
+ QCOMPARE(QTransform().rotate(90), qvariant_cast<QTransform>(variant));
void *mmatrix = QMetaType::create(QVariant::Transform, 0);
QVERIFY(mmatrix);
void tst_QVariant::vector2D()
{
QVariant variant;
- QVector2D vector = qVariantValue<QVector2D>(variant);
+ QVector2D vector = qvariant_cast<QVector2D>(variant);
QVERIFY(vector.isNull());
- qVariantSetValue(variant, QVector2D(0.1, 0.2));
- QCOMPARE(QVector2D(0.1, 0.2), qVariantValue<QVector2D>(variant));
+ variant.setValue(QVector2D(0.1, 0.2));
+ QCOMPARE(QVector2D(0.1, 0.2), qvariant_cast<QVector2D>(variant));
void *pvector = QMetaType::create(QVariant::Vector2D, 0);
QVERIFY(pvector);
void tst_QVariant::vector3D()
{
QVariant variant;
- QVector3D vector = qVariantValue<QVector3D>(variant);
+ QVector3D vector = qvariant_cast<QVector3D>(variant);
QVERIFY(vector.isNull());
- qVariantSetValue(variant, QVector3D(0.1, 0.2, 0.3));
- QCOMPARE(QVector3D(0.1, 0.2, 0.3), qVariantValue<QVector3D>(variant));
+ variant.setValue(QVector3D(0.1, 0.2, 0.3));
+ QCOMPARE(QVector3D(0.1, 0.2, 0.3), qvariant_cast<QVector3D>(variant));
void *pvector = QMetaType::create(QVariant::Vector3D, 0);
QVERIFY(pvector);
void tst_QVariant::vector4D()
{
QVariant variant;
- QVector4D vector = qVariantValue<QVector4D>(variant);
+ QVector4D vector = qvariant_cast<QVector4D>(variant);
QVERIFY(vector.isNull());
- qVariantSetValue(variant, QVector4D(0.1, 0.2, 0.3, 0.4));
- QCOMPARE(QVector4D(0.1, 0.2, 0.3, 0.4), qVariantValue<QVector4D>(variant));
+ variant.setValue(QVector4D(0.1, 0.2, 0.3, 0.4));
+ QCOMPARE(QVector4D(0.1, 0.2, 0.3, 0.4), qvariant_cast<QVector4D>(variant));
void *pvector = QMetaType::create(QVariant::Vector4D, 0);
QVERIFY(pvector);
void tst_QVariant::quaternion()
{
QVariant variant;
- QQuaternion quaternion = qVariantValue<QQuaternion>(variant);
+ QQuaternion quaternion = qvariant_cast<QQuaternion>(variant);
QVERIFY(quaternion.isIdentity());
- qVariantSetValue(variant, QQuaternion(0.1, 0.2, 0.3, 0.4));
- QCOMPARE(QQuaternion(0.1, 0.2, 0.3, 0.4), qVariantValue<QQuaternion>(variant));
+ variant.setValue(QQuaternion(0.1, 0.2, 0.3, 0.4));
+ QCOMPARE(QQuaternion(0.1, 0.2, 0.3, 0.4), qvariant_cast<QQuaternion>(variant));
void *pquaternion = QMetaType::create(QVariant::Quaternion, 0);
QVERIFY(pquaternion);
QTest::addColumn<QVariant>("writeVariant");
QTest::addColumn<bool>("isNull");
{
- typedef QList<QVariant> variantsList;
- variantsList valuelist;
+ QVariantList valuelist;
valuelist << QVariant( 1 ) << QVariant( QString("Two") ) << QVariant( 3.45 );
QVariant var(valuelist);
QTest::newRow( "list_valid" ) << var << false;
bytearray[3] = 't';
bytearray[4] = '\0';
QTest::newRow( "bytearray_valid" ) << QVariant( bytearray ) << false;
- QTest::newRow( "bitmap_invalid" ) << qVariantFromValue( QBitmap() ) << true;
+ QTest::newRow( "bitmap_invalid" ) << QVariant::fromValue( QBitmap() ) << true;
QBitmap bitmap( 10, 10 );
bitmap.fill( Qt::red );
- QTest::newRow( "bitmap_valid" ) << qVariantFromValue( bitmap ) << false;
- QTest::newRow( "brush_valid" ) << qVariantFromValue( QBrush( Qt::red ) ) << false;
- QTest::newRow( "color_valid" ) << qVariantFromValue( QColor( Qt::red ) ) << false;
+ QTest::newRow( "bitmap_valid" ) << QVariant::fromValue( bitmap ) << false;
+ QTest::newRow( "brush_valid" ) << QVariant::fromValue( QBrush( Qt::red ) ) << false;
+ QTest::newRow( "color_valid" ) << QVariant::fromValue( QColor( Qt::red ) ) << false;
#ifndef QT_NO_CURSOR
- QTest::newRow( "cursor_valid" ) << qVariantFromValue( QCursor( Qt::PointingHandCursor ) ) << false;
+ QTest::newRow( "cursor_valid" ) << QVariant::fromValue( QCursor( Qt::PointingHandCursor ) ) << false;
#endif
QTest::newRow( "date_invalid" ) << QVariant( QDate() ) << true;
QTest::newRow( "date_valid" ) << QVariant( QDate( 2002, 07, 06 ) ) << false;
QTest::newRow( "datetime_valid" ) << QVariant( QDateTime( QDate( 2002, 07, 06 ), QTime( 14, 0, 0 ) ) ) << false;
QTest::newRow( "double_valid" ) << QVariant( 123.456 ) << false;
QTest::newRow( "float_valid" ) << QVariant( 123.456f ) << false;
- QTest::newRow( "font_valid" ) << qVariantFromValue( QFont( "times", 12 ) ) << false;
- QTest::newRow( "pixmap_invalid" ) << qVariantFromValue( QPixmap() ) << true;
+ QTest::newRow( "font_valid" ) << QVariant::fromValue( QFont( "times", 12 ) ) << false;
+ QTest::newRow( "pixmap_invalid" ) << QVariant::fromValue( QPixmap() ) << true;
QPixmap pixmap( 10, 10 );
pixmap.fill( Qt::red );
- QTest::newRow( "pixmap_valid" ) << qVariantFromValue( pixmap ) << false;
+ QTest::newRow( "pixmap_valid" ) << QVariant::fromValue( pixmap ) << false;
// QTest::newRow( "iconset_valid" ) << QVariant( QIcon( pixmap ) ) << false;
- QTest::newRow( "image_invalid" ) << qVariantFromValue( QImage() ) << true;
- QTest::newRow( "keysequence_valid" ) << qVariantFromValue( QKeySequence( Qt::CTRL + Qt::Key_A ) ) << false;
+ QTest::newRow( "image_invalid" ) << QVariant::fromValue( QImage() ) << true;
+ QTest::newRow( "keysequence_valid" ) << QVariant::fromValue( QKeySequence( Qt::CTRL + Qt::Key_A ) ) << false;
QTest::newRow( "int_valid" ) << QVariant( -123 ) << false;
- typedef QMap<QString, QVariant> variantsMap;
- variantsMap vMap;
+ QVariantMap vMap;
vMap.insert( "int", QVariant( 1 ) );
vMap.insert( "string", QVariant( QString("Two") ) );
vMap.insert( "double", QVariant( 3.45 ) );
vMap.insert( "float", QVariant( 3.45f ) );
QTest::newRow( "map_valid" ) << QVariant( vMap ) << false;
- QTest::newRow( "palette_valid" ) << qVariantFromValue(QPalette(QColor("turquoise"))) << false;
- QTest::newRow( "pen_valid" ) << qVariantFromValue( QPen( Qt::red ) ) << false;
- QTest::newRow( "pointarray_invalid" ) << qVariantFromValue( QPolygon() ) << true;
- QTest::newRow( "pointarray_valid" ) << qVariantFromValue( QPolygon( QRect( 10, 10, 20, 20 ) ) ) << false;
- QTest::newRow( "region_invalid" ) << qVariantFromValue( QRegion() ) << true;
- QTest::newRow( "region_valid" ) << qVariantFromValue( QRegion( 10, 10, 20, 20 ) ) << false;
- QTest::newRow( "sizepolicy_valid" ) << qVariantFromValue( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) ) << false;
- QTest::newRow( "point_invalid" ) << qVariantFromValue( QPoint() ) << true;
- QTest::newRow( "point_valid" ) << qVariantFromValue( QPoint( 10, 10 ) ) << false;
+ QTest::newRow( "palette_valid" ) << QVariant::fromValue(QPalette(QColor("turquoise"))) << false;
+ QTest::newRow( "pen_valid" ) << QVariant::fromValue( QPen( Qt::red ) ) << false;
+ QTest::newRow( "pointarray_invalid" ) << QVariant::fromValue( QPolygon() ) << true;
+ QTest::newRow( "pointarray_valid" ) << QVariant::fromValue( QPolygon( QRect( 10, 10, 20, 20 ) ) ) << false;
+ QTest::newRow( "region_invalid" ) << QVariant::fromValue( QRegion() ) << true;
+ QTest::newRow( "region_valid" ) << QVariant::fromValue( QRegion( 10, 10, 20, 20 ) ) << false;
+ QTest::newRow( "point_invalid" ) << QVariant::fromValue( QPoint() ) << true;
+ QTest::newRow( "point_valid" ) << QVariant::fromValue( QPoint( 10, 10 ) ) << false;
QTest::newRow( "rect_invalid" ) << QVariant( QRect() ) << true;
QTest::newRow( "rect_valid" ) << QVariant( QRect( 10, 10, 20, 20 ) ) << false;
QTest::newRow( "size_invalid" ) << QVariant( QSize( 0, 0 ) ) << true;
void tst_QVariant::checkDataStream()
{
- QTest::ignoreMessage(QtWarningMsg, "Trying to construct an instance of an invalid type, type id: 49");
- const QByteArray settingsHex("00000031ffffffffff");
+ const int typeId = QMetaType::LastCoreType + 1;
+ QVERIFY(!QMetaType::isRegistered(typeId));
+
+ QByteArray errorMessage("Trying to construct an instance of an invalid type, type id: ");
+ errorMessage.append(QString::number(typeId, 10));
+
+ QTest::ignoreMessage(QtWarningMsg, errorMessage.constData());
+ QByteArray settingsHex("000000");
+ settingsHex.append(QString::number(typeId, 16));
+ settingsHex.append("ffffffffff");
const QByteArray settings = QByteArray::fromHex(settingsHex);
QDataStream in(settings);
QVariant v;
{
QVariant userVar;
- qVariantSetValue(userVar, data);
+ userVar.setValue(data);
QCOMPARE(userVar.type(), QVariant::UserType);
QCOMPARE(userVar.userType(), qMetaTypeId<MyType>());
QVariant userVar2(userVar);
QVERIFY(userVar == userVar2);
- qVariantSetValue(userVar2, data2);
+ userVar2.setValue(data2);
QVERIFY(userVar != userVar2);
const MyType *varData = static_cast<const MyType *>(userVar.constData());
QCOMPARE(varData->text, data.text);
QVariant userVar3;
- qVariantSetValue(userVar3, data2);
+ userVar3.setValue(data2);
userVar3 = userVar2;
QVERIFY(userVar2 == userVar3);
QCOMPARE(instanceCount, 2);
{
QVariant userVar;
- qVariantSetValue(userVar, &data);
+ userVar.setValue(&data);
QCOMPARE(userVar.type(), QVariant::UserType);
QCOMPARE(userVar.userType(), qMetaTypeId<MyType*>());
QVariant userVar2(userVar);
QVERIFY(userVar == userVar2);
- qVariantSetValue(userVar2, &data2);
+ userVar2.setValue(&data2);
QVERIFY(userVar != userVar2);
MyType * const*varData = reinterpret_cast<MyType *const *>(userVar.constData());
QCOMPARE(*varData, &data);
QVariant userVar3;
- qVariantSetValue(userVar3, &data2);
+ userVar3.setValue(&data2);
/* This check is correct now. userVar2 contains a pointer to data2 and so
* does userVar3. */
QCOMPARE(instanceCount, 2);
QVariant myCarrier;
- qVariantSetValue(myCarrier, data);
+ myCarrier.setValue(data);
QCOMPARE(instanceCount, 3);
{
QVariant second = myCarrier;
QCOMPARE(instanceCount, 3);
MyType data3(0, "null");
- data3 = qVariantValue<MyType>(myCarrier);
+ data3 = qvariant_cast<MyType>(myCarrier);
QCOMPARE(data3.number, 1);
QCOMPARE(data3.text, (const char *)"eins");
#ifndef Q_CC_SUN
const MyType data(3, "drei");
QVariant myCarrier;
- qVariantSetValue(myCarrier, data);
+ myCarrier.setValue(data);
QCOMPARE(myCarrier.typeName(), "MyType");
const MyType data2 = qvariant_cast<MyType>(myCarrier);
short s = 42;
QVariant myCarrier;
- qVariantSetValue(myCarrier, s);
+ myCarrier.setValue(s);
QCOMPARE((int)qvariant_cast<short>(myCarrier), 42);
}
qlonglong ll = Q_INT64_C(42);
QVariant myCarrier;
- qVariantSetValue(myCarrier, ll);
+ myCarrier.setValue(ll);
QCOMPARE(qvariant_cast<int>(myCarrier), 42);
}
pod.a = 10;
pod.b = 20;
- QVariant pod_as_variant = qVariantFromValue(pod);
+ QVariant pod_as_variant = QVariant::fromValue(pod);
MyTypePOD pod2 = qvariant_cast<MyTypePOD>(pod_as_variant);
QCOMPARE(pod.a, pod2.a);
QCOMPARE(pod.b, pod2.b);
- qVariantSetValue(pod_as_variant, pod);
- pod2 = qVariantValue<MyTypePOD>(pod_as_variant);
+ pod_as_variant.setValue(pod);
+ pod2 = qvariant_cast<MyTypePOD>(pod_as_variant);
QCOMPARE(pod.a, pod2.a);
QCOMPARE(pod.b, pod2.b);
v = f;
QVERIFY(v.data());
- QCOMPARE(*static_cast<float *>(v.data()), qVariantValue<float>(v));
+ QCOMPARE(*static_cast<float *>(v.data()), qvariant_cast<float>(v));
v = ll;
QVERIFY(v.data());
QStringList sl;
sl << QLatin1String("blah");
- qVariantSetValue(v3, sl);
+ v3.setValue(sl);
Foo foo;
foo.i = 42;
- qVariantSetValue(v4, foo);
+ v4.setValue(foo);
QCOMPARE(qvariant_cast<double>(v1), 4.2);
QCOMPARE(qvariant_cast<float>(v1), 4.2f);
QCOMPARE(qvariant_cast<int>(v1), 4);
- QVariant n = qVariantFromValue<short>(42);
+ QVariant n = QVariant::fromValue<short>(42);
QCOMPARE(qvariant_cast<int>(n), 42);
QCOMPARE(qvariant_cast<uint>(n), 42u);
QCOMPARE(qvariant_cast<double>(n), 42.0);
QCOMPARE(qvariant_cast<short>(n), short(42));
QCOMPARE(qvariant_cast<ushort>(n), ushort(42));
- n = qVariantFromValue(43l);
+ n = QVariant::fromValue(43l);
QCOMPARE(qvariant_cast<int>(n), 43);
QCOMPARE(qvariant_cast<uint>(n), 43u);
QCOMPARE(qvariant_cast<double>(n), 43.0);
QCOMPARE(qvariant_cast<ulong>(n), 44ul);
QCOMPARE(qvariant_cast<float>(n), 44.0f);
- QCOMPARE(qVariantFromValue(0.25f).toDouble(), 0.25);
+ QCOMPARE(QVariant::fromValue(0.25f).toDouble(), 0.25);
}
struct Blah { int i; };
QVariant v3(str); //built with a QString
QCOMPARE(v2.toUrl(), url);
- QVERIFY(qVariantCanConvert<QUrl>(v3));
+ QVERIFY(v3.canConvert<QUrl>());
QCOMPARE(v2.toUrl(), v3.toUrl());
- QVERIFY(qVariantCanConvert<QString>(v2));
+ QVERIFY(v2.canConvert<QString>());
QCOMPARE(v2.toString(), str);
QCOMPARE(v3.toString(), str);
}
-void tst_QVariant::globalColor()
-{
- QVariant variant(Qt::blue);
- QVERIFY(variant.type() == QVariant::Color);
- QVERIFY(qVariantValue<QColor>(variant) == QColor(Qt::blue));
-}
-
void tst_QVariant::variantMap()
{
QMap<QString, QVariant> map;
public:
CustomQObject(QObject *parent = 0) : QObject(parent) {}
};
-class CustomQWidget : public QWidget {
- Q_OBJECT
-public:
- CustomQWidget(QWidget *parent = 0) : QWidget(parent) {}
-};
Q_DECLARE_METATYPE(CustomQObject*)
-Q_DECLARE_METATYPE(CustomQWidget*)
class CustomNonQObject { };
Q_DECLARE_METATYPE(CustomNonQObject)
QTest::newRow("from QObject2") << QVariant::fromValue(obj) << true;
QTest::newRow("from String") << QVariant(QLatin1String("1, 2, 3")) << false;
QTest::newRow("from int") << QVariant((int) 123) << false;
- QWidget *widget = new QWidget;
- widget->setObjectName(QString::fromLatin1("Hello"));
- QTest::newRow("from QWidget") << QVariant::fromValue(widget) << true;
CustomQObject *customObject = new CustomQObject(this);
customObject->setObjectName(QString::fromLatin1("Hello"));
QTest::newRow("from Derived QObject") << QVariant::fromValue(customObject) << true;
- CustomQWidget *customWidget = new CustomQWidget;
- customWidget->setObjectName(QString::fromLatin1("Hello"));
- QTest::newRow("from Derived QWidget") << QVariant::fromValue(customWidget) << true;
QTest::newRow("from custom Object") << QVariant::fromValue(CustomNonQObject()) << false;
// Deleted in cleanupTestCase.
// Deleted in cleanupTestCase.
objectPointerTestData.push_back(obj);
- objectPointerTestData.push_back(widget);
objectPointerTestData.push_back(customObject);
- objectPointerTestData.push_back(customWidget);
}
void tst_QVariant::qvariant_cast_QObject()
QCOMPARE(o != 0, success);
if (success) {
QCOMPARE(o->objectName(), QString::fromLatin1("Hello"));
+ QVERIFY(data.canConvert<QObject*>());
+ QVERIFY(data.canConvert(QMetaType::QObjectStar));
+ QVERIFY(data.canConvert(::qMetaTypeId<QObject*>()));
+ QVERIFY(data.value<QObject*>());
+ QVERIFY(data.convert(QMetaType::QObjectStar));
+ QCOMPARE(data.userType(), int(QMetaType::QObjectStar));
+ } else {
+ QVERIFY(!data.canConvert<QObject*>());
+ QVERIFY(!data.canConvert(QMetaType::QObjectStar));
+ QVERIFY(!data.canConvert(::qMetaTypeId<QObject*>()));
+ QVERIFY(!data.value<QObject*>());
+ QVERIFY(!data.convert(QMetaType::QObjectStar));
+ QVERIFY(data.userType() != QMetaType::QObjectStar);
}
}
QCOMPARE(data.value<QObject *>(), object);
QCOMPARE(data.value<CustomQObjectDerivedNoMetaType *>(), object);
QCOMPARE(data.value<CustomQObject *>(), object);
- QVERIFY(data.value<CustomQWidget*>() == 0);
}
{
CustomQObjectDerived *object = new CustomQObjectDerived(this);
QCOMPARE(data.value<QObject *>(), object);
QCOMPARE(data.value<CustomQObjectDerived *>(), object);
QCOMPARE(data.value<CustomQObject *>(), object);
- QVERIFY(data.value<CustomQWidget*>() == 0);
- }
- {
- CustomQWidget customWidget;
- QWidget *widget = &customWidget;
- QVariant data = QVariant::fromValue(widget);
- QVERIFY(data.userType() == QMetaType::QWidgetStar);
-
- QCOMPARE(data.value<QObject*>(), widget);
- QCOMPARE(data.value<QWidget*>(), widget);
- QCOMPARE(data.value<CustomQWidget*>(), widget);
}
}
-Q_DECLARE_METATYPE(qint8);
-
void tst_QVariant::convertToQUint8() const
{
/* qint8. */
* It's of type QVariant::Int. */
const QVariant v0 = anInt;
- QVERIFY(qVariantCanConvert<qint8>(v0));
+ QVERIFY(v0.canConvert<qint8>());
QCOMPARE(int(qvariant_cast<qint8>(v0)), 32);
QCOMPARE(int(v0.toInt()), 32);
QCOMPARE(v0.toString(), QString("32"));
const quint8 anInt = 32;
const QVariant v0 = anInt;
- QVERIFY(qVariantCanConvert<quint8>(v0));
+ QVERIFY(v0.canConvert<quint8>());
QCOMPARE(int(qvariant_cast<quint8>(v0)), 32);
QCOMPARE(int(v0.toUInt()), 32);
QCOMPARE(v0.toString(), QString("32"));
const qint16 anInt = 32;
const QVariant v0 = anInt;
- QVERIFY(qVariantCanConvert<qint16>(v0));
+ QVERIFY(v0.canConvert<qint16>());
QCOMPARE(int(qvariant_cast<qint16>(v0)), 32);
QCOMPARE(int(v0.toInt()), 32);
QCOMPARE(v0.toString(), QString("32"));
const quint16 anInt = 32;
const QVariant v0 = anInt;
- QVERIFY(qVariantCanConvert<quint16>(v0));
+ QVERIFY(v0.canConvert<quint16>());
QCOMPARE(int(qvariant_cast<quint16>(v0)), 32);
QCOMPARE(int(v0.toUInt()), 32);
QCOMPARE(v0.toString(), QString("32"));
MyClass myClass;
- QVariant v = qVariantFromValue<void *>(&myClass);
- QVariant v2 = qVariantFromValue<void *>(&myClass);
+ QVariant v = QVariant::fromValue<void *>(&myClass);
+ QVariant v2 = QVariant::fromValue<void *>(&myClass);
QCOMPARE(v, v2);
}
void *p2 = p1;
QVariant v1, v2;
- v1 = qVariantFromValue(p1);
+ v1 = QVariant::fromValue(p1);
v2 = v1;
QVERIFY(v1 == v2);
- v2 = qVariantFromValue(p2);
+ v2 = QVariant::fromValue(p2);
QVERIFY(v1 == v2);
p2 = 0;
- v2 = qVariantFromValue(p2);
+ v2 = QVariant::fromValue(p2);
QVERIFY(v1 != v2);
}
qRegisterMetaType<Data*>();
Data *p1 = new Data;
- QVariant v1 = qVariantFromValue(p1);
+ QVariant v1 = QVariant::fromValue(p1);
QCOMPARE(v1.userType(), qMetaTypeId<Data*>());
QCOMPARE(qvariant_cast<Data*>(v1), p1);
QVariant v2 = v1;
QVERIFY(v1 == v2);
- v2 = qVariantFromValue(p1);
+ v2 = QVariant::fromValue(p1);
QVERIFY(v1 == v2);
delete p1;
}
template<typename T> void convertMetaType()
{
- QVERIFY(qVariantFromValue<T>(10).isValid());
- QVERIFY(qVariantFromValue<T>(10).canConvert(QVariant::Int));
- QCOMPARE(qVariantFromValue<T>(10).toInt(), 10);
- QCOMPARE(qVariantFromValue<T>(10), qVariantFromValue<T>(10));
+ QVERIFY(QVariant::fromValue<T>(10).isValid());
+ QVERIFY(QVariant::fromValue<T>(10).canConvert(QVariant::Int));
+ QCOMPARE(QVariant::fromValue<T>(10).toInt(), 10);
+ QCOMPARE(QVariant::fromValue<T>(10), QVariant::fromValue<T>(10));
}
#define CONVERT_META_TYPE(Type) \
void tst_QVariant::loadUnknownUserType()
{
qRegisterMetaType<MyClass>("MyClass");
+ QTest::ignoreMessage(QtWarningMsg, "QVariant::load: unable to load type "
+ + QByteArray::number(qMetaTypeId<MyClass>()) +".");
char data[] = {0, 0, QMetaType::User >> 8 , char(QMetaType::User), 0, 0, 0, 0, 8, 'M', 'y', 'C', 'l', 'a', 's', 's', 0};
QByteArray ba(data, sizeof(data));
void tst_QVariant::loadBrokenUserType()
{
- char data[] = {0, 0, 0, 127, 0, 112 };
+ QTest::ignoreMessage(QtWarningMsg, "Trying to construct an instance of an invalid type, type id: 127");
+ char data[] = {0, 0, 0, 127, 0 };
QByteArray ba(data, sizeof(data));
QDataStream ds(&ba, QIODevice::ReadOnly);
QVariant var;
var.load(ds);
- QCOMPARE(ds.status(), QDataStream::ReadPastEnd);
+ QCOMPARE(ds.status(), QDataStream::Ok);
}
void tst_QVariant::invalidDate() const
WontCompare f1;
f1.x = 0;
- const QVariant variant1(qVariantFromValue(f1));
+ const QVariant variant1(QVariant::fromValue(f1));
WontCompare f2;
f2.x = 0;
- const QVariant variant2(qVariantFromValue(f2));
+ const QVariant variant2(QVariant::fromValue(f2));
/* We compare pointers. */
QVERIFY(variant1 != variant2);
QVERIFY(!val.toDateTime().isValid());
}
-Q_DECLARE_METATYPE(QHostAddress)
+struct CustomComparable
+{
+ CustomComparable(int value = 0) : myValue(value) {}
+ int myValue;
+
+ bool operator==(const CustomComparable &other) const
+ { return other.myValue == myValue; }
+};
+
+Q_DECLARE_METATYPE(CustomComparable)
void tst_QVariant::copyingUserTypes() const
{
QVariant var;
- QVariant var3;
- const QHostAddress ha("127.0.0.1");
- qVariantSetValue(var, ha);
- var3 = var;
+ QVariant varCopy;
+ const CustomComparable userType = CustomComparable(42);
+ var.setValue(userType);
+ varCopy = var;
- QCOMPARE(qVariantValue<QHostAddress>(var3), ha);
+ const CustomComparable copiedType = qvariant_cast<CustomComparable>(varCopy);
+ QCOMPARE(copiedType, userType);
+ QCOMPARE(copiedType.myValue, 42);
}
void tst_QVariant::convertBoolToByteArray() const
const QVariant variant(input);
- QCOMPARE(qVariantCanConvert<bool>(variant), canConvert);
+ QCOMPARE(variant.canConvert<bool>(), canConvert);
if(canConvert) {
/* Just call this function so we run the code path. */
const QVariant variant(input);
QCOMPARE(variant.type(), QVariant::Bool);
QCOMPARE(variant.toBool(), input);
- QVERIFY(qVariantCanConvert<bool>(variant));
+ QVERIFY(variant.canConvert<bool>());
QCOMPARE(variant.toByteArray(), output);
}
QVERIFY( !v1.isDetached() );
QVERIFY( !v2.isDetached() );
- qVariantSetValue(v2, 3); //set an integer value
+ v2.setValue(3); //set an integer value
QVERIFY( v1.isDetached() );
QVERIFY( v2.isDetached() );
}
QCOMPARE(qvariant_cast<T>(v2), qvariant_cast<T>(v));
QCOMPARE(v2.toString(), toString);
- v3 = qVariantFromValue(orig);
+ v3 = QVariant::fromValue(orig);
QVERIFY(v3.isValid());
QCOMPARE(v3.isNull(), isNull);
PLAY_WITH_VARIANT( qint32(17), false, "17", 17, true);
PLAY_WITH_VARIANT(quint64(18), false, "18", 18, true);
PLAY_WITH_VARIANT( qint64(19), false, "19", 19, true);
- PLAY_WITH_VARIANT( qint8(-12), false, "\xf4", -12, true);
+ PLAY_WITH_VARIANT( qint8(-12), false, QLatin1String("\xf4"), -12, true); // qint8 is char, so it gets converted via QChar
PLAY_WITH_VARIANT( qint16(-13), false, "-13", -13, true);
PLAY_WITH_VARIANT( qint32(-14), false, "-14", -14, true);
PLAY_WITH_VARIANT( qint64(-15), false, "-15", -15, true);
QCOMPARE(recunstructedVariant.userType(), constructedVariant.userType());
}
-class MessageHandler {
-public:
- MessageHandler(const int typeId, QtMsgHandler msgHandler = handler)
- : oldMsgHandler(qInstallMsgHandler(msgHandler))
- {
- currentId = typeId;
- }
-
- ~MessageHandler()
- {
- qInstallMsgHandler(oldMsgHandler);
- }
-
- bool testPassed() const
- {
- return ok;
- }
-protected:
- static void handler(QtMsgType, const char *txt)
- {
- QString msg = QString::fromLatin1(txt);
- // 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());
- ok &= (currentId == QMetaType::UnknownType
- ? msg.contains("Invalid")
- : msg.contains(QMetaType::typeName(currentId)));
- QVERIFY2(ok, (QString::fromLatin1("Message doesn't contain type name: '") + msg + '\'').toLatin1().constData());
- if (currentId == QMetaType::Char || currentId == QMetaType::QChar) {
- // Chars insert '\0' into the qdebug stream, it is not possible to find a real string length
- return;
- }
- if (QMetaType::typeFlags(currentId) & QMetaType::PointerToQObject) {
- QByteArray currentName = QMetaType::typeName(currentId);
- currentName.chop(1);
- ok &= (msg.contains(", " + currentName) || msg.contains(", 0x0"));
- }
- ok &= msg.endsWith(") ");
- QVERIFY2(ok, (QString::fromLatin1("Message is not correctly finished: '") + msg + '\'').toLatin1().constData());
-
- }
-
- QtMsgHandler oldMsgHandler;
- static int currentId;
- static bool ok;
-};
-bool MessageHandler::ok;
-int MessageHandler::currentId;
-
void tst_QVariant::debugStream_data()
{
QTest::addColumn<QVariant>("variant");
QTest::addColumn<int>("typeId");
- for (int id = 0; id < QMetaType::User; ++id) {
+ for (int id = 0; id < QMetaType::LastGuiType + 1; ++id) {
const char *tagName = QMetaType::typeName(id);
if (!tagName)
continue;
// crash test, it should not crash at QGuiApplication exit
static QVariant cursor = QCursor();
static QVariant point = QPoint();
+ static QVariant icon = QIcon();
static QVariant image = QImage();
- static QVariant pallete = QPalette();
+ static QVariant palette = QPalette();
Q_UNUSED(cursor);
Q_UNUSED(point);
- Q_UNUSED(image);
- Q_UNUSED(pallete);
- QVERIFY(true);
-}
-
-void tst_QVariant::widgetsVariantAtExit()
-{
- // crash test, it should not crash at QGuiApplication exit
- static QVariant icon= QIcon();
- static QVariant sizePolicy = QSizePolicy();
Q_UNUSED(icon);
- Q_UNUSED(sizePolicy);
+ Q_UNUSED(image);
+ Q_UNUSED(palette);
QVERIFY(true);
}
projects / profile / ivi / qtbase.git / blobdiff