summaryrefslogtreecommitdiffstats
path: root/tests/auto/qvariant/tst_qvariant.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'tests/auto/qvariant/tst_qvariant.cpp')
-rw-r--r--tests/auto/qvariant/tst_qvariant.cpp360
1 files changed, 341 insertions, 19 deletions
diff --git a/tests/auto/qvariant/tst_qvariant.cpp b/tests/auto/qvariant/tst_qvariant.cpp
index 9ad4482b8..3d68a734d 100644
--- a/tests/auto/qvariant/tst_qvariant.cpp
+++ b/tests/auto/qvariant/tst_qvariant.cpp
@@ -1,6 +1,7 @@
/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the test suite of the Qt Toolkit.
@@ -9,8 +10,8 @@
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
-** contained in the either Technology Preview License Agreement or the
-** Beta Release License Agreement.
+** contained in the Technology Preview License Agreement accompanying
+** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
@@ -20,21 +21,20 @@
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3.0 as published by the Free Software
-** Foundation and appearing in the file LICENSE.GPL included in the
-** packaging of this file. Please review the following information to
-** ensure the GNU General Public License version 3.0 requirements will be
-** met: http://www.gnu.org/copyleft/gpl.html.
**
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at http://qt.nokia.com/contact.
** $QT_END_LICENSE$
**
****************************************************************************/
@@ -266,7 +266,12 @@ private slots:
void convertByteArrayToBool() const;
void convertByteArrayToBool_data() const;
void toIntFromQString() const;
+ void toIntFromDouble() const;
void task256984_setValue();
+
+ void numericalConvert();
+ void moreCustomTypes();
+ void variantInVariant();
};
Q_DECLARE_METATYPE(QDate)
@@ -315,6 +320,14 @@ void tst_QVariant::constructor()
QVariant var6(qlonglong(0));
QCOMPARE(var6.type(), QVariant::LongLong);
QCOMPARE(var6.typeName(), "qlonglong");
+
+ QVariant var7 = 5;
+ QVERIFY(var7.isValid());
+ QVERIFY(!var7.isNull());
+ QVariant var8;
+ var8.setValue<int>(5);
+ QVERIFY(var8.isValid());
+ QVERIFY(!var8.isNull());
}
void tst_QVariant::copy_constructor()
@@ -1419,8 +1432,10 @@ void tst_QVariant::matrix4x4()
QVariant variant;
QMatrix4x4 matrix = qVariantValue<QMatrix4x4>(variant);
QVERIFY(matrix.isIdentity());
- qVariantSetValue(variant, QMatrix4x4().scale(2.0));
- QCOMPARE(QMatrix4x4().scale(2.0), qVariantValue<QMatrix4x4>(variant));
+ QMatrix4x4 m;
+ m.scale(2.0f);
+ qVariantSetValue(variant, m);
+ QCOMPARE(m, qVariantValue<QMatrix4x4>(variant));
void *mmatrix = QMetaType::construct(QVariant::Matrix4x4, 0);
QVERIFY(mmatrix);
@@ -2620,7 +2635,7 @@ void tst_QVariant::qvariant_cast_QObject_data() {
QTest::addColumn<QVariant>("data");
QTest::addColumn<bool>("success");
- QTest::newRow("from QObject") << QVariant(QMetaType::QObjectStar, new QObject) << true;
+ QTest::newRow("from QObject") << QVariant(QMetaType::QObjectStar, new QObject(this)) << true;
QTest::newRow("from String") << QVariant(QLatin1String("1, 2, 3")) << false;
QTest::newRow("from int") << QVariant((int) 123) << false;
}
@@ -2745,6 +2760,7 @@ void tst_QVariant::dataStar() const
v2 = qVariantFromValue(p1);
QVERIFY(v1 == v2);
+ delete p1;
}
void tst_QVariant::canConvertQStringList() const
@@ -3050,6 +3066,31 @@ void tst_QVariant::toIntFromQString() const
QVERIFY(ok);
}
+/*!
+ We verify that:
+ 1. Conversion from (64 bit) double to int works (no overflow).
+ 2. Same conversion works for QVariant::convert.
+
+ Rationale: if 2147483630 is set in float and then converted to int,
+ there will be overflow and the result will be -2147483648.
+
+ See task 250267.
+ */
+void tst_QVariant::toIntFromDouble() const
+{
+ double d = 2147483630; // max int 2147483647
+ QVERIFY((int)d == 2147483630);
+
+ QVariant var(d);
+ QVERIFY( var.canConvert( QVariant::Int ) );
+
+ bool ok;
+ int result = var.toInt(&ok);
+
+ QVERIFY( ok == true );
+ QCOMPARE(result, 2147483630);
+}
+
void tst_QVariant::task256984_setValue()
{
QTransform t; //we just take a value so that we're sure that it will be shared
@@ -3060,11 +3101,292 @@ void tst_QVariant::task256984_setValue()
QVERIFY( !v2.isDetached() );
qVariantSetValue(v2, 3); //set an integer value
-
+
QVERIFY( v1.isDetached() );
QVERIFY( v2.isDetached() );
}
+void tst_QVariant::numericalConvert()
+{
+ QVariant vfloat(float(5.3));
+ QVariant vdouble(double(5.3));
+ QVariant vreal(qreal(5.3));
+ QVariant vint(int(5));
+ QVariant vuint(uint(5));
+ QVariant vshort(short(5));
+ QVariant vlonglong(quint64(5));
+ QVariant vstringint(QString::fromLatin1("5"));
+ QVariant vstring(QString::fromLatin1("5.3"));
+
+ QVector<QVariant *> vect;
+ vect << &vfloat << &vdouble << &vreal << &vint << &vuint << &vshort<< &vlonglong << &vstringint << &vstring;
+
+ for(int i = 0; i < vect.size(); i++) {
+ double num = 5.3;
+ if (i >= 3 && i <= 7)
+ num = 5;
+ QVariant *v = vect.at(i);
+ QCOMPARE(v->toFloat() , float(num));
+ QCOMPARE(float(v->toReal()) , float(num));
+ QCOMPARE(float(v->toDouble()) , float(num));
+ if(i != 8) {
+ QCOMPARE(v->toInt() , int(num));
+ QCOMPARE(v->toUInt() , uint(num));
+ QCOMPARE(v->toULongLong() , quint64(num));
+ }
+ QCOMPARE(v->toString() , QString::number(num));
+ }
+}
+
+
+template<class T> void playWithVariant(const T &orig, bool isNull, const QString &toString, double toDouble, bool toBool)
+{
+ QVariant v = QVariant::fromValue(orig);
+ QVERIFY(v.isValid());
+ QCOMPARE(v.isNull(), isNull);
+ QCOMPARE(v.toString(), toString);
+ QCOMPARE(v.toDouble(), toDouble);
+ QCOMPARE(v.toBool(), toBool);
+ QCOMPARE(qvariant_cast<T>(v), orig);
+
+ {
+ QVariant v2 = v;
+ QCOMPARE(v2, v);
+ QVERIFY(v2.isValid());
+ QCOMPARE(v2.isNull(), isNull);
+ QCOMPARE(v2.toString(), toString);
+ QCOMPARE(v2.toDouble(), toDouble);
+ QCOMPARE(v2.toBool(), toBool);
+ QCOMPARE(qvariant_cast<T>(v2), orig);
+
+ QVariant v3;
+ v = QVariant();
+ QCOMPARE(v3, v);
+ v = v2;
+ QCOMPARE(v, v2);
+ QCOMPARE(qvariant_cast<T>(v2), qvariant_cast<T>(v));
+ QCOMPARE(v2.toString(), toString);
+ v3 = qVariantFromValue(orig);
+
+ QVERIFY(v3.isValid());
+ QCOMPARE(v3.isNull(), isNull);
+ QCOMPARE(v3.toString(), toString);
+ QCOMPARE(v3.toDouble(), toDouble);
+ QCOMPARE(v3.toBool(), toBool);
+ QCOMPARE(qvariant_cast<T>(v3), qvariant_cast<T>(v));
+ }
+
+ QVERIFY(v.isValid());
+ QCOMPARE(v.isNull(), isNull);
+ QCOMPARE(v.toString(), toString);
+ QCOMPARE(v.toDouble(), toDouble);
+ QCOMPARE(v.toBool(), toBool);
+ QCOMPARE(qvariant_cast<T>(v), orig);
+
+ if (qMetaTypeId<T>() != qMetaTypeId<QVariant>()) {
+ QCOMPARE(v.userType(), qMetaTypeId<T>());
+ QCOMPARE(QVariant::typeToName(QVariant::Type(v.userType())), QMetaType::typeName(qMetaTypeId<T>()));
+ }
+}
+
+
+struct MyPrimitive
+{
+ char x, y;
+ bool operator==(const MyPrimitive &o) const
+ {
+ return x == o.x && y == o.y;
+ }
+};
+Q_DECLARE_TYPEINFO(MyPrimitive, Q_PRIMITIVE_TYPE);
+
+struct MyData
+{
+ void *ptr;
+ MyData() : ptr(this) {}
+ ~MyData() { Q_ASSERT(ptr == this); }
+ MyData(const MyData& o) : ptr(this) { Q_ASSERT(o.ptr == &o); }
+ MyData &operator=(const MyData &o)
+ {
+ Q_ASSERT(ptr == this);
+ Q_ASSERT(o.ptr == &o);
+ return *this;
+ }
+ bool operator==(const MyData &o) const
+ {
+ Q_ASSERT(ptr == this);
+ Q_ASSERT(o.ptr == &o);
+ return true;
+ }
+};
+
+struct MyMovable
+{
+ static int count;
+ int v;
+ MyMovable() { v = count++; }
+ ~MyMovable() { count--; }
+ MyMovable(const MyMovable &o) : v(o.v) { count++; }
+
+ bool operator==(const MyMovable &o) const
+ {
+ return v == o.v;
+ }
+};
+
+int MyMovable::count = 0;
+
+
+Q_DECLARE_TYPEINFO(MyMovable, Q_MOVABLE_TYPE);
+
+Q_DECLARE_METATYPE(QList<QSize>)
+Q_DECLARE_METATYPE(MyPrimitive)
+Q_DECLARE_METATYPE(MyData)
+Q_DECLARE_METATYPE(MyMovable)
+Q_DECLARE_METATYPE(QList<MyPrimitive>)
+Q_DECLARE_METATYPE(QList<MyData>)
+Q_DECLARE_METATYPE(QList<MyMovable>)
+Q_DECLARE_METATYPE(MyPrimitive *)
+Q_DECLARE_METATYPE(MyData *)
+Q_DECLARE_METATYPE(MyMovable *)
+
+
+void tst_QVariant::moreCustomTypes()
+{
+ {
+ QList<QSize> listSize;
+ playWithVariant(listSize, false, QString(), 0, false);
+ listSize << QSize(4,5) << QSize(89,23) << QSize(5,6);
+ playWithVariant(listSize, false, QString(), 0, false);
+ }
+
+ {
+ QString str;
+ playWithVariant(str, true, QString(), 0, false);
+ str = QString::fromLatin1("123456789.123");
+ playWithVariant(str, false, str, 123456789.123, true);
+ }
+
+ {
+ QSize size;
+ playWithVariant(size, false, QString(), 0, false);
+ playWithVariant(QSize(45,78), false, QString(), 0, false);
+ }
+
+ {
+ MyData d;
+ playWithVariant(d, false, QString(), 0, false);
+ playWithVariant(&d, false, QString(), 0, false);
+ QList<MyData> l;
+ playWithVariant(l, false, QString(), 0, false);
+ l << MyData() << MyData();
+ playWithVariant(l, false, QString(), 0, false);
+ }
+
+ {
+ MyPrimitive d = { 4, 5 };
+ playWithVariant(d, false, QString(), 0, false);
+ playWithVariant(&d, false, QString(), 0, false);
+ QList<MyPrimitive> l;
+ playWithVariant(l, false, QString(), 0, false);
+ l << d;
+ playWithVariant(l, false, QString(), 0, false);
+ }
+
+ {
+ MyMovable d;
+ playWithVariant(d, false, QString(), 0, false);
+ playWithVariant(&d, false, QString(), 0, false);
+ QList<MyMovable> l;
+ playWithVariant(l, false, QString(), 0, false);
+ l << MyMovable() << d;
+ playWithVariant(l, false, QString(), 0, false);
+ }
+ QCOMPARE(MyMovable::count, 0);
+
+ {
+ playWithVariant(12.12, false, "12.12", 12.12, true);
+ playWithVariant(12.12f, false, "12.12", 12.12f, true);
+ playWithVariant('a', false, "a", 'a', true);
+ playWithVariant((unsigned char)('a'), false, "a", 'a', true);
+ playWithVariant( quint8(12), false, "\xc", 12, true);
+ playWithVariant( qint8(13), false, "\xd", 13, true);
+ playWithVariant(quint16(14), false, "14", 14, true);
+ playWithVariant( qint16(15), false, "15", 15, true);
+ playWithVariant(quint32(16), false, "16", 16, true);
+ playWithVariant( qint32(17), false, "17", 17, true);
+ playWithVariant(quint64(18), false, "18", 18, true);
+ playWithVariant( qint64(19), false, "19", 19, true);
+ playWithVariant( qint8(-12), false, "\xf4", -12, true);
+ playWithVariant( qint16(-13), false, "-13", -13, true);
+ playWithVariant( qint32(-14), false, "-14", -14, true);
+ playWithVariant( qint64(-15), false, "-15", -15, true);
+ playWithVariant(quint64(0), false, "0", 0, false);
+ playWithVariant( true, false, "true", 1, true);
+ playWithVariant( false, false, "false", 0, false);
+
+ playWithVariant(QString("hello\n"), false, "hello\n", 0, true);
+ }
+
+ {
+ int i = 5;
+ playWithVariant((void *)(&i), false, QString(), 0, false);
+ playWithVariant((void *)(0), false, QString(), 0, false);
+ }
+
+ {
+ QVariant v1 = QVariant::fromValue(5);
+ QVariant v2 = QVariant::fromValue(5.0);
+ QVariant v3 = QVariant::fromValue(quint16(5));
+ QVariant v4 = 5;
+ QVariant v5 = QVariant::fromValue(MyPrimitive());
+ QVariant v6 = QVariant::fromValue(MyMovable());
+ QVariant v7 = QVariant::fromValue(MyData());
+ playWithVariant(v1, false, "5", 5, true);
+ playWithVariant(v2, false, "5", 5, true);
+ playWithVariant(v3, false, "5", 5, true);
+ playWithVariant(v4, false, "5", 5, true);
+
+ playWithVariant(v5, false, QString(), 0, false);
+ }
+}
+
+
+void tst_QVariant::variantInVariant()
+{
+ QVariant var1 = 5;
+ QCOMPARE(var1.type(), QVariant::Int);
+ QVariant var2 = var1;
+ QCOMPARE(var2, var1);
+ QCOMPARE(var2.type(), QVariant::Int);
+ QVariant var3 = QVariant::fromValue(var1);
+ QCOMPARE(var3, var1);
+ QCOMPARE(var3.type(), QVariant::Int);
+ QVariant var4 = qvariant_cast<QVariant>(var1);
+ QCOMPARE(var4, var1);
+ QCOMPARE(var4.type(), QVariant::Int);
+ QVariant var5;
+ var5 = var1;
+ QCOMPARE(var5, var1);
+ QCOMPARE(var5.type(), QVariant::Int);
+ QVariant var6;
+ var6.setValue(var1);
+ QCOMPARE(var6, var1);
+ QCOMPARE(var6.type(), QVariant::Int);
+
+ QCOMPARE(QVariant::fromValue(var1), QVariant::fromValue(var2));
+ QCOMPARE(qvariant_cast<QVariant>(var3), QVariant::fromValue(var4));
+ QCOMPARE(qvariant_cast<QVariant>(var5), qvariant_cast<QVariant>(var6));
+
+ QString str("hello");
+ QVariant var8 = qvariant_cast<QVariant>(QVariant::fromValue(QVariant::fromValue(str)));
+ QCOMPARE((int)var8.type(), (int)QVariant::String);
+ QCOMPARE(qvariant_cast<QString>(QVariant(qvariant_cast<QVariant>(var8))), str);
+
+ QVariant var9(qMetaTypeId<QVariant>(), &var1);
+ QCOMPARE(var9.userType(), qMetaTypeId<QVariant>());
+ QCOMPARE(qvariant_cast<QVariant>(var9), var1);
+}
QTEST_MAIN(tst_QVariant)
#include "tst_qvariant.moc"
generated by cgit v1.2.3 (git 2.25.1) at 2024-05-17 10:10:57 +0000