← Back to branch summary

~unity-2d-team/gconf-qt/trunk

« back to all changes in this revision

Viewing changes to libgq-fremantle/gconf/test-gconf.cpp

  • Committer: Michael Casadevall
  • Date: 2011-01-14 20:37:52 UTC
  • mfrom: (33.1.7 libQtGConf-natty)
  • Revision ID: mcasadevall@ubuntu.com-20110114203752-esunu11srfqxowub
Merge natty release onto trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
libgq-fremantle/gconf/test-gconf.cpp
1
 
#include "test-gconf.h"
2
 
 
3
 
#define MYLOGLEVEL 2
4
 
void myMessageOutput(QtMsgType type, const char *msg)
5
 
{
6
 
    switch (type) {
7
 
    case QtDebugMsg:
8
 
        if (MYLOGLEVEL <= 0)
9
 
            fprintf(stderr, "Debug: %s\n", msg);
10
 
        break;
11
 
    case QtWarningMsg:
12
 
        if (MYLOGLEVEL <= 1)
13
 
            fprintf(stderr, "Warning: %s\n", msg);
14
 
        break;
15
 
    case QtCriticalMsg:
16
 
        if (MYLOGLEVEL <= 2)
17
 
            fprintf(stderr, "Critical: %s\n", msg);
18
 
        break;
19
 
    case QtFatalMsg:
20
 
        if (MYLOGLEVEL <= 3)
21
 
            fprintf(stderr, "Fatal: %s\n", msg);
22
 
        abort();
23
 
    }
24
 
}
25
 
 
26
 
//
27
 
// Definition of testcases: Normal tests
28
 
//
29
 
 
30
 
void GConfItemTests::timeout()
31
 
{
32
 
    timed_out = true;
33
 
    timer.stop();
34
 
}
35
 
 
36
 
// Before all tests
37
 
void GConfItemTests::initTestCase()
38
 
{
39
 
    connect(&timer, SIGNAL(timeout()),
40
 
            this, SLOT(timeout()));
41
 
}
42
 
 
43
 
// After all tests
44
 
void GConfItemTests::cleanupTestCase()
45
 
{
46
 
}
47
 
 
48
 
// Before each test
49
 
void GConfItemTests::init()
50
 
{
51
 
    boolItem = new GConfItem("/Test/Bool");
52
 
    intItem = new GConfItem("/Test/Int");
53
 
    stringItem = new GConfItem("/Test/String");
54
 
    doubleItem = new GConfItem("/Test/Double");
55
 
    stringListItem = new GConfItem("/Test/StringList");
56
 
    intListItem = new GConfItem("/Test/IntList");
57
 
    doubleListItem = new GConfItem("/Test/DoubleList");
58
 
    boolListItem = new GConfItem("/Test/BoolList");
59
 
    unsetBeforeItem = new GConfItem("/Test/UnsetBefore");
60
 
    unsetAfterItem = new GConfItem("/Test/UnsetAfter");
61
 
    signalSpy = new SignalListener();
62
 
    QObject::connect(boolItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));
63
 
    QObject::connect(intItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));
64
 
    QObject::connect(stringItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));
65
 
    QObject::connect(doubleItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));
66
 
    QObject::connect(stringListItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));
67
 
    QObject::connect(intListItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));
68
 
    QObject::connect(doubleListItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));
69
 
    QObject::connect(boolListItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));
70
 
}
71
 
 
72
 
// After each test
73
 
void GConfItemTests::cleanup()
74
 
{
75
 
    QObject::disconnect(boolItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));
76
 
    QObject::disconnect(intItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));
77
 
    QObject::disconnect(stringItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));
78
 
    QObject::disconnect(doubleItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));
79
 
    QObject::disconnect(stringListItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));
80
 
    QObject::disconnect(intListItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));
81
 
    QObject::disconnect(doubleListItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));
82
 
    QObject::disconnect(boolListItem, SIGNAL(valueChanged()), signalSpy, SLOT(valueChanged()));
83
 
    delete signalSpy;
84
 
    delete boolItem;
85
 
    delete intItem;
86
 
    delete stringItem;
87
 
    delete doubleItem;
88
 
    delete stringListItem;
89
 
    delete intListItem;
90
 
    delete doubleListItem;
91
 
    delete boolListItem;
92
 
    delete unsetBeforeItem;
93
 
    delete unsetAfterItem;
94
 
 
95
 
    timer.stop();
96
 
}
97
 
 
98
 
void GConfItemTests::path()
99
 
{
100
 
    QCOMPARE(boolItem->key(), QString("/Test/Bool"));
101
 
    QCOMPARE(intItem->key(), QString("/Test/Int"));
102
 
    QCOMPARE(stringItem->key(), QString("/Test/String"));
103
 
    QCOMPARE(doubleItem->key(), QString("/Test/Double"));
104
 
    QCOMPARE(stringListItem->key(), QString("/Test/StringList"));
105
 
    QCOMPARE(intListItem->key(), QString("/Test/IntList"));
106
 
    QCOMPARE(doubleListItem->key(), QString("/Test/DoubleList"));
107
 
    QCOMPARE(boolListItem->key(), QString("/Test/BoolList"));
108
 
    QCOMPARE(unsetBeforeItem->key(), QString("/Test/UnsetBefore"));
109
 
    QCOMPARE(unsetAfterItem->key(), QString("/Test/UnsetAfter"));
110
 
}
111
 
 
112
 
void GConfItemTests::external_values()
113
 
{
114
 
    // These values are set before this program starts.
115
 
    QCOMPARE(boolItem->value().toBool(), true);
116
 
    QCOMPARE(intItem->value().toInt(), 123);
117
 
    QCOMPARE(stringItem->value().toString(), QString("Hello GConf"));
118
 
    QCOMPARE(doubleItem->value().toDouble(), 3.5);
119
 
    QCOMPARE(stringListItem->value().toStringList(), QStringList() << "Hello" << "GConf" << QString::fromUtf8("ÄÖÜ"));
120
 
    QCOMPARE(intListItem->value().toList(), QList<QVariant>() << 1 << 2 << 3 << 4);
121
 
    QCOMPARE(doubleListItem->value().toList(), QList<QVariant>() << 3.5 << 3.5 << 3.5);
122
 
    QCOMPARE(boolListItem->value().toList(), QList<QVariant>() << false << true << true << false);
123
 
    QCOMPARE(unsetBeforeItem->value().isValid(), false);
124
 
    QCOMPARE(unsetAfterItem->value().isValid(), true);
125
 
}
126
 
 
127
 
void GConfItemTests::set_bool()
128
 
{
129
 
    signalSpy->numberOfCalls = 0;
130
 
 
131
 
    boolItem->set(false);
132
 
    QCOMPARE(boolItem->value().toBool(), false);
133
 
    boolItem->set(true);
134
 
    QCOMPARE(boolItem->value().toBool(), true);
135
 
 
136
 
    QCOMPARE(signalSpy->numberOfCalls, 2);
137
 
}
138
 
 
139
 
void GConfItemTests::set_int()
140
 
{
141
 
    signalSpy->numberOfCalls = 0;
142
 
 
143
 
    intItem->set(12);
144
 
    QCOMPARE(intItem->value().toInt(), 12);
145
 
    intItem->set(-5);
146
 
    QCOMPARE(intItem->value().toInt(), -5);
147
 
 
148
 
    QCOMPARE(signalSpy->numberOfCalls, 2);
149
 
}
150
 
 
151
 
void GConfItemTests::set_string()
152
 
{
153
 
    signalSpy->numberOfCalls = 0;
154
 
 
155
 
    stringItem->set("Hi");
156
 
    QCOMPARE(stringItem->value().toString(), QString("Hi"));
157
 
 
158
 
    QCOMPARE(signalSpy->numberOfCalls, 1);
159
 
}
160
 
 
161
 
void GConfItemTests::set_unicode_string()
162
 
{
163
 
    signalSpy->numberOfCalls = 0;
164
 
 
165
 
    stringItem->set(QString::fromUtf8("Höäü"));
166
 
    QCOMPARE(stringItem->value().toString(), QString::fromUtf8("Höäü"));
167
 
 
168
 
    QCOMPARE(signalSpy->numberOfCalls, 1);
169
 
}
170
 
 
171
 
void GConfItemTests::set_double()
172
 
{
173
 
    signalSpy->numberOfCalls = 0;
174
 
 
175
 
    doubleItem->set(1.2345);
176
 
    QCOMPARE(doubleItem->value().toDouble(), 1.2345);
177
 
 
178
 
    QCOMPARE(signalSpy->numberOfCalls, 1);
179
 
}
180
 
 
181
 
void GConfItemTests::set_string_list()
182
 
{
183
 
    signalSpy->numberOfCalls = 0;
184
 
 
185
 
    stringListItem->set(QStringList() << "one" << "two" << "three");
186
 
    QCOMPARE(stringListItem->value().toStringList(), QStringList() << "one" << "two" << "three");
187
 
 
188
 
    QCOMPARE(signalSpy->numberOfCalls, 1);
189
 
}
190
 
 
191
 
void GConfItemTests::set_int_list()
192
 
{
193
 
    signalSpy->numberOfCalls = 0;
194
 
 
195
 
    intListItem->set(QList<QVariant>() << 10 << 11 << 12);
196
 
    QCOMPARE(intListItem->value().toList(), QList<QVariant>() << 10 << 11 << 12);
197
 
 
198
 
    QCOMPARE(signalSpy->numberOfCalls, 1);
199
 
}
200
 
 
201
 
void GConfItemTests::set_double_list()
202
 
{
203
 
    signalSpy->numberOfCalls = 0;
204
 
 
205
 
    doubleListItem->set(QList<QVariant>() << 1.1 << 2.2 << 3.3);
206
 
    QCOMPARE(doubleListItem->value().toList(), QList<QVariant>() << 1.1 << 2.2 << 3.3);
207
 
 
208
 
    QCOMPARE(signalSpy->numberOfCalls, 1);
209
 
}
210
 
 
211
 
void GConfItemTests::set_bool_list()
212
 
{
213
 
    signalSpy->numberOfCalls = 0;
214
 
 
215
 
    boolListItem->set(QList<QVariant>() << true << true << false);
216
 
    QCOMPARE(boolListItem->value().toList(), QList<QVariant>() << true << true << false);
217
 
 
218
 
    QCOMPARE(signalSpy->numberOfCalls, 1);
219
 
}
220
 
 
221
 
void GConfItemTests::unset ()
222
 
{
223
 
    signalSpy->numberOfCalls = 0;
224
 
 
225
 
    boolItem->unset();
226
 
    QCOMPARE(boolItem->value().isValid(), false);
227
 
 
228
 
    QCOMPARE(signalSpy->numberOfCalls, 1);
229
 
}
230
 
 
231
 
void GConfItemTests::list_dirs ()
232
 
{
233
 
    GConfItem test("/Test");
234
 
    QStringList dirs = test.listDirs();
235
 
 
236
 
    QVERIFY (!dirs.contains("/Test/Bool"));
237
 
    QVERIFY (!dirs.contains("/Test/Int"));
238
 
    QVERIFY (!dirs.contains("/Test/String"));
239
 
    QVERIFY (!dirs.contains("/Test/Double"));
240
 
    QVERIFY (!dirs.contains("/Test/StringList"));
241
 
    QVERIFY (!dirs.contains("/Test/IntList"));
242
 
    QVERIFY (!dirs.contains("/Test/DoubleList"));
243
 
    QVERIFY (!dirs.contains("/Test/BoolList"));
244
 
    QVERIFY (!dirs.contains("/Test/UnsetBefore"));
245
 
    QVERIFY (!dirs.contains("/Test/UnsetAfter"));
246
 
    QVERIFY (dirs.contains("/Test/Dir"));
247
 
}
248
 
 
249
 
void GConfItemTests::list_entries ()
250
 
{
251
 
    GConfItem test("/Test");
252
 
    QStringList entries = test.listEntries();
253
 
 
254
 
    QVERIFY (entries.contains("/Test/Bool"));
255
 
    QVERIFY (entries.contains("/Test/Int"));
256
 
    QVERIFY (entries.contains("/Test/String"));
257
 
    QVERIFY (entries.contains("/Test/Double"));
258
 
    QVERIFY (entries.contains("/Test/StringList"));
259
 
    QVERIFY (entries.contains("/Test/IntList"));
260
 
    QVERIFY (entries.contains("/Test/DoubleList"));
261
 
    QVERIFY (entries.contains("/Test/BoolList"));
262
 
    QVERIFY (!entries.contains("/Test/UnsetBefore"));
263
 
    QVERIFY (entries.contains("/Test/UnsetAfter"));
264
 
    QVERIFY (!entries.contains("/Test/Dir"));
265
 
}
266
 
 
267
 
void GConfItemTests::get_default ()
268
 
{
269
 
    intItem->unset();
270
 
    QCOMPARE(intItem->value(123).toInt(), 123);
271
 
    intItem->set(234);
272
 
    QCOMPARE(intItem->value(123).toInt(), 234);
273
 
}
274
 
 
275
 
void GConfItemTests::propagate ()
276
 
{
277
 
    GConfItem secondIntItem("/Test/Int");
278
 
    secondIntItem.set(3000);
279
 
    QVERIFY_TIMEOUT(2000, intItem->value() == secondIntItem.value());
280
 
    QCOMPARE(signalSpy->numberOfCalls, 1);
281
 
}
282
 
 
283
 
void GConfItemTests::set_external()
284
 
{
285
 
    // This must be the last test case.  The values that are set here
286
 
    // are checked after this program exits.
287
 
 
288
 
    boolItem->set(false);
289
 
    intItem->set(54321);
290
 
    stringItem->set("Good bye GConf");
291
 
    doubleItem->set(-2.5);
292
 
    stringListItem->set(QStringList() << "Good" << "bye" << "GConf" << QString::fromUtf8("äöü"));
293
 
    intListItem->set(QList<QVariant>() << 5 << 4 << 3 << 2 << 1);
294
 
    doubleListItem->set(QList<QVariant>() << -2.5 << -2.5);
295
 
    boolListItem->set(QList<QVariant>() << false << false << true << true);
296
 
    unsetAfterItem->set(QVariant());
297
 
}
298
 
 
299
 
QTEST_MAIN(GConfItemTests);