1425     qVariantSetValue(variant, QMatrix4x4().scale(2.0));

  1437     QMatrix4x4 m;

  1426     QCOMPARE(QMatrix4x4().scale(2.0), qVariantValue<QMatrix4x4>(variant));

  1438     m.scale(2.0f);

  1439     qVariantSetValue(variant, m);

  1440     QCOMPARE(m, qVariantValue<QMatrix4x4>(variant));

  3130 

  3144 template<class T> void playWithVariant(const T &orig, bool isNull, const QString &toString, double toDouble, bool toBool)

  3145 {

  3146     QVariant v = QVariant::fromValue(orig);

  3147     QVERIFY(v.isValid());

  3148     QCOMPARE(v.isNull(), isNull);

  3149     QCOMPARE(v.toString(), toString);

  3150     QCOMPARE(v.toDouble(), toDouble);

  3151     QCOMPARE(v.toBool(), toBool);

  3152     QCOMPARE(qvariant_cast<T>(v), orig);

  3153 

  3154     {

  3155         QVariant v2 = v;

  3156         QCOMPARE(v2, v);

  3157         QVERIFY(v2.isValid());

  3158         QCOMPARE(v2.isNull(), isNull);

  3159         QCOMPARE(v2.toString(), toString);

  3160         QCOMPARE(v2.toDouble(), toDouble);

  3161         QCOMPARE(v2.toBool(), toBool);

  3162         QCOMPARE(qvariant_cast<T>(v2), orig);

  3163 

  3164         QVariant v3;

  3165         v = QVariant();

  3166         QCOMPARE(v3, v);

  3167         v = v2;

  3168         QCOMPARE(v, v2);

  3169         QCOMPARE(qvariant_cast<T>(v2), qvariant_cast<T>(v));

  3170         QCOMPARE(v2.toString(), toString);

  3171         v3 = qVariantFromValue(orig);

  3172 

  3173         QVERIFY(v3.isValid());

  3174         QCOMPARE(v3.isNull(), isNull);

  3175         QCOMPARE(v3.toString(), toString);

  3176         QCOMPARE(v3.toDouble(), toDouble);

  3177         QCOMPARE(v3.toBool(), toBool);

  3178         QCOMPARE(qvariant_cast<T>(v3), qvariant_cast<T>(v));

  3179     }

  3180 

  3181     QVERIFY(v.isValid());

  3182     QCOMPARE(v.isNull(), isNull);

  3183     QCOMPARE(v.toString(), toString);

  3184     QCOMPARE(v.toDouble(), toDouble);

  3185     QCOMPARE(v.toBool(), toBool);

  3186     QCOMPARE(qvariant_cast<T>(v), orig);

  3187 

  3188     if (qMetaTypeId<T>() != qMetaTypeId<QVariant>()) {

  3189         QCOMPARE(v.userType(), qMetaTypeId<T>());

  3190         QCOMPARE(QVariant::typeToName(QVariant::Type(v.userType())), QMetaType::typeName(qMetaTypeId<T>()));

  3191     }

  3192 }

  3193 

  3194 

  3195 struct MyPrimitive

  3196 {

  3197     char x, y;

  3198     bool operator==(const MyPrimitive &o) const

  3199     {

  3200         return x == o.x && y == o.y;

  3201     }

  3202 };

  3203 Q_DECLARE_TYPEINFO(MyPrimitive, Q_PRIMITIVE_TYPE);

  3204 

  3205 struct MyData

  3206 {

  3207     void *ptr;

  3208     MyData() : ptr(this) {}

  3209     ~MyData() { Q_ASSERT(ptr == this); }

  3210     MyData(const MyData& o) : ptr(this) { Q_ASSERT(o.ptr == &o); }

  3211     MyData &operator=(const MyData &o)

  3212     {

  3213         Q_ASSERT(ptr == this);

  3214         Q_ASSERT(o.ptr == &o);

  3215         return *this;

  3216     }

  3217     bool operator==(const MyData &o) const

  3218     {

  3219         Q_ASSERT(ptr == this);

  3220         Q_ASSERT(o.ptr == &o);

  3221         return true;

  3222     }

  3223 };

  3224 

  3225 struct MyMovable

  3226 {

  3227     static int count;

  3228     int v;

  3229     MyMovable() { v = count++; }

  3230     ~MyMovable() { count--; }

  3231     MyMovable(const MyMovable &o) : v(o.v) { count++; }

  3232 

  3233     bool operator==(const MyMovable &o) const

  3234     {

  3235         return v == o.v;

  3236     }

  3237 };

  3238 

  3239 int MyMovable::count  = 0;

  3240 

  3241 

  3242 Q_DECLARE_TYPEINFO(MyMovable, Q_MOVABLE_TYPE);

  3243 

  3244 Q_DECLARE_METATYPE(QList<QSize>)

  3245 Q_DECLARE_METATYPE(MyPrimitive)

  3246 Q_DECLARE_METATYPE(MyData)

  3247 Q_DECLARE_METATYPE(MyMovable)

  3248 Q_DECLARE_METATYPE(QList<MyPrimitive>)

  3249 Q_DECLARE_METATYPE(QList<MyData>)

  3250 Q_DECLARE_METATYPE(QList<MyMovable>)

  3251 Q_DECLARE_METATYPE(MyPrimitive *)

  3252 Q_DECLARE_METATYPE(MyData *)

  3253 Q_DECLARE_METATYPE(MyMovable *)

  3254 

  3255 

  3256 void tst_QVariant::moreCustomTypes()

  3257 {

  3258     {

  3259         QList<QSize> listSize;

  3260         playWithVariant(listSize, false, QString(), 0, false);

  3261         listSize << QSize(4,5) << QSize(89,23) << QSize(5,6);

  3262         playWithVariant(listSize, false, QString(), 0, false);

  3263     }

  3264 

  3265     {

  3266         QString str;

  3267         playWithVariant(str, true, QString(), 0, false);

  3268         str = QString::fromLatin1("123456789.123");

  3269         playWithVariant(str, false, str, 123456789.123, true);

  3270     }

  3271 

  3272     {

  3273         QSize size;

  3274         playWithVariant(size, false, QString(), 0, false);

  3275         playWithVariant(QSize(45,78), false, QString(), 0, false);

  3276     }

  3277 

  3278     {

  3279         MyData d;

  3280         playWithVariant(d, false, QString(), 0, false);

  3281         playWithVariant(&d, false, QString(), 0, false);

  3282         QList<MyData> l;

  3283         playWithVariant(l, false, QString(), 0, false);

  3284         l << MyData() << MyData();

  3285         playWithVariant(l, false, QString(), 0, false);

  3286     }

  3287 

  3288     {

  3289         MyPrimitive d = { 4, 5 };

  3290         playWithVariant(d, false, QString(), 0, false);

  3291         playWithVariant(&d, false, QString(), 0, false);

  3292         QList<MyPrimitive> l;

  3293         playWithVariant(l, false, QString(), 0, false);

  3294         l << d;

  3295         playWithVariant(l, false, QString(), 0, false);

  3296     }

  3297 

  3298     {

  3299         MyMovable d;

  3300         playWithVariant(d, false, QString(), 0, false);

  3301         playWithVariant(&d, false, QString(), 0, false);

  3302         QList<MyMovable> l;

  3303         playWithVariant(l, false, QString(), 0, false);

  3304         l << MyMovable() << d;

  3305         playWithVariant(l, false, QString(), 0, false);

  3306     }

  3307     QCOMPARE(MyMovable::count, 0);

  3308 

  3309     {

  3310         playWithVariant(12.12, false, "12.12", 12.12, true);

  3311         playWithVariant(12.12f, false, "12.12", 12.12f, true);

  3312         playWithVariant('a', false, "a", 'a', true);

  3313         playWithVariant((unsigned char)('a'), false, "a", 'a', true);

  3314         playWithVariant( quint8(12), false, "\xc", 12, true);

  3315         playWithVariant(  qint8(13), false, "\xd", 13, true);

  3316         playWithVariant(quint16(14), false, "14", 14, true);

  3317         playWithVariant( qint16(15), false, "15", 15, true);

  3318         playWithVariant(quint32(16), false, "16", 16, true);

  3319         playWithVariant( qint32(17), false, "17", 17, true);

  3320         playWithVariant(quint64(18), false, "18", 18, true);

  3321         playWithVariant( qint64(19), false, "19", 19, true);

  3322         playWithVariant(  qint8(-12), false, "\xf4", -12, true);

  3323         playWithVariant( qint16(-13), false, "-13", -13, true);

  3324         playWithVariant( qint32(-14), false, "-14", -14, true);

  3325         playWithVariant( qint64(-15), false, "-15", -15, true);

  3326         playWithVariant(quint64(0), false, "0", 0, false);

  3327         playWithVariant( true, false, "true", 1, true);

  3328         playWithVariant( false, false, "false", 0, false);

  3329 

  3330         playWithVariant(QString("hello\n"), false, "hello\n", 0, true);

  3331     }

  3332 

  3333     {

  3334         int i = 5;

  3335         playWithVariant((void *)(&i), false, QString(), 0, false);

  3336         playWithVariant((void *)(0), false, QString(), 0, false);

  3337     }

  3338 

  3339     {

  3340         QVariant v1 = QVariant::fromValue(5);

  3341         QVariant v2 = QVariant::fromValue(5.0);

  3342         QVariant v3 = QVariant::fromValue(quint16(5));

  3343         QVariant v4 = 5;

  3344         QVariant v5 = QVariant::fromValue(MyPrimitive());

  3345         QVariant v6 = QVariant::fromValue(MyMovable());

  3346         QVariant v7 = QVariant::fromValue(MyData());

  3347         playWithVariant(v1, false, "5", 5, true);

  3348         playWithVariant(v2, false, "5", 5, true);

  3349         playWithVariant(v3, false, "5", 5, true);

  3350         playWithVariant(v4, false, "5", 5, true);

  3351 

  3352         playWithVariant(v5, false, QString(), 0, false);

  3353     }

  3354 }

  3355 

  3356 

  3357 void tst_QVariant::variantInVariant()

  3358 {

  3359     QVariant var1 = 5;

  3360     QCOMPARE(var1.type(), QVariant::Int);

  3361     QVariant var2 = var1;

  3362     QCOMPARE(var2, var1);

  3363     QCOMPARE(var2.type(), QVariant::Int);

  3364     QVariant var3 = QVariant::fromValue(var1);

  3365     QCOMPARE(var3, var1);

  3366     QCOMPARE(var3.type(), QVariant::Int);

  3367     QVariant var4 = qvariant_cast<QVariant>(var1);

  3368     QCOMPARE(var4, var1);

  3369     QCOMPARE(var4.type(), QVariant::Int);

  3370     QVariant var5;

  3371     var5 = var1;

  3372     QCOMPARE(var5, var1);

  3373     QCOMPARE(var5.type(), QVariant::Int);

  3374     QVariant var6;

  3375     var6.setValue(var1);

  3376     QCOMPARE(var6, var1);

  3377     QCOMPARE(var6.type(), QVariant::Int);

  3378 

  3379     QCOMPARE(QVariant::fromValue(var1), QVariant::fromValue(var2));

  3380     QCOMPARE(qvariant_cast<QVariant>(var3), QVariant::fromValue(var4));

  3381     QCOMPARE(qvariant_cast<QVariant>(var5), qvariant_cast<QVariant>(var6));

  3382 

  3383     QString str("hello");

  3384     QVariant var8 = qvariant_cast<QVariant>(QVariant::fromValue(QVariant::fromValue(str)));

  3385     QCOMPARE((int)var8.type(), (int)QVariant::String);

  3386     QCOMPARE(qvariant_cast<QString>(QVariant(qvariant_cast<QVariant>(var8))), str);

  3387 

  3388     QVariant var9(qMetaTypeId<QVariant>(), &var1);

  3389     QCOMPARE(var9.userType(), qMetaTypeId<QVariant>());

  3390     QCOMPARE(qvariant_cast<QVariant>(var9), var1);

  3391 }

  3392 

  3393 void tst_QVariant::colorInteger()

  3394 {

  3395     QVariant v = QColor(Qt::red);

  3396     QCOMPARE(v.type(), QVariant::Color);

  3397     QCOMPARE(v.value<QColor>(), QColor(Qt::red));

  3398 

  3399     v.setValue(1000);

  3400     QCOMPARE(v.type(), QVariant::Int);

  3401     QCOMPARE(v.toInt(), 1000);

  3402 

  3403     v.setValue(QColor(Qt::yellow));

  3404     QCOMPARE(v.type(), QVariant::Color);

  3405     QCOMPARE(v.value<QColor>(), QColor(Qt::yellow));

  3406 }