/****************************************************************************
**
-** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
-** All rights reserved.
-** Contact: Nokia Corporation (qt-info@nokia.com)
+** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: http://www.qt-project.org/
**
** This file is part of the test suite of the Qt Toolkit.
**
**
**
**
+**
** $QT_END_LICENSE$
**
****************************************************************************/
#include <qvariant.h>
#include <qbitarray.h>
-#include <qhostaddress.h>
#include <qdatetime.h>
#include <qmap.h>
#include <qiodevice.h>
#include <qmatrix4x4.h>
#include <qpen.h>
#include <qpolygon.h>
+#include <qpalette.h>
#include <qtransform.h>
#include <qvector2d.h>
#include <qvector3d.h>
#include <qvector4d.h>
#include <qquaternion.h>
+#include <qdebug.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;
class tst_QVariant : public QObject
{
Q_OBJECT
+public:
+ tst_QVariant(QObject *parent = 0)
+ : QObject(parent), customNonQObjectPointer(0)
+ {
+
+ }
+
private slots:
+ void cleanupTestCase();
+
void constructor();
void copy_constructor();
+ void constructor_invalid_data();
+ void constructor_invalid();
void isNull();
void swap();
void qvariant_cast_QObject_data();
void qvariant_cast_QObject();
+ void qvariant_cast_QObject_derived();
void toLocale();
void toRegExp();
+ void toRegularExpression();
void matrix();
void podUserType();
- void data_(); // data is virtual function in QtTestCase
+ void data();
void constData();
void saveLoadCustomTypes();
- void globalColor();
-
void variantMap();
void variantHash();
void numericalConvert();
void moreCustomTypes();
+ void movabilityTest();
void variantInVariant();
void colorInteger();
void forwardDeclare();
+ void debugStream_data();
+ void debugStream();
+ void debugStreamType_data();
+ void debugStreamType();
+
+ void loadQt4Stream_data();
+ void loadQt4Stream();
+ void saveQt4Stream_data();
+ void saveQt4Stream();
+ void loadQt5Stream_data();
+ void loadQt5Stream();
+ void saveQt5Stream_data();
+ void saveQt5Stream();
+
+ void guiVariantAtExit();
+private:
+ void dataStream_data(QDataStream::Version version);
+ void loadQVariantFromDataStream(QDataStream::Version version);
+ void saveQVariantFromDataStream(QDataStream::Version version);
+
+ CustomNonQObject *customNonQObjectPointer;
+ 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);
+ QCOMPARE(val.canConvert(-23), false);
+ QCOMPARE(val.canConvert(-23876), false);
+ QCOMPARE(val.canConvert(23876), false);
}
void tst_QVariant::toInt_data()
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" );
}
rx = variant.toRegExp();
}
+void tst_QVariant::toRegularExpression()
+{
+ QVariant variant;
+ QRegularExpression re = variant.toRegularExpression();
+ QCOMPARE(re, QRegularExpression());
+
+ variant = QRegularExpression("abc.*def");
+ re = variant.toRegularExpression();
+ QCOMPARE(re, QRegularExpression("abc.*def"));
+
+ variant = QVariant::fromValue(QRegularExpression("[ab]\\w+"));
+ re = variant.value<QRegularExpression>();
+ QCOMPARE(re, QRegularExpression("[ab]\\w+"));
+}
+
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);
QMetaType::destroy(QVariant::Quaternion, pquaternion);
}
+struct CustomStreamableClass
+{
+ int i;
+ bool operator==(const CustomStreamableClass& other) const
+ {
+ return i == other.i;
+ }
+};
+Q_DECLARE_METATYPE(CustomStreamableClass);
+
+QDataStream &operator<<(QDataStream &out, const CustomStreamableClass &myObj)
+{
+ return out << myObj.i;
+}
+
+QDataStream &operator>>(QDataStream &in, CustomStreamableClass &myObj)
+{
+ return in >> myObj.i;
+}
+
void tst_QVariant::writeToReadFromDataStream_data()
{
+ qRegisterMetaTypeStreamOperators<CustomStreamableClass>();
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;
QTest::newRow( "qchar_null" ) << QVariant(QChar(0)) << true;
QTest::newRow( "regexp" ) << QVariant(QRegExp("foo", Qt::CaseInsensitive)) << false;
QTest::newRow( "regexp_empty" ) << QVariant(QRegExp()) << false;
+ QTest::newRow( "regularexpression" ) << QVariant(QRegularExpression("abc.*def")) << false;
+ QTest::newRow( "regularexpression_empty" ) << QVariant(QRegularExpression()) << false;
// types known to QMetaType, but not part of QVariant::Type
QTest::newRow("QMetaType::Long invalid") << QVariant(QMetaType::Long, (void *) 0) << false;
QTest::newRow("QMetaType::Float invalid") << QVariant(QMetaType::Float, (void *) 0) << false;
float f = 1.234f;
QTest::newRow("QMetaType::Float") << QVariant(QMetaType::Float, &f) << false;
+ CustomStreamableClass custom = {123};
+ QTest::newRow("Custom type") << QVariant::fromValue(custom) << false;
}
void tst_QVariant::writeToReadFromDataStream()
// Best way to confirm the readVariant contains the same data?
// Since only a few won't match since the serial numbers are different
// I won't bother adding another bool in the data test.
- QVariant::Type writeType = writeVariant.type();
- if ( writeType != QVariant::Invalid && writeType != QVariant::Bitmap && writeType != QVariant::Pixmap
+ 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) {
switch (writeType) {
default:
void tst_QVariant::checkDataStream()
{
- const QByteArray settingsHex("0000002effffffffff");
+ 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;
QTest::newRow("HashSecondLarger") << QVariant(hash1) << QVariant(hash2) << false;
}
-
- QTest::newRow( "UserType" ) << QVariant(QVariant::UserType) << QVariant(QVariant::UserType) << true;
- QVariant mUserType(QVariant::UserType);
- QTest::newRow( "Shared UserType" ) << mUserType << mUserType << true;
}
void tst_QVariant::operator_eq_eq()
QTest::newRow("39") << int(QVariant::RectF) << QByteArray("QRectF");
QTest::newRow("40") << int(QVariant::PointF) << QByteArray("QPointF");
QTest::newRow("41") << int(QVariant::RegExp) << QByteArray("QRegExp");
- QTest::newRow("42") << int(QVariant::UserType) << QByteArray("UserType");
QTest::newRow("43") << int(QVariant::Matrix) << QByteArray("QMatrix");
QTest::newRow("44") << int(QVariant::Transform) << QByteArray("QTransform");
QTest::newRow("45") << int(QVariant::Hash) << QByteArray("QVariantHash");
QTest::newRow("48") << int(QVariant::Vector3D) << QByteArray("QVector3D");
QTest::newRow("49") << int(QVariant::Vector4D) << QByteArray("QVector4D");
QTest::newRow("50") << int(QVariant::Quaternion) << QByteArray("QQuaternion");
+ QTest::newRow("51") << int(QVariant::RegularExpression) << QByteArray("QRegularExpression");
}
void tst_QVariant::typeName()
QVERIFY( QVariant::nameToType( 0 ) == QVariant::Invalid );
QVERIFY( QVariant::nameToType( "" ) == QVariant::Invalid );
QVERIFY( QVariant::nameToType( "foo" ) == QVariant::Invalid );
- QCOMPARE(QVariant::nameToType("QIconSet"), QVariant::Icon);
+
+ QCOMPARE(QVariant::nameToType("UserType"), QVariant::Invalid);
+
+ // We don't support these old (Qt3) types anymore.
+ QCOMPARE(QVariant::nameToType("QIconSet"), QVariant::Invalid);
+ QCOMPARE(QVariant::nameToType("Q3CString"), QVariant::Invalid);
+ QCOMPARE(QVariant::nameToType("Q_LLONG"), QVariant::Invalid);
+ QCOMPARE(QVariant::nameToType("Q_ULLONG"), QVariant::Invalid);
}
void tst_QVariant::streamInvalidVariant()
void tst_QVariant::userType()
{
{
- QVariant userVariant(QVariant::UserType);
-
- QVERIFY(userVariant.isValid());
- QVERIFY(userVariant.isNull());
- }
-
- {
MyType data(1, "eins");
MyType data2(2, "zwei");
{
QVariant userVar;
- qVariantSetValue(userVar, data);
+ userVar.setValue(data);
QCOMPARE(userVar.type(), QVariant::UserType);
+ QCOMPARE(userVar.userType(), qMetaTypeId<MyType>());
QCOMPARE(userVar.typeName(), "MyType");
QVERIFY(!userVar.isNull());
QVERIFY(!userVar.canConvert(QVariant::String));
- QVERIFY(!userVar.canConvert(QVariant::UserType));
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);
- QVERIFY(userVar2 == userVar3);
+ 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*>());
QCOMPARE(userVar.typeName(), "MyType*");
QVERIFY(!userVar.isNull());
QVERIFY(!userVar.canConvert(QVariant::String));
- QVERIFY(!userVar.canConvert(QVariant::UserType));
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, 4);
+ QCOMPARE(instanceCount, 3);
second.detach();
QCOMPARE(instanceCount, 4);
}
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);
QCOMPARE(v.toByteArray(), QByteArray("bar"));
}
-void tst_QVariant::data_()
+void tst_QVariant::data()
{
QVariant v;
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;
QVERIFY(!qvariant_cast<QColor>(va).isValid());
}
-void tst_QVariant::qvariant_cast_QObject_data() {
+class CustomQObject : public QObject {
+ Q_OBJECT
+public:
+ CustomQObject(QObject *parent = 0) : QObject(parent) {}
+};
+Q_DECLARE_METATYPE(CustomQObject*)
+class CustomNonQObject { };
+Q_DECLARE_METATYPE(CustomNonQObject)
+Q_DECLARE_METATYPE(CustomNonQObject*)
+
+void tst_QVariant::cleanupTestCase()
+{
+ delete customNonQObjectPointer;
+ qDeleteAll(objectPointerTestData);
+}
+
+void tst_QVariant::qvariant_cast_QObject_data()
+{
QTest::addColumn<QVariant>("data");
QTest::addColumn<bool>("success");
- QObject *obj = new QObject(this);
+ QObject *obj = new QObject;
obj->setObjectName(QString::fromLatin1("Hello"));
QTest::newRow("from QObject") << QVariant(QMetaType::QObjectStar, &obj) << true;
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;
-}
+ CustomQObject *customObject = new CustomQObject(this);
+ customObject->setObjectName(QString::fromLatin1("Hello"));
+ QTest::newRow("from Derived QObject") << QVariant::fromValue(customObject) << true;
+ QTest::newRow("from custom Object") << QVariant::fromValue(CustomNonQObject()) << false;
+
+ // Deleted in cleanupTestCase.
+ customNonQObjectPointer = new CustomNonQObject;
+ QTest::newRow("from custom ObjectStar") << QVariant::fromValue(customNonQObjectPointer) << false;
+ // Deleted in cleanupTestCase.
+ objectPointerTestData.push_back(obj);
+ objectPointerTestData.push_back(customObject);
+}
-void tst_QVariant::qvariant_cast_QObject() {
+void tst_QVariant::qvariant_cast_QObject()
+{
QFETCH(QVariant, data);
QFETCH(bool, success);
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);
}
}
-Q_DECLARE_METATYPE(qint8);
+class CustomQObjectDerived : public CustomQObject {
+ Q_OBJECT
+public:
+ CustomQObjectDerived(QObject *parent = 0) : CustomQObject(parent) {}
+};
+Q_DECLARE_METATYPE(CustomQObjectDerived*)
+
+class CustomQObjectDerivedNoMetaType : public CustomQObject {
+ Q_OBJECT
+public:
+ CustomQObjectDerivedNoMetaType(QObject *parent = 0) : CustomQObject(parent) {}
+};
+
+void tst_QVariant::qvariant_cast_QObject_derived()
+{
+ {
+ CustomQObjectDerivedNoMetaType *object = new CustomQObjectDerivedNoMetaType(this);
+ QVariant data = QVariant::fromValue(object);
+ QVERIFY(data.userType() == qMetaTypeId<CustomQObjectDerivedNoMetaType*>());
+ QCOMPARE(data.value<QObject *>(), object);
+ QCOMPARE(data.value<CustomQObjectDerivedNoMetaType *>(), object);
+ QCOMPARE(data.value<CustomQObject *>(), object);
+ }
+ {
+ CustomQObjectDerived *object = new CustomQObjectDerived(this);
+ QVariant data = QVariant::fromValue(object);
+
+ QVERIFY(data.userType() == qMetaTypeId<CustomQObjectDerived*>());
+
+ QCOMPARE(data.value<QObject *>(), object);
+ QCOMPARE(data.value<CustomQObjectDerived *>(), object);
+ QCOMPARE(data.value<CustomQObject *>(), object);
+ }
+}
void tst_QVariant::convertToQUint8() const
{
* 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");
- char data[] = {0, 0, 0, 127, 0, 0, 0, 0, 8, 77, 121, 67, 108, 97, 115, 115, 0};
+ 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));
QDataStream ds(&ba, QIODevice::ReadOnly);
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);
PLAY_WITH_VARIANT(d, false, QString(), 0, false);
}
QCOMPARE(MyMovable::count, 0);
+
+ {
+ QList<QList<int> > data;
+ PLAY_WITH_VARIANT(data, false, QString(), 0, false);
+ data << (QList<int>() << 42);
+ PLAY_WITH_VARIANT(data, false, QString(), 0, false);
+ }
+
+ {
+ QList<QVector<int> > data;
+ PLAY_WITH_VARIANT(data, false, QString(), 0, false);
+ data << (QVector<int>() << 42);
+ PLAY_WITH_VARIANT(data, false, QString(), 0, false);
+ }
+
+ {
+ QList<QSet<int> > data;
+ PLAY_WITH_VARIANT(data, false, QString(), 0, false);
+ data << (QSet<int>() << 42);
+ PLAY_WITH_VARIANT(data, false, QString(), 0, false);
+ }
+
+ {
+ QList<QLinkedList<int> > data;
+ PLAY_WITH_VARIANT(data, false, QString(), 0, false);
+ data << (QLinkedList<int>() << 42);
+ PLAY_WITH_VARIANT(data, false, QString(), 0, false);
+ }
}
+void tst_QVariant::movabilityTest()
+{
+ // This test checks if QVariant is movable even if an internal data is not movable.
+ QVERIFY(!MyNotMovable::count);
+ {
+ QVariant variant = QVariant::fromValue(MyNotMovable());
+ QVERIFY(MyNotMovable::count);
+
+ // prepare destination memory space to which variant will be moved
+ QVariant buffer[1];
+ QCOMPARE(buffer[0].type(), QVariant::Invalid);
+ buffer[0].~QVariant();
+
+ memcpy(buffer, &variant, sizeof(QVariant));
+ QCOMPARE(buffer[0].type(), QVariant::UserType);
+ QCOMPARE(buffer[0].userType(), qMetaTypeId<MyNotMovable>());
+ MyNotMovable tmp(buffer[0].value<MyNotMovable>());
+
+ new (&variant) QVariant();
+ }
+ QVERIFY(!MyNotMovable::count);
+}
void tst_QVariant::variantInVariant()
{
}
class Forward;
-Q_DECLARE_METATYPE(Forward*);
+Q_DECLARE_OPAQUE_POINTER(Forward*)
+Q_DECLARE_METATYPE(Forward*)
void tst_QVariant::forwardDeclare()
{
QCOMPARE(qvariant_cast<Forward*>(v), f);
}
+void tst_QVariant::loadQt5Stream_data()
+{
+ dataStream_data(QDataStream::Qt_5_0);
+}
+
+void tst_QVariant::loadQt5Stream()
+{
+ loadQVariantFromDataStream(QDataStream::Qt_5_0);
+}
+
+void tst_QVariant::saveQt5Stream_data()
+{
+ dataStream_data(QDataStream::Qt_5_0);
+}
+
+void tst_QVariant::saveQt5Stream()
+{
+ saveQVariantFromDataStream(QDataStream::Qt_5_0);
+}
+
+void tst_QVariant::loadQt4Stream_data()
+{
+ dataStream_data(QDataStream::Qt_4_9);
+}
+
+void tst_QVariant::loadQt4Stream()
+{
+ loadQVariantFromDataStream(QDataStream::Qt_4_9);
+}
+
+void tst_QVariant::saveQt4Stream_data()
+{
+ dataStream_data(QDataStream::Qt_4_9);
+}
+
+void tst_QVariant::saveQt4Stream()
+{
+ saveQVariantFromDataStream(QDataStream::Qt_4_9);
+}
+
+void tst_QVariant::dataStream_data(QDataStream::Version version)
+{
+ QTest::addColumn<QString>("fileName");
+
+ QString path;
+ switch (version) {
+ case QDataStream::Qt_4_9:
+ path = QString::fromLatin1("qt4.9");
+ break;
+ case QDataStream::Qt_5_0:
+ path = QString::fromLatin1("qt5.0");
+ break;
+ default:
+ Q_UNIMPLEMENTED();
+ }
+
+ path = path.prepend(":/stream/").append("/");
+ QDir dir(path);
+ uint i = 0;
+ foreach (const QFileInfo &fileInfo, dir.entryInfoList(QStringList() << "*.bin")) {
+ QTest::newRow((path + fileInfo.fileName()).toLatin1()) << fileInfo.filePath();
+ i += 1;
+ }
+ QVERIFY(i > 10);
+}
+
+void tst_QVariant::loadQVariantFromDataStream(QDataStream::Version version)
+{
+ QFETCH(QString, fileName);
+
+ QFile file(fileName);
+ QVERIFY(file.open(QIODevice::ReadOnly));
+
+ QDataStream stream(&file);
+ stream.setVersion(version);
+
+ QString typeName;
+ QVariant loadedVariant;
+ stream >> typeName >> loadedVariant;
+
+ const int id = QMetaType::type(typeName.toLatin1());
+ if (id == QMetaType::Void) {
+ // Void type is not supported by QVariant
+ return;
+ }
+
+ QVariant constructedVariant(static_cast<QVariant::Type>(id));
+ QCOMPARE(constructedVariant.userType(), id);
+ QCOMPARE(QMetaType::typeName(loadedVariant.userType()), typeName.toLatin1().constData());
+ QCOMPARE(loadedVariant.userType(), constructedVariant.userType());
+}
+
+void tst_QVariant::saveQVariantFromDataStream(QDataStream::Version version)
+{
+ QFETCH(QString, fileName);
+
+ QFile file(fileName);
+ QVERIFY(file.open(QIODevice::ReadOnly));
+ QDataStream dataFileStream(&file);
+
+ QString typeName;
+ dataFileStream >> typeName;
+ QByteArray data = file.readAll();
+ const int id = QMetaType::type(typeName.toLatin1());
+ if (id == QMetaType::Void) {
+ // Void type is not supported by QVariant
+ return;
+ }
+
+ QBuffer buffer;
+ buffer.open(QIODevice::ReadWrite);
+ QDataStream stream(&buffer);
+ stream.setVersion(version);
+
+ QVariant constructedVariant(static_cast<QVariant::Type>(id));
+ QCOMPARE(constructedVariant.userType(), id);
+ stream << constructedVariant;
+
+ // We are testing QVariant there is no point in testing full array.
+ QCOMPARE(buffer.data().left(5), data.left(5));
+
+ buffer.seek(0);
+ QVariant recunstructedVariant;
+ stream >> recunstructedVariant;
+ QCOMPARE(recunstructedVariant.userType(), constructedVariant.userType());
+}
+
+void tst_QVariant::debugStream_data()
+{
+ QTest::addColumn<QVariant>("variant");
+ QTest::addColumn<int>("typeId");
+ for (int id = 0; id < QMetaType::LastGuiType + 1; ++id) {
+ const char *tagName = QMetaType::typeName(id);
+ if (!tagName)
+ continue;
+ if (id != QMetaType::Void) {
+ QTest::newRow(tagName) << QVariant(static_cast<QVariant::Type>(id)) << id;
+ }
+ }
+ QTest::newRow("QBitArray(111)") << QVariant(QBitArray(3, true)) << qMetaTypeId<QBitArray>();
+ QTest::newRow("CustomStreamableClass") << QVariant(qMetaTypeId<CustomStreamableClass>(), 0) << qMetaTypeId<CustomStreamableClass>();
+ QTest::newRow("MyClass") << QVariant(qMetaTypeId<MyClass>(), 0) << qMetaTypeId<MyClass>();
+ QTest::newRow("InvalidVariant") << QVariant() << int(QMetaType::UnknownType);
+ QTest::newRow("CustomQObject") << QVariant::fromValue(this) << qMetaTypeId<tst_QVariant*>();
+}
+
+void tst_QVariant::debugStream()
+{
+ QFETCH(QVariant, variant);
+ QFETCH(int, typeId);
+
+ MessageHandler msgHandler(typeId);
+ qDebug() << variant;
+ QVERIFY(msgHandler.testPassed());
+}
+
+struct MessageHandlerType : public MessageHandler
+{
+ MessageHandlerType(const int typeId)
+ : MessageHandler(typeId, handler)
+ {}
+ 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());
+ }
+};
+
+void tst_QVariant::debugStreamType_data()
+{
+ debugStream_data();
+}
+
+void tst_QVariant::debugStreamType()
+{
+ QFETCH(QVariant, variant);
+ QFETCH(int, typeId);
+
+ MessageHandlerType msgHandler(typeId);
+ qDebug() << QVariant::Type(typeId);
+ QVERIFY(msgHandler.testPassed());
+}
+
+void tst_QVariant::guiVariantAtExit()
+{
+ // 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 palette = QPalette();
+ Q_UNUSED(cursor);
+ Q_UNUSED(point);
+ Q_UNUSED(icon);
+ Q_UNUSED(image);
+ Q_UNUSED(palette);
+ QVERIFY(true);
+}
QTEST_MAIN(tst_QVariant)
#include "tst_qvariant.moc"
projects / profile / ivi / qtbase.git / blobdiff