← Back to branch summary

~indicator-applet-developers/qmenumodel/trunk

« back to all changes in this revision

Viewing changes to tests/client/convertertest.cpp

  • Committer: Bileto Bot
  • Author(s): Marco Trevisan (Treviño)
  • Date: 2016-11-16 10:41:44 UTC
  • mfrom: (121.3.23 converter-improvements)
  • Revision ID: ci-train-bot@canonical.com-20161116104144-q1g8rtm2c5wvpa30
converter: cleanup and add support for more variant types

Approved by: Lukáš Tinkl

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/client/convertertest.cpp
28
28
#include <QtTest>
29
29
#include <QDebug>
30
30
 
31
 
class QGVariantType : public QObject
 
31
class QGVariantType
32
32
{
33
 
    Q_OBJECT
34
33
public:
35
34
    QGVariantType() : type(NULL) {}
36
35
    QGVariantType(const GVariantType *gvtype) : type(gvtype) {}
37
 
    QGVariantType(const QGVariantType &other) : type(other.type) {}
38
36
    const GVariantType *getType() const { return type; }
39
37
    operator const GVariantType*() const { return type; }
40
38
 
43
41
};
44
42
Q_DECLARE_METATYPE(QGVariantType);
45
43
 
46
 
class QGVariant : public QObject
 
44
class QGVariant
47
45
{
48
 
    Q_OBJECT
49
46
public:
50
47
    QGVariant() : variant(NULL) {}
51
48
    ~QGVariant() { if (variant) g_variant_unref(variant); }
52
49
    QGVariant(GVariant *gv) : variant(g_variant_ref_sink(gv)) {}
53
 
    QGVariant(const QGVariant &other) : variant(g_variant_ref_sink(other.variant)) {}
 
50
    QGVariant(const QGVariant &other) : QGVariant(other.variant) {}
54
51
    GVariant *gvariant() const { return variant; }
55
52
    operator GVariant*() const { return variant; }
56
53
 
104
101
                       << "Expected:"<< g_variant_type_peek_string(expected_type);
105
102
        }
106
103
        g_variant_unref(gv);
 
104
        g_variant_type_free(expected_type);
107
105
        return result;
108
106
    }
109
107
 
130
128
        QTest::newRow("UInt64") << QVariant::fromValue<qulonglong>(42) << QGVariantType(G_VARIANT_TYPE_UINT64);
131
129
        QTest::newRow("Double") << QVariant((double)42.42) << QGVariantType(G_VARIANT_TYPE_DOUBLE);
132
130
        QTest::newRow("String") << QVariant(QString("42")) << QGVariantType(G_VARIANT_TYPE_STRING);
 
131
        QTest::newRow("String List") << QVariant(QStringList({"42", "42"})) << QGVariantType(G_VARIANT_TYPE_STRING_ARRAY);
133
132
        QTest::newRow("ByteArray") << QVariant(QByteArray("42")) << QGVariantType(G_VARIANT_TYPE_BYTESTRING);
134
133
        QTest::newRow("Map") << QVariant(QVariantMap()) << QGVariantType(G_VARIANT_TYPE_VARDICT);
 
134
        QTest::newRow("Map Filled") << QVariant(QVariantMap({{"fooBar", 0xdeadbeef}})) << QGVariantType(G_VARIANT_TYPE_VARDICT);
135
135
        QTest::newRow("List") << QVariant(QVariantList()) << QGVariantType(G_VARIANT_TYPE_UNIT);
 
136
        QTest::newRow("List Filled") << QVariant(QVariantList({"fooBar", 0xdeadbeef})) << QGVariantType(G_VARIANT_TYPE("(su)"));
 
137
 
 
138
        QVariant result;
 
139
        result.setValue(QByteArrayList({"42", "53"}));
 
140
        QTest::newRow("ByteArrayList") << result << QGVariantType(G_VARIANT_TYPE_BYTESTRING_ARRAY);
136
141
    }
137
142
 
138
143
    void testConvertToGVariant()
143
148
        QVERIFY(compare(value, expectedType));
144
149
    }
145
150
 
 
151
    void testConvertToGVariantAndBack_data()
 
152
    {
 
153
        testConvertToGVariant_data();
 
154
    }
 
155
 
 
156
    void testConvertToGVariantAndBack()
 
157
    {
 
158
        QFETCH(QVariant, value);
 
159
 
 
160
        GVariant *gv = Converter::toGVariant(value);
 
161
        QVERIFY(gv != NULL);
 
162
 
 
163
        QCOMPARE(Converter::toQVariant(gv), value);
 
164
 
 
165
        g_variant_unref(gv);
 
166
    }
 
167
 
146
168
    void testTupleConversion()
147
169
    {
148
170
        QVariantList qTuple;
175
197
        QTest::addColumn<QVariant>("value");
176
198
        QTest::addColumn<QString>("schema");
177
199
 
 
200
        // convert to byte
 
201
        QTest::newRow("byte") << QVariant::fromValue<int>(1) << "y";
 
202
 
178
203
        // convert to integer
179
204
        QTest::newRow("integer") << QVariant::fromValue<int>(1) << "i";
180
205
        QTest::newRow("integer from double") << QVariant::fromValue<double>(1.1) << "i";
 
206
        QTest::newRow("int16") << QVariant::fromValue<int>(-1) << "n";
 
207
        QTest::newRow("uint16") << QVariant::fromValue<int>(1) << "q";
 
208
        QTest::newRow("uint32") << QVariant::fromValue<int>(1) << "u";
 
209
        QTest::newRow("int64") << QVariant::fromValue<int>(1) << "x";
 
210
        QTest::newRow("uint64") << QVariant::fromValue<int>(1) << "t";
 
211
 
 
212
        // convert to variant
 
213
        QTest::newRow("variant from int") << QVariant::fromValue<int>(1) << "v";
 
214
        QTest::newRow("variant from double") << QVariant::fromValue<double>(1.1) << "v";
 
215
        QTest::newRow("variant from string") << QVariant::fromValue<QString>("string") << "v";
181
216
 
182
217
        // convert to bool
183
218
        QTest::newRow("bool") << QVariant::fromValue<bool>(true) << "b";
242
277
        QTest::newRow("UInt64") << QGVariant(g_variant_new_uint64(53)) << (unsigned) QVariant::ULongLong;
243
278
        QTest::newRow("Double") << QGVariant(g_variant_new_double(53.3)) << (unsigned) QVariant::Double;
244
279
        QTest::newRow("String") << QGVariant(g_variant_new_string("53")) << (unsigned) QVariant::String;
 
280
        QTest::newRow("Byte string") << QGVariant(g_variant_new_bytestring("53")) << (unsigned) QVariant::ByteArray;
245
281
        QTest::newRow("Tuple") << QGVariant(g_variant_new("(si)", "foo", 53)) << (unsigned) QVariant::List;
246
282
 
247
 
        GVariantBuilder* builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
248
 
        g_variant_builder_add(builder, "{sv}", "fooo", g_variant_new_variant(g_variant_new_int64(53)));
249
 
        QTest::newRow("Map") << QGVariant(g_variant_new("a{sv}", builder)) << (unsigned) QVariant::Map;
 
283
        GVariantBuilder* builder = g_variant_builder_new(G_VARIANT_TYPE_VARDICT);
 
284
        g_variant_builder_add(builder, "{sv}", "fooo", g_variant_new_int64(53));
 
285
        QTest::newRow("Map") << QGVariant(g_variant_builder_end(builder)) << (unsigned) QVariant::Map;
250
286
        g_variant_builder_unref(builder);
251
287
 
252
288
        builder = g_variant_builder_new(G_VARIANT_TYPE("ai"));
253
289
        g_variant_builder_add(builder, "i", g_variant_new_int32(53));
254
290
        QTest::newRow("List") << QGVariant(g_variant_new("ai", builder)) << (unsigned) QVariant::List;
255
291
        g_variant_builder_unref(builder);
 
292
 
 
293
        QTest::newRow("Tuple") << QGVariant(g_variant_new("(i)", 53)) << (unsigned) QVariant::List;
 
294
 
 
295
        const gchar *byteArray[] = {"42", "53", NULL};
 
296
        QTest::newRow("ByteArrayList") << QGVariant(g_variant_new_bytestring_array(byteArray, -1)) << (unsigned) QMetaType::QByteArrayList;
 
297
        QTest::newRow("String List") << QGVariant(g_variant_new_strv(byteArray, -1)) << (unsigned) QVariant::StringList;
256
298
    }
257
299
 
258
300
    void testConvertToQVariant()
263
305
        QVERIFY(compare(value, (QVariant::Type) expectedType));
264
306
    }
265
307
 
 
308
    void testConvertToQVariantAndBack_data()
 
309
    {
 
310
        testConvertToQVariant_data();
 
311
    }
 
312
 
 
313
    void testConvertToQVariantAndBack()
 
314
    {
 
315
        QFETCH(QGVariant, value);
 
316
 
 
317
        QVariant qv = Converter::toQVariant(value);
 
318
        QVERIFY(qv.isValid());
 
319
 
 
320
        GVariant *gv = Converter::toGVariant(qv);
 
321
        gboolean equals = g_variant_equal(value, gv);
 
322
 
 
323
        if (!equals && qv.type() == QVariant::List) {
 
324
            QVERIFY(g_variant_type_is_array(g_variant_get_type(value)));
 
325
            QVERIFY(g_variant_type_is_tuple(g_variant_get_type(gv)));
 
326
 
 
327
            gsize vsize = g_variant_n_children(value);
 
328
            QCOMPARE(vsize, g_variant_n_children(gv));
 
329
 
 
330
            for (gsize i = 0; i < vsize; ++i) {
 
331
                equals = g_variant_equal(g_variant_get_child_value(value, i), g_variant_get_child_value(gv, i));
 
332
                if (!equals)
 
333
                    break;
 
334
            }
 
335
        }
 
336
 
 
337
        if (!equals) {
 
338
            gchar *vs = g_variant_print(value, TRUE);
 
339
            gchar *gvs = g_variant_print(gv, TRUE);
 
340
            qWarning() << "Values do not match. Old" << vs << "converted" << gvs;
 
341
            g_free(vs);
 
342
            g_free(gvs);
 
343
        }
 
344
 
 
345
        g_variant_unref(gv);
 
346
        QVERIFY(equals != FALSE);
 
347
    }
 
348
 
266
349
    void testConvertToQVariantFromString_data()
267
350
    {
268
351
        QTest::addColumn<QString>("value");
279
362
        QTest::newRow("Double") << "double 65" << (unsigned) QVariant::Double;
280
363
        QTest::newRow("String") << "string '65'" << (unsigned) QVariant::String;
281
364
        QTest::newRow("String simple") << "\"65\"" << (unsigned) QVariant::String;
 
365
        QTest::newRow("String List") << "['foo', 'bar']" << (unsigned) QVariant::StringList;
 
366
        QTest::newRow("Byte string") << "b'fooo'" << (unsigned) QVariant::ByteArray;
282
367
        QTest::newRow("Map") << "{'foo': <65>}" << (unsigned) QVariant::Map;
283
368
        QTest::newRow("List") << "[65, 66]" << (unsigned) QVariant::List;
284
369
        QTest::newRow("Tuple") << "('foo', 65)" << (unsigned) QVariant::List;
 
370
        QTest::newRow("ByteArrayList") << "[b'foo', b'bar']" << (unsigned) QMetaType::QByteArrayList;
285
371
    }
286
372
 
287
373
    void testConvertToQVariantFromString()