1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
/*
* Copyright 2012 Canonical Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation; version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Authors:
* Renato Araujo Oliveira Filho <renato@canonical.com>
*/
extern "C" {
#include <glib.h>
}
#include "converter.h"
#include <QObject>
#include <QtTest>
#include <QDebug>
class ConverterTest : public QObject
{
Q_OBJECT
private:
bool compare(const QVariant &qv, const GVariantType *type)
{
bool result;
GVariant *gv = Converter::toGVariant(qv);
result = g_variant_type_equal(g_variant_get_type(gv), type);
if (!result) {
qWarning() << "types are different: QVariant:" << qv.typeName()
<< "Result:" << (const char*) g_variant_get_type(gv)
<< "Expected:"<< (const char*) type;
}
g_variant_unref(gv);
return result;
}
private Q_SLOTS:
/*
* Test converter QVariant to GVariant
*/
void testToGVariant()
{
// Boolean
QVERIFY(compare(QVariant(true), G_VARIANT_TYPE_BOOLEAN));
// Byte
QVERIFY(compare(QVariant::fromValue<uchar>(42), G_VARIANT_TYPE_BYTE));
// Int16
QVERIFY(compare(QVariant::fromValue<short>(-42), G_VARIANT_TYPE_INT16));
// UInt16
QVERIFY(compare(QVariant::fromValue<ushort>(-42), G_VARIANT_TYPE_UINT16));
// Int32
QVERIFY(compare(QVariant(-42), G_VARIANT_TYPE_INT32));
// UInt32
QVERIFY(compare(QVariant((uint)42), G_VARIANT_TYPE_UINT32));
// Int64
QVERIFY(compare(QVariant::fromValue<long>(-42), G_VARIANT_TYPE_INT64));
// UInt64
QVERIFY(compare(QVariant::fromValue<ulong>(42), G_VARIANT_TYPE_UINT64));
// Double
QVERIFY(compare(QVariant((double)42.42), G_VARIANT_TYPE_DOUBLE));
// String
QVERIFY(compare(QVariant(QString("42")), G_VARIANT_TYPE_STRING));
// ByteArray
QVERIFY(compare(QVariant(QByteArray("42")), G_VARIANT_TYPE_BYTESTRING));
// Map
QVERIFY(compare(QVariantMap(), G_VARIANT_TYPE_VARDICT));
}
void testTupleConversion()
{
QVariantList qTuple;
qTuple << 1 << "2" << 3.3;
GVariant *gTuple = Converter::toGVariant(qTuple);
QVERIFY(g_variant_type_is_tuple(g_variant_get_type(gTuple)));
QCOMPARE(g_variant_n_children(gTuple), (gsize)3);
GVariant *v = g_variant_get_child_value(gTuple, 0);
int v0 = g_variant_get_int32(v);
QCOMPARE(v0, 1);
g_variant_unref(v);
v = g_variant_get_child_value(gTuple, 1);
const gchar *v1 = g_variant_get_string(v, NULL);
QCOMPARE(QString(v1), QString("2"));
g_variant_unref(v);
v = g_variant_get_child_value(gTuple, 2);
gdouble v2 = g_variant_get_double(v);
QCOMPARE(v2, 3.3);
g_variant_unref(v);
g_variant_unref(gTuple);
}
};
QTEST_MAIN(ConverterTest)
#include "convertertest.moc"
|
