← Back to branch summary

~chris.gagnon/+junk/qtpim-coverage

« back to all changes in this revision

Viewing changes to tests/auto/contacts/qcontactdetail/tst_qcontactdetail.cpp

  • Committer: chris.gagnon
  • Date: 2013-12-10 23:09:37 UTC
  • Revision ID: chris.gagnon@canonical.com-20131210230937-2akf1ft1edcttk87
first post

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/auto/contacts/qcontactdetail/tst_qcontactdetail.cpp
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
 
4
** Contact: http://www.qt-project.org/legal
 
5
**
 
6
** This file is part of the test suite of the Qt Toolkit.
 
7
**
 
8
** $QT_BEGIN_LICENSE:LGPL$
 
9
** Commercial License Usage
 
10
** Licensees holding valid commercial Qt licenses may use this file in
 
11
** accordance with the commercial license agreement provided with the
 
12
** Software or, alternatively, in accordance with the terms contained in
 
13
** a written agreement between you and Digia.  For licensing terms and
 
14
** conditions see http://qt.digia.com/licensing.  For further information
 
15
** use the contact form at http://qt.digia.com/contact-us.
 
16
**
 
17
** GNU Lesser General Public License Usage
 
18
** Alternatively, this file may be used under the terms of the GNU Lesser
 
19
** General Public License version 2.1 as published by the Free Software
 
20
** Foundation and appearing in the file LICENSE.LGPL included in the
 
21
** packaging of this file.  Please review the following information to
 
22
** ensure the GNU Lesser General Public License version 2.1 requirements
 
23
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 
24
**
 
25
** In addition, as a special exception, Digia gives you certain additional
 
26
** rights.  These rights are described in the Digia Qt LGPL Exception
 
27
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 
28
**
 
29
** GNU General Public License Usage
 
30
** Alternatively, this file may be used under the terms of the GNU
 
31
** General Public License version 3.0 as published by the Free Software
 
32
** Foundation and appearing in the file LICENSE.GPL included in the
 
33
** packaging of this file.  Please review the following information to
 
34
** ensure the GNU General Public License version 3.0 requirements will be
 
35
** met: http://www.gnu.org/copyleft/gpl.html.
 
36
**
 
37
**
 
38
** $QT_END_LICENSE$
 
39
**
 
40
****************************************************************************/
 
41
 
 
42
#include <QtTest/QtTest>
 
43
#include <QContactDetail>
 
44
#include <qcontacts.h>
 
45
 
 
46
#include <QSet>
 
47
 
 
48
//TESTED_COMPONENT=src/contacts
 
49
 
 
50
QTCONTACTS_USE_NAMESPACE
 
51
class tst_QContactDetail : public QObject
 
52
{
 
53
Q_OBJECT
 
54
 
 
55
public:
 
56
    tst_QContactDetail();
 
57
    virtual ~tst_QContactDetail();
 
58
 
 
59
public slots:
 
60
    void init();
 
61
    void cleanup();
 
62
 
 
63
private slots:
 
64
    void classHierarchy();
 
65
    void assignment();
 
66
    void templates();
 
67
    void contexts();
 
68
    void values();
 
69
    void hash();
 
70
    void datastream();
 
71
    void traits();
 
72
    void keys();
 
73
    void detailUris();
 
74
};
 
75
 
 
76
tst_QContactDetail::tst_QContactDetail()
 
77
{
 
78
}
 
79
 
 
80
tst_QContactDetail::~tst_QContactDetail()
 
81
{
 
82
}
 
83
 
 
84
void tst_QContactDetail::init()
 
85
{
 
86
}
 
87
 
 
88
void tst_QContactDetail::cleanup()
 
89
{
 
90
}
 
91
 
 
92
void tst_QContactDetail::classHierarchy()
 
93
{
 
94
    QContactDetail f1;
 
95
    QContactDetail f2;
 
96
 
 
97
    QVERIFY(f1.isEmpty());
 
98
    QVERIFY(f2.isEmpty());
 
99
 
 
100
    QContactPhoneNumber p1;
 
101
    p1.setNumber("123456");
 
102
    QVERIFY(!p1.isEmpty());
 
103
    QVERIFY(p1.type() == QContactPhoneNumber::Type);
 
104
 
 
105
    QContactName m1;
 
106
    m1.setFirstName("Bob");
 
107
    QVERIFY(!m1.isEmpty());
 
108
    QVERIFY(m1.type() == QContactName::Type);
 
109
 
 
110
    QVERIFY(p1 != m1);
 
111
    QVERIFY(f1 == f2);
 
112
 
 
113
    f1 = p1; // f1 is a phonenumber
 
114
    QVERIFY(f1 == p1);
 
115
 
 
116
    f1 = f1; // assign to itself
 
117
    QVERIFY(f1 == f1);
 
118
    QVERIFY(f1 == p1);
 
119
    QVERIFY(f1 != f2);
 
120
    QVERIFY(p1 != f2);
 
121
 
 
122
    p1 = p1; // assign leaf class to itself
 
123
    QVERIFY(p1 == p1);
 
124
    QVERIFY(f1 == p1);
 
125
    QVERIFY(p1 == f1);
 
126
 
 
127
    f2 = f1; // f2 = f1 = phonenumber
 
128
    QVERIFY(f1 == f2);
 
129
    QVERIFY(f2 == f1);
 
130
    QVERIFY(f2 == p1);
 
131
    QVERIFY(f1 == p1);
 
132
 
 
133
    f1 = m1; // f1 = name, f2 = phonenumber
 
134
    QVERIFY(f1 == m1);
 
135
    QVERIFY(f1 != f2);
 
136
    QVERIFY(f2 == p1);
 
137
 
 
138
    QContactPhoneNumber p2(f2); // p2 = f2 = phonenumber
 
139
    QVERIFY(p1 == p2);
 
140
    QVERIFY(p1 == f2);
 
141
    QCOMPARE(p2.number(), p1.number());
 
142
    QCOMPARE(p2.number(), QString("123456"));
 
143
 
 
144
    p2 = p1; // phone number to phone number
 
145
    QVERIFY(p1 == p2);
 
146
    QVERIFY(p1 == f2);
 
147
    QCOMPARE(p2.number(), p1.number());
 
148
    QCOMPARE(p2.number(), QString("123456"));
 
149
 
 
150
    p2.setNumber("5678"); // NOTE: implicitly shared, this has caused a detach so p1 != 2
 
151
    QVERIFY(p1 != p2);
 
152
    QVERIFY(p1 == f2);
 
153
    QVERIFY(p2 != f2);
 
154
    QCOMPARE(p2.number(), QString("5678"));
 
155
    QCOMPARE(p1.number(), QString("123456"));
 
156
 
 
157
    /* Bad assignment */
 
158
    p2 = m1; // assign a name to a phone number
 
159
    QVERIFY(p2 != m1);
 
160
    QVERIFY(p2.type() == QContactPhoneNumber::Type); // should still be a phone number though
 
161
    QVERIFY(p2.isEmpty());
 
162
 
 
163
    /* copy ctor */
 
164
    QContactName m2(m1);
 
165
    QVERIFY(m2 == m1);
 
166
 
 
167
    /* another bad assignment */
 
168
    m2 = p2; // phone number to a name
 
169
    QVERIFY(m2 != m1);
 
170
    QVERIFY(m2.type() == QContactName::Type);
 
171
    QVERIFY(m2.isEmpty());
 
172
 
 
173
    /* Check contexts are considered for equality */
 
174
    p2 = QContactPhoneNumber(); // new id / detach
 
175
    p2.setNumber(p1.number());
 
176
    p2.setContexts(QContactDetail::ContextHome);
 
177
    QVERIFY(p1 != p2);
 
178
    p2.removeValue(QContactDetail::FieldContext); // note, context is a value.
 
179
    QVERIFY(p1 == p2); // different ids but same values should be equal
 
180
 
 
181
    /* Copy ctor from valid type */
 
182
    QContactDetail f3(p2);
 
183
    QVERIFY(f3 == p2);
 
184
    QVERIFY(f3.type() == QContactPhoneNumber::Type);
 
185
 
 
186
    /* Copy ctor from invalid type */
 
187
    QContactPhoneNumber p3(m1);
 
188
    QVERIFY(p3 != m1);
 
189
    QVERIFY(p3.type() == QContactPhoneNumber::Type);
 
190
    QVERIFY(p3.isEmpty());
 
191
 
 
192
    /* Copy ctore from invalid type, through base type */
 
193
    f3 = m1;
 
194
    QContactPhoneNumber p4(f3);
 
195
    QVERIFY(p4 != f3);
 
196
    QVERIFY(p4.type() == QContactPhoneNumber::Type);
 
197
    QVERIFY(p4.isEmpty());
 
198
 
 
199
    /* Try a reference */
 
200
    p1.setNumber("123456");
 
201
    QContactDetail& ref = p1;
 
202
    QVERIFY(p1.number() == "123456");
 
203
    QVERIFY(p1.value(QContactPhoneNumber::FieldNumber) == "123456");
 
204
    QVERIFY(ref.value(QContactPhoneNumber::FieldNumber) == "123456");
 
205
    QVERIFY(p1 == ref);
 
206
    QVERIFY(ref == p1);
 
207
 
 
208
    /* Try changing the original */
 
209
    p1.setNumber("56789");
 
210
    QVERIFY(p1.number() == "56789");
 
211
    QVERIFY(p1.value(QContactPhoneNumber::FieldNumber) == "56789");
 
212
    QVERIFY(ref.value(QContactPhoneNumber::FieldNumber) == "56789");
 
213
    QVERIFY(p1 == ref);
 
214
    QVERIFY(ref == p1);
 
215
 
 
216
    /* Try changing the reference */
 
217
    ref.setValue(QContactPhoneNumber::FieldNumber, "654321");
 
218
    QVERIFY(p1.number() == "654321");
 
219
    QVERIFY(p1.value(QContactPhoneNumber::FieldNumber) == "654321");
 
220
    QVERIFY(ref.value(QContactPhoneNumber::FieldNumber) == "654321");
 
221
    QVERIFY(p1 == ref);
 
222
    QVERIFY(ref == p1);
 
223
}
 
224
 
 
225
void tst_QContactDetail::assignment()
 
226
{
 
227
    QContactPhoneNumber p1, p2;
 
228
    p1.setNumber("12345");
 
229
    p2.setNumber("54321");
 
230
    QVERIFY(p1 != p2);
 
231
 
 
232
    p1 = p2;
 
233
    QVERIFY(p1 == p2);
 
234
 
 
235
    QContactEmailAddress e1;
 
236
    e1.setEmailAddress("test@nokia.com");
 
237
    QVERIFY(e1 != p1);
 
238
    e1 = p1;
 
239
    QVERIFY(e1 != p1); // assignment across types shouldn't work
 
240
    QVERIFY(e1.emailAddress() == QString()); // should reset the detail
 
241
    QCOMPARE(e1, QContactEmailAddress());
 
242
 
 
243
    QContactManagerEngine::setDetailAccessConstraints(&p2, QContactDetail::Irremovable);
 
244
    QVERIFY(p1 != p2);
 
245
}
 
246
 
 
247
void tst_QContactDetail::templates()
 
248
{
 
249
    QContact c;
 
250
    QContactPhoneNumber p1, p2;
 
251
    p1.setNumber("1234");
 
252
    p2.setNumber("5678");
 
253
    QVERIFY(c.saveDetail(&p1));
 
254
    QVERIFY(c.saveDetail(&p2));
 
255
 
 
256
    QList<QContactDetail> l = c.details(QContactPhoneNumber::Type);
 
257
 
 
258
    QCOMPARE(l.count(), 2);
 
259
    QCOMPARE(QContactPhoneNumber(l.at(0)), p1);
 
260
    QCOMPARE(QContactPhoneNumber(l.at(1)), p2);
 
261
 
 
262
    QList<QContactPhoneNumber> l2 = c.details<QContactPhoneNumber>();
 
263
    QCOMPARE(l2.count(), 2);
 
264
    QCOMPARE(l2.at(0), p1);
 
265
    QCOMPARE(l2.at(1), p2);
 
266
}
 
267
 
 
268
void tst_QContactDetail::contexts()
 
269
{
 
270
    QContactDetail d;
 
271
    QVERIFY(d.contexts().count() == 0);
 
272
 
 
273
    // test set contexts
 
274
    d.setContexts(QContactDetail::ContextWork);
 
275
    QVERIFY(d.contexts().count() == 1);
 
276
    QVERIFY(d.contexts().contains(QContactDetail::ContextWork));
 
277
    QVERIFY(!d.contexts().contains(QContactDetail::ContextOther));
 
278
    QVERIFY(!d.contexts().contains(QContactDetail::ContextHome));
 
279
 
 
280
    QList<int> contexts;
 
281
    contexts.append(QContactDetail::ContextHome);
 
282
    contexts.append(QContactDetail::ContextOther);
 
283
    d.setContexts(contexts);
 
284
    QVERIFY(d.contexts().count() == 2);
 
285
    QVERIFY(!d.contexts().contains(QContactDetail::ContextWork));
 
286
    QVERIFY(d.contexts().contains(QContactDetail::ContextOther));
 
287
    QVERIFY(d.contexts().contains(QContactDetail::ContextHome));
 
288
    QCOMPARE(d.contexts(), contexts);
 
289
 
 
290
    // test that contexts are values.
 
291
    QCOMPARE(d.value<QList<int> >(QContactDetail::FieldContext), d.contexts());
 
292
}
 
293
 
 
294
void tst_QContactDetail::values()
 
295
{
 
296
    QContactDetail p;
 
297
    QMap<int, QVariant> emptyValues;
 
298
    QCOMPARE(p.values(), emptyValues);
 
299
 
 
300
    QDateTime dt = QDateTime::currentDateTime();
 
301
    QTime t = dt.time();
 
302
    t.setHMS(t.hour(), t.minute(), t.second(), 0); // milliseconds don't round trip through ISODate
 
303
    dt.setTime(t);
 
304
    QDate d = dt.date();
 
305
 
 
306
    QDateTime ddt(d); // DateTime version of a Date (QTime())
 
307
 
 
308
    QVERIFY(p.setValue(QContactAddress::FieldStreet, "This is a string"));
 
309
    QVERIFY(p.setValue(QContactAddress::FieldLocality, d));
 
310
    QVERIFY(p.setValue(QContactAddress::FieldRegion, dt));
 
311
    QVERIFY(p.setValue(QContactAddress::FieldPostcode, (int)6));
 
312
    QVERIFY(p.setValue(QContactAddress::FieldSubTypes, d.toString(Qt::ISODate)));
 
313
    QVERIFY(p.setValue(QContactAddress::FieldPostOfficeBox, dt.toString(Qt::ISODate)));
 
314
 
 
315
    // Presence test (const char * version)
 
316
    QVERIFY(p.hasValue(QContactAddress::FieldStreet));
 
317
    QVERIFY(p.hasValue(QContactAddress::FieldLocality));
 
318
    QVERIFY(p.hasValue(QContactAddress::FieldRegion));
 
319
    QVERIFY(p.hasValue(QContactAddress::FieldPostcode));
 
320
    QVERIFY(p.hasValue(QContactAddress::FieldSubTypes));
 
321
    QVERIFY(p.hasValue(QContactAddress::FieldPostOfficeBox));
 
322
    QVERIFY(!p.hasValue(QContactAddress::FieldCountry));
 
323
 
 
324
    // string accessors with const char* key
 
325
    QCOMPARE(p.value(QContactAddress::FieldStreet).toString(), QString("This is a string"));
 
326
    QCOMPARE(p.value(QContactAddress::FieldLocality).toString(), d.toString(Qt::ISODate));
 
327
    QCOMPARE(p.value(QContactAddress::FieldRegion).toString(), dt.toString(Qt::ISODate));
 
328
    QCOMPARE(p.value(QContactAddress::FieldPostcode).toString(), QString("6"));
 
329
    QCOMPARE(p.value(QContactAddress::FieldSubTypes).toString(), d.toString(Qt::ISODate));
 
330
    QCOMPARE(p.value(QContactAddress::FieldPostOfficeBox).toString(), dt.toString(Qt::ISODate));
 
331
 
 
332
    // Variant accessor with const char * key
 
333
    QCOMPARE(p.value(QContactAddress::FieldStreet), QVariant(QString("This is a string")));
 
334
    QCOMPARE(p.value(QContactAddress::FieldLocality), QVariant(d));
 
335
    QCOMPARE(p.value(QContactAddress::FieldRegion), QVariant(dt));
 
336
    QCOMPARE(p.value(QContactAddress::FieldPostcode), QVariant((int)6));
 
337
    QCOMPARE(p.value(QContactAddress::FieldSubTypes), QVariant(d.toString(Qt::ISODate)));
 
338
    QCOMPARE(p.value(QContactAddress::FieldPostOfficeBox), QVariant(dt.toString(Qt::ISODate)));
 
339
 
 
340
    /* Typed accessors, string first, const char* key */
 
341
    QCOMPARE(p.value<QString>(QContactAddress::FieldStreet), QString("This is a string"));
 
342
    QCOMPARE(p.value<QString>(QContactAddress::FieldLocality), d.toString(Qt::ISODate));
 
343
    QCOMPARE(p.value<QString>(QContactAddress::FieldRegion), dt.toString(Qt::ISODate));
 
344
    QCOMPARE(p.value<QString>(QContactAddress::FieldPostcode), QString("6"));
 
345
    QCOMPARE(p.value<QString>(QContactAddress::FieldSubTypes), d.toString(Qt::ISODate));
 
346
    QCOMPARE(p.value<QString>(QContactAddress::FieldPostOfficeBox), dt.toString(Qt::ISODate));
 
347
 
 
348
    /* Now individual original types */
 
349
    QCOMPARE(p.value<QDate>(QContactAddress::FieldLocality), d);
 
350
    QCOMPARE(p.value<QDateTime>(QContactAddress::FieldRegion), dt);
 
351
    QCOMPARE(p.value<int>(QContactAddress::FieldPostcode), 6);
 
352
 
 
353
    /* Now cross types that should fail */
 
354
    QDate id;
 
355
    QDateTime idt;
 
356
    QCOMPARE(p.value<QDate>(QContactAddress::FieldStreet), id);
 
357
    QCOMPARE(p.value<QDate>(QContactAddress::FieldPostcode), id);
 
358
    QCOMPARE(p.value<QDateTime>(QContactAddress::FieldStreet), idt);
 
359
    QCOMPARE(p.value<QDateTime>(QContactAddress::FieldPostcode), idt);
 
360
    QCOMPARE(p.value<int>(QContactAddress::FieldLocality), 0);
 
361
    QCOMPARE(p.value<int>(QContactAddress::FieldRegion), 0);
 
362
    QCOMPARE(p.value<int>(QContactAddress::FieldStreet), 0);
 
363
    QCOMPARE(p.value<int>(QContactAddress::FieldSubTypes), 0);
 
364
    QCOMPARE(p.value<int>(QContactAddress::FieldPostOfficeBox), 0);
 
365
 
 
366
    /* Cross types that should work.. */
 
367
    QCOMPARE(p.value<int>(QContactAddress::FieldPostcode), 6);
 
368
    QCOMPARE(p.value<QDate>(QContactAddress::FieldSubTypes), d);
 
369
    QCOMPARE(p.value<QDateTime>(QContactAddress::FieldPostOfficeBox), dt);
 
370
    QCOMPARE(p.value<QDate>(QContactAddress::FieldRegion), d);
 
371
    QCOMPARE(p.value<QDate>(QContactAddress::FieldPostOfficeBox), d);
 
372
    QCOMPARE(p.value<QDateTime>(QContactAddress::FieldLocality), ddt);
 
373
    QCOMPARE(p.value<QDateTime>(QContactAddress::FieldSubTypes), ddt);
 
374
 
 
375
    /* Now set everything again */
 
376
    QMap<int, QVariant> values = p.values();
 
377
    QList<int> keys = values.keys();
 
378
    foreach (int key, keys)
 
379
        QVERIFY(p.setValue(key, QVariant()));
 
380
 
 
381
    QCOMPARE(p.values(), emptyValues);
 
382
    QVERIFY(p.values().count() == 0);
 
383
    QVERIFY(!p.hasValue(QContactAddress::FieldStreet));
 
384
    QVERIFY(!p.hasValue(QContactAddress::FieldLocality));
 
385
    QVERIFY(!p.hasValue(QContactAddress::FieldRegion));
 
386
    QVERIFY(!p.hasValue(QContactAddress::FieldPostcode));
 
387
    QVERIFY(!p.hasValue(QContactAddress::FieldSubTypes));
 
388
    QVERIFY(!p.hasValue(QContactAddress::FieldPostOfficeBox));
 
389
 
 
390
    QVERIFY(p.value(QContactAddress::FieldStreet).toString() == QString());
 
391
    QVERIFY(p.value(QContactAddress::FieldStreet) == QVariant());
 
392
 
 
393
    values.insert(QContactAddress::FieldStreet, "This is a string");
 
394
    values.insert(QContactAddress::FieldLocality, d);
 
395
    values.insert(QContactAddress::FieldRegion, dt);
 
396
    values.insert(QContactAddress::FieldPostcode, (int)6);
 
397
 
 
398
    values.insert(QContactAddress::FieldSubTypes, d.toString(Qt::ISODate));
 
399
    values.insert(QContactAddress::FieldPostOfficeBox, dt.toString(Qt::ISODate));
 
400
    values.insert(QContactAddress::FieldStreet, QString("This is a string"));
 
401
 
 
402
    /* Set values */
 
403
    keys = values.keys();
 
404
    foreach (int key, keys)
 
405
        QVERIFY(p.setValue(key, values.value(key)));
 
406
 
 
407
    /* Now repeat the tests with our bulk set map */
 
408
    QVERIFY(p.hasValue(QContactAddress::FieldStreet));
 
409
    QVERIFY(p.hasValue(QContactAddress::FieldLocality));
 
410
    QVERIFY(p.hasValue(QContactAddress::FieldRegion));
 
411
    QVERIFY(p.hasValue(QContactAddress::FieldPostcode));
 
412
    QVERIFY(p.hasValue(QContactAddress::FieldSubTypes));
 
413
    QVERIFY(p.hasValue(QContactAddress::FieldPostOfficeBox));
 
414
 
 
415
    /* String accessors */
 
416
    QCOMPARE(p.value(QContactAddress::FieldStreet).toString(), QString("This is a string"));
 
417
    QCOMPARE(p.value(QContactAddress::FieldLocality).toString(), d.toString(Qt::ISODate));
 
418
    QCOMPARE(p.value(QContactAddress::FieldRegion).toString(), dt.toString(Qt::ISODate));
 
419
    QCOMPARE(p.value(QContactAddress::FieldPostcode).toString(), QString("6"));
 
420
    QCOMPARE(p.value(QContactAddress::FieldSubTypes).toString(), d.toString(Qt::ISODate));
 
421
    QCOMPARE(p.value(QContactAddress::FieldPostOfficeBox).toString(), dt.toString(Qt::ISODate));
 
422
 
 
423
    /* Typed accessors, string first */
 
424
    QCOMPARE(p.value<QString>(QContactAddress::FieldStreet), QString("This is a string"));
 
425
    QCOMPARE(p.value<QString>(QContactAddress::FieldLocality), d.toString(Qt::ISODate));
 
426
    QCOMPARE(p.value<QString>(QContactAddress::FieldRegion), dt.toString(Qt::ISODate));
 
427
    QCOMPARE(p.value<QString>(QContactAddress::FieldPostcode), QString("6"));
 
428
    QCOMPARE(p.value<QString>(QContactAddress::FieldSubTypes), d.toString(Qt::ISODate));
 
429
    QCOMPARE(p.value<QString>(QContactAddress::FieldPostOfficeBox), dt.toString(Qt::ISODate));
 
430
 
 
431
    /* Now individual original types */
 
432
    QCOMPARE(p.value<QDate>(QContactAddress::FieldLocality), d);
 
433
    QCOMPARE(p.value<QDateTime>(QContactAddress::FieldRegion), dt);
 
434
    QCOMPARE(p.value<int>(QContactAddress::FieldPostcode), 6);
 
435
 
 
436
    /* Now cross types that should fail */
 
437
    QCOMPARE(p.value<QDate>(QContactAddress::FieldStreet), id);
 
438
    QCOMPARE(p.value<QDate>(QContactAddress::FieldPostcode), id);
 
439
    QCOMPARE(p.value<QDateTime>(QContactAddress::FieldStreet), idt);
 
440
    QCOMPARE(p.value<QDateTime>(QContactAddress::FieldPostcode), idt);
 
441
    QCOMPARE(p.value<int>(QContactAddress::FieldLocality), 0);
 
442
    QCOMPARE(p.value<int>(QContactAddress::FieldRegion), 0);
 
443
    QCOMPARE(p.value<int>(QContactAddress::FieldStreet), 0);
 
444
    QCOMPARE(p.value<int>(QContactAddress::FieldSubTypes), 0);
 
445
    QCOMPARE(p.value<int>(QContactAddress::FieldPostOfficeBox), 0);
 
446
 
 
447
    /* Cross types that should work.. */
 
448
    QCOMPARE(p.value<QDate>(QContactAddress::FieldSubTypes), d);
 
449
    QCOMPARE(p.value<QDateTime>(QContactAddress::FieldPostOfficeBox), dt);
 
450
    QCOMPARE(p.value<QDate>(QContactAddress::FieldRegion), d);
 
451
    QCOMPARE(p.value<QDate>(QContactAddress::FieldPostOfficeBox), d);
 
452
    QCOMPARE(p.value<QDateTime>(QContactAddress::FieldLocality), ddt);
 
453
    QCOMPARE(p.value<QDateTime>(QContactAddress::FieldSubTypes), ddt);
 
454
 
 
455
    /* Reset again */
 
456
    values = p.values();
 
457
    keys = values.keys();
 
458
    foreach (int key, keys)
 
459
        QVERIFY(p.setValue(key, QVariant()));
 
460
    QCOMPARE(p.values(), emptyValues);
 
461
 
 
462
    /* Check adding a null value removes the field */
 
463
    p.setValue(QContactAddress::FieldStreet, "stringvalue");
 
464
    QVERIFY(p.values().contains(QContactAddress::FieldStreet));
 
465
    QVERIFY(p.value(QContactAddress::FieldStreet) == QString("stringvalue"));
 
466
    p.setValue(QContactAddress::FieldStreet, QVariant());
 
467
    QVERIFY(!p.values().contains(QContactAddress::FieldStreet));
 
468
 
 
469
    /* Check adding a field whose value is an empty string */
 
470
    p.setValue(QContactAddress::FieldStreet, "");
 
471
    QVERIFY(p.values().contains(QContactAddress::FieldStreet));
 
472
    QVERIFY(p.value(QContactAddress::FieldStreet) == QString(""));
 
473
 
 
474
    /* Check accessing a missing value */
 
475
    QCOMPARE(p.value(QContactAddress::FieldStreet).toString(), QString());
 
476
    QVERIFY(p.setValue(QContactAddress::FieldStreet, "changed my mind"));
 
477
    QCOMPARE(p.value(QContactAddress::FieldStreet).toString(), QString("changed my mind"));
 
478
 
 
479
    /* Check removing a missing value */
 
480
    QVERIFY(!p.removeValue(QContactAddress::FieldCountry));
 
481
 
 
482
    p.setValue(QContactAddress::FieldCountry, "555");
 
483
    p.setValue(QContactAddress::FieldPostOfficeBox, "1234");
 
484
 
 
485
    /* Check removing a real value */
 
486
    QVERIFY(p.removeValue(QContactAddress::FieldStreet));
 
487
    QVERIFY(p.removeValue(QContactAddress::FieldCountry));
 
488
    QVERIFY(p.removeValue(QContactAddress::FieldPostOfficeBox));
 
489
}
 
490
 
 
491
void tst_QContactDetail::hash()
 
492
{
 
493
    QContactExtendedDetail detail1;
 
494
    detail1.setName("key");
 
495
    detail1.setData(QVariant("value"));
 
496
    QContactExtendedDetail detail2;
 
497
    detail2.setName("key");
 
498
    detail2.setData(QVariant("value"));
 
499
    QContactExtendedDetail detail3;
 
500
    detail3.setName("key");
 
501
    detail3.setData(QVariant("different value"));
 
502
    QVERIFY(qHash(detail1) == qHash(detail2));
 
503
    QVERIFY(qHash(detail1) != qHash(detail3));
 
504
    QSet<QContactDetail> set;
 
505
    set.insert(detail1);
 
506
    set.insert(detail2);
 
507
    set.insert(detail3);
 
508
    QCOMPARE(set.size(), 2);
 
509
}
 
510
 
 
511
void tst_QContactDetail::datastream()
 
512
{
 
513
    QByteArray buffer;
 
514
    QDataStream stream1(&buffer, QIODevice::WriteOnly);
 
515
    QContactExtendedDetail detailIn;
 
516
    detailIn.setName("key1");
 
517
    detailIn.setData(QVariant("value1"));
 
518
    detailIn.setName("key2");
 
519
    detailIn.setData(QVariant("value2"));
 
520
    stream1 << detailIn;
 
521
 
 
522
    QVERIFY(buffer.size() > 0);
 
523
 
 
524
    QDataStream stream2(buffer);
 
525
    QContactExtendedDetail detailOut;
 
526
    stream2 >> detailOut;
 
527
    QCOMPARE(detailOut, detailIn);
 
528
}
 
529
 
 
530
void tst_QContactDetail::traits()
 
531
{
 
532
    QCOMPARE(sizeof(QContactDetail), sizeof(void *));
 
533
    QVERIFY(QTypeInfo<QContactDetail>::isComplex);
 
534
    QVERIFY(!QTypeInfo<QContactDetail>::isStatic);
 
535
    QVERIFY(!QTypeInfo<QContactDetail>::isLarge);
 
536
    QVERIFY(!QTypeInfo<QContactDetail>::isPointer);
 
537
    QVERIFY(!QTypeInfo<QContactDetail>::isDummy);
 
538
}
 
539
 
 
540
void tst_QContactDetail::keys()
 
541
{
 
542
    QContactDetail d;
 
543
    QContactDetail d2;
 
544
    QVERIFY(d.key() != d2.key());
 
545
 
 
546
    d = d2;
 
547
    QVERIFY(d.key() == d2.key());
 
548
    d.resetKey();
 
549
    QVERIFY(d.key() != d2.key());
 
550
}
 
551
 
 
552
void tst_QContactDetail::detailUris()
 
553
{
 
554
    QContactDetail d;
 
555
    QVERIFY(d.detailUri().isEmpty());
 
556
 
 
557
    d.setDetailUri("I'm a detail uri");
 
558
    QVERIFY(d.detailUri() == "I'm a detail uri");
 
559
 
 
560
    d.setDetailUri(QString());
 
561
    QVERIFY(d.detailUri().isEmpty());
 
562
 
 
563
    QVERIFY(d.linkedDetailUris().isEmpty());
 
564
 
 
565
    d.setLinkedDetailUris("5555");
 
566
    QVERIFY(d.linkedDetailUris().count() == 1);
 
567
    QVERIFY(d.linkedDetailUris().count("5555") == 1);
 
568
 
 
569
    QStringList sl;
 
570
    sl << "6666" << "7777";
 
571
    d.setLinkedDetailUris(sl);
 
572
    QVERIFY(d.linkedDetailUris().count() == 2);
 
573
    QVERIFY(d.linkedDetailUris() == sl);
 
574
}
 
575
 
 
576
QTEST_MAIN(tst_QContactDetail)
 
577
#include "tst_qcontactdetail.moc"