#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 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;
QTest::newRow("0xfffffffff") << uint(0xfffffffff);
QTest::newRow("LastCoreType + 1") << uint(QMetaType::LastCoreType + 1);
QVERIFY(!QMetaType::isRegistered(QMetaType::LastCoreType + 1));
- QTest::newRow("LastGuiType + 1") << uint(QMetaType::LastGuiType + 1);
- QVERIFY(!QMetaType::isRegistered(QMetaType::LastGuiType + 1));
- QTest::newRow("LastWidgetsType + 1") << uint(QMetaType::LastWidgetsType + 1);
- QVERIFY(!QMetaType::isRegistered(QMetaType::LastWidgetsType + 1));
}
-struct MessageHandlerInvalidType
-{
- MessageHandlerInvalidType()
- : oldMsgHandler(qInstallMsgHandler(handler))
- {
- ok = false;
- }
-
- ~MessageHandlerInvalidType()
- {
- qInstallMsgHandler(oldMsgHandler);
- }
-
- QtMsgHandler oldMsgHandler;
-
- static void handler(QtMsgType type, const char *txt)
- {
- QString msg = QString::fromLatin1(txt);
- // uint(-1) can be platform dependent so we check only beginning of the message.
- ok = msg.startsWith("Trying to construct an instance of an invalid type, type id:");
- QVERIFY2(ok, (QString::fromLatin1("Message is not started correctly: '") + msg + '\'').toLatin1().constData());
- }
- static bool ok;
-};
-bool MessageHandlerInvalidType::ok;
-
void tst_QVariant::constructor_invalid()
{
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
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 = QVariant::fromValue(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::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;
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;
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 ) );
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( "sizepolicy_valid" ) << QVariant::fromValue( QSizePolicy( QSizePolicy::Fixed, QSizePolicy::Fixed ) ) << 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;
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;
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. */
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");
- var.setValue(ha);
- var3 = var;
+ QVariant varCopy;
+ const CustomComparable userType = CustomComparable(42);
+ var.setValue(userType);
+ varCopy = var;
- QCOMPARE(qvariant_cast<QHostAddress>(var3), ha);
+ const CustomComparable copiedType = qvariant_cast<CustomComparable>(varCopy);
+ QCOMPARE(copiedType, userType);
+ QCOMPARE(copiedType.myValue, 42);
}
void tst_QVariant::convertBoolToByteArray() const
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