← Back to branch summary

~chris.gagnon/+junk/qtpim-coverage

« back to all changes in this revision

Viewing changes to tests/auto/organizer/qorganizeritemdetail/tst_qorganizeritemdetail.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/organizer/qorganizeritemdetail/tst_qorganizeritemdetail.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
 
 
44
#include "qorganizer.h"
 
45
#include <QSet>
 
46
 
 
47
//TESTED_COMPONENT=src/organizer
 
48
 
 
49
QTORGANIZER_USE_NAMESPACE
 
50
class tst_QOrganizerItemDetail : public QObject
 
51
{
 
52
Q_OBJECT
 
53
 
 
54
public:
 
55
    tst_QOrganizerItemDetail();
 
56
    virtual ~tst_QOrganizerItemDetail();
 
57
 
 
58
public slots:
 
59
    void init();
 
60
    void cleanup();
 
61
 
 
62
private slots:
 
63
    void classHierarchy();
 
64
    void assignment();
 
65
    void templates();
 
66
    void values();
 
67
    void hash();
 
68
    void datastream();
 
69
    void traits();
 
70
    void keys();
 
71
};
 
72
 
 
73
tst_QOrganizerItemDetail::tst_QOrganizerItemDetail()
 
74
{
 
75
}
 
76
 
 
77
tst_QOrganizerItemDetail::~tst_QOrganizerItemDetail()
 
78
{
 
79
}
 
80
 
 
81
void tst_QOrganizerItemDetail::init()
 
82
{
 
83
}
 
84
 
 
85
void tst_QOrganizerItemDetail::cleanup()
 
86
{
 
87
}
 
88
 
 
89
/* Test class that doesn't do the right thing */
 
90
class NonMacroCustomDetail : public QOrganizerItemDetail
 
91
{
 
92
public:
 
93
    NonMacroCustomDetail() : QOrganizerItemDetail(QOrganizerItemDetail::TypeUndefined) {}
 
94
    void doAssign(const QOrganizerItemDetail& other) {assign(other, QOrganizerItemDetail::TypeUndefined);}
 
95
    NonMacroCustomDetail(const QOrganizerItemDetail& other)
 
96
        : QOrganizerItemDetail(other, QOrganizerItemDetail::TypeUndefined) {}
 
97
};
 
98
 
 
99
class NonMacroCustomDetail2 : public QOrganizerItemDetail
 
100
{
 
101
public:
 
102
    NonMacroCustomDetail2() : QOrganizerItemDetail(QOrganizerItemDetail::TypeUndefined) {}
 
103
    void doAssign(const QOrganizerItemDetail& other) {assign(other, QOrganizerItemDetail::TypeUndefined);}
 
104
    NonMacroCustomDetail2(const QOrganizerItemDetail& other)
 
105
        : QOrganizerItemDetail(other, QOrganizerItemDetail::TypeUndefined) {}
 
106
};
 
107
 
 
108
void tst_QOrganizerItemDetail::classHierarchy()
 
109
{
 
110
    QOrganizerItemDetail f1;
 
111
    QOrganizerItemDetail f2;
 
112
 
 
113
    QVERIFY(f1.isEmpty());
 
114
    QVERIFY(f2.isEmpty());
 
115
 
 
116
    QOrganizerItemPriority p1;
 
117
    p1.setPriority(QOrganizerItemPriority::VeryHighPriority);
 
118
    QVERIFY(!p1.isEmpty());
 
119
    QVERIFY(p1.type() == QOrganizerItemDetail::TypePriority);
 
120
 
 
121
    QOrganizerItemComment m1;
 
122
    m1.setComment("Bob");
 
123
    QVERIFY(!m1.isEmpty());
 
124
    QVERIFY(m1.type() == QOrganizerItemDetail::TypeComment);
 
125
 
 
126
    QVERIFY(p1 != m1);
 
127
    QVERIFY(f1 == f2);
 
128
 
 
129
    f1 = p1; // f1 is a priority
 
130
    QVERIFY(f1 == p1);
 
131
 
 
132
    f1 = f1; // assign to itself
 
133
    QVERIFY(f1 == f1);
 
134
    QVERIFY(f1 == p1);
 
135
    QVERIFY(f1 != f2);
 
136
    QVERIFY(p1 != f2);
 
137
 
 
138
    p1 = p1; // assign leaf class to itself
 
139
    QVERIFY(p1 == p1);
 
140
    QVERIFY(f1 == p1);
 
141
    QVERIFY(p1 == f1);
 
142
 
 
143
    f2 = f1; // f2 = f1 = priority
 
144
    QVERIFY(f1 == f2);
 
145
    QVERIFY(f2 == f1);
 
146
    QVERIFY(f2 == p1);
 
147
    QVERIFY(f1 == p1);
 
148
 
 
149
    f1 = m1; // f1 = name, f2 = priority
 
150
    QVERIFY(f1 == m1);
 
151
    QVERIFY(f1 != f2);
 
152
    QVERIFY(f2 == p1);
 
153
 
 
154
    QOrganizerItemPriority p2(f2); // p2 = f2 = priority
 
155
    QVERIFY(p1 == p2);
 
156
    QVERIFY(p1 == f2);
 
157
    QCOMPARE(p2.priority(), p1.priority());
 
158
    QCOMPARE(p2.priority(), QOrganizerItemPriority::VeryHighPriority);
 
159
 
 
160
    p2 = p1; // priority to priority
 
161
    QVERIFY(p1 == p2);
 
162
    QVERIFY(p1 == f2);
 
163
    QCOMPARE(p2.priority(), p1.priority());
 
164
    QCOMPARE(p2.priority(), QOrganizerItemPriority::VeryHighPriority);
 
165
 
 
166
    p2.setPriority(QOrganizerItemPriority::VeryLowPriority); // NOTE: implicitly shared, this has caused a detach so p1 != 2
 
167
    QVERIFY(p1 != p2);
 
168
    QVERIFY(p1 == f2);
 
169
    QVERIFY(p2 != f2);
 
170
    QCOMPARE(p2.priority(), QOrganizerItemPriority::VeryLowPriority);
 
171
    QCOMPARE(p1.priority(), QOrganizerItemPriority::VeryHighPriority);
 
172
 
 
173
    /* Bad assignment */
 
174
    p2 = m1; // assign a comment to a priority
 
175
    QVERIFY(p2 != m1);
 
176
    QVERIFY(p2.type() == QOrganizerItemDetail::TypePriority);
 
177
    QVERIFY(p2.isEmpty());
 
178
 
 
179
    /* copy ctor */
 
180
    QOrganizerItemComment m2(m1);
 
181
    QVERIFY(m2 == m1);
 
182
 
 
183
    /* another bad assignment */
 
184
    m2 = p2; // priority to a comment
 
185
    QVERIFY(m2 != m1);
 
186
    QVERIFY(m2.type() == QOrganizerItemDetail::TypeComment);
 
187
    QVERIFY(m2.isEmpty());
 
188
 
 
189
    /* Copy ctor from valid type */
 
190
    QOrganizerItemDetail f3(p2);
 
191
    QVERIFY(f3 == p2);
 
192
    QVERIFY(f3.type() == QOrganizerItemDetail::TypePriority);
 
193
 
 
194
    /* Copy ctor from invalid type */
 
195
    QOrganizerItemPriority p3(m1);
 
196
    QVERIFY(p3 != m1);
 
197
    QVERIFY(p3.type() == QOrganizerItemDetail::TypePriority);
 
198
    QVERIFY(p3.isEmpty());
 
199
 
 
200
    /* Copy ctore from invalid type, through base type */
 
201
    f3 = m1;
 
202
    QOrganizerItemPriority p4(f3);
 
203
    QVERIFY(p4 != f3);
 
204
    QVERIFY(p4.type() == QOrganizerItemDetail::TypePriority);
 
205
    QVERIFY(p4.isEmpty());
 
206
 
 
207
    /* Try a reference */
 
208
    p1.setPriority(QOrganizerItemPriority::VeryLowPriority);
 
209
    QOrganizerItemDetail& ref = p1;
 
210
    QVERIFY(p1.priority() == QOrganizerItemPriority::VeryLowPriority);
 
211
    QVERIFY(p1.value(QOrganizerItemPriority::FieldPriority).toInt() == static_cast<int>(QOrganizerItemPriority::VeryLowPriority));
 
212
    QVERIFY(ref.value(QOrganizerItemPriority::FieldPriority).toInt() == static_cast<int>(QOrganizerItemPriority::VeryLowPriority));
 
213
    QVERIFY(p1 == ref);
 
214
    QVERIFY(ref == p1);
 
215
 
 
216
    /* Try changing the original */
 
217
    p1.setPriority(QOrganizerItemPriority::MediumPriority);
 
218
    QVERIFY(p1.priority() == QOrganizerItemPriority::MediumPriority);
 
219
    QVERIFY(p1.value(QOrganizerItemPriority::FieldPriority).toInt() == static_cast<int>(QOrganizerItemPriority::MediumPriority));
 
220
    QVERIFY(ref.value(QOrganizerItemPriority::FieldPriority).toInt() == static_cast<int>(QOrganizerItemPriority::MediumPriority));
 
221
    QVERIFY(p1 == ref);
 
222
    QVERIFY(ref == p1);
 
223
 
 
224
    /* Try changing the reference */
 
225
    ref.setValue(QOrganizerItemPriority::FieldPriority, QOrganizerItemPriority::LowPriority);
 
226
    QVERIFY(p1.priority() == QOrganizerItemPriority::LowPriority);
 
227
    QVERIFY(p1.value(QOrganizerItemPriority::FieldPriority).toInt() == static_cast<int>(QOrganizerItemPriority::LowPriority));
 
228
    QVERIFY(ref.value(QOrganizerItemPriority::FieldPriority).toInt() == static_cast<int>(QOrganizerItemPriority::LowPriority));
 
229
    QVERIFY(p1 == ref);
 
230
    QVERIFY(ref == p1);
 
231
 
 
232
    /* Random other test */
 
233
    NonMacroCustomDetail md;
 
234
    QVERIFY(md.type() == QOrganizerItemDetail::TypeUndefined);
 
235
    QVERIFY(md.setValue(1, "value"));
 
236
    QVERIFY(!md.isEmpty());
 
237
    md.doAssign(md); // self assignment
 
238
    QVERIFY(!md.isEmpty());
 
239
    QVERIFY(md.value(1) == "value");
 
240
 
 
241
    QOrganizerItemDetail mdv;
 
242
    mdv = md;
 
243
    QVERIFY(mdv.type() == QOrganizerItemDetail::TypeUndefined);
 
244
    QVERIFY(mdv.value(1) == "value");
 
245
 
 
246
    md = mdv;
 
247
    QVERIFY(md.type() == QOrganizerItemDetail::TypeUndefined);
 
248
    QVERIFY(md.value(1) == "value");
 
249
 
 
250
    NonMacroCustomDetail2 md2;
 
251
    QVERIFY(md2.setValue(1, "value"));
 
252
    QVERIFY(md2.type() == QOrganizerItemDetail::TypeUndefined);
 
253
    QVERIFY(md2.value(1) == "value");
 
254
    md2.doAssign(md);
 
255
    QVERIFY(md2 == md);
 
256
    md2 = md;
 
257
    QVERIFY(md.type() == QOrganizerItemDetail::TypeUndefined);
 
258
    QVERIFY(md.value(1) == "value");
 
259
 
 
260
    // Self assignment
 
261
    md2.doAssign(md2);
 
262
    QVERIFY(md2.type() == QOrganizerItemDetail::TypeUndefined);
 
263
    QVERIFY(md2.value(1) == "value");
 
264
 
 
265
    md.doAssign(md2);
 
266
    QVERIFY(md == md2);
 
267
 
 
268
    // Assigning something else
 
269
    QOrganizerItemPriority pn;
 
270
    pn.setPriority(QOrganizerItemPriority::LowestPriority);
 
271
    md2.doAssign(pn);
 
272
    QVERIFY(md2.isEmpty());
 
273
    QVERIFY(md2.type() == QOrganizerItemDetail::TypeUndefined);
 
274
 
 
275
    NonMacroCustomDetail mdb(pn);
 
276
    QVERIFY(mdb.isEmpty());
 
277
    QVERIFY(mdb.type() == QOrganizerItemDetail::TypeUndefined);
 
278
 
 
279
    NonMacroCustomDetail2 md2b(pn);
 
280
    QVERIFY(md2b.isEmpty());
 
281
    QVERIFY(md2b.type() == QOrganizerItemDetail::TypeUndefined);
 
282
}
 
283
 
 
284
void tst_QOrganizerItemDetail::assignment()
 
285
{
 
286
    QOrganizerItemPriority p1, p2;
 
287
    p1.setPriority(QOrganizerItemPriority::LowPriority);
 
288
    p2.setPriority(QOrganizerItemPriority::HighPriority);
 
289
    QVERIFY(p1 != p2);
 
290
 
 
291
    p1 = p2;
 
292
    QVERIFY(p1 == p2);
 
293
 
 
294
    QOrganizerItemComment c1;
 
295
    c1.setComment("test comment");
 
296
    QVERIFY(c1 != p1);
 
297
    c1 = p1;
 
298
    QVERIFY(c1 != p1); // assignment across types shouldn't work
 
299
    QVERIFY(c1.comment() == QString()); // should reset the detail
 
300
    QCOMPARE(c1, QOrganizerItemComment());
 
301
}
 
302
 
 
303
void tst_QOrganizerItemDetail::templates()
 
304
{
 
305
    QOrganizerItem c;
 
306
    QOrganizerItemPriority p1, p2;
 
307
    p1.setPriority(QOrganizerItemPriority::HighPriority);
 
308
    p2.setPriority(QOrganizerItemPriority::HighestPriority);
 
309
    QVERIFY(c.saveDetail(&p1));
 
310
    QVERIFY(c.saveDetail(&p2));
 
311
 
 
312
    QList<QOrganizerItemDetail> l = c.details(QOrganizerItemDetail::TypePriority);
 
313
 
 
314
    QCOMPARE(l.count(), 2);
 
315
    QCOMPARE(QOrganizerItemPriority(l.at(0)), p1);
 
316
    QCOMPARE(QOrganizerItemPriority(l.at(1)), p2);
 
317
 
 
318
    QList<QOrganizerItemDetail> l2 = c.details(QOrganizerItemDetail::TypePriority);
 
319
    QCOMPARE(l2.count(), 2);
 
320
    QCOMPARE(static_cast<QOrganizerItemPriority>(l2.at(0)), p1);
 
321
    QCOMPARE(static_cast<QOrganizerItemPriority>(l2.at(1)), p2);
 
322
}
 
323
 
 
324
void tst_QOrganizerItemDetail::values()
 
325
{
 
326
    QOrganizerItemDetail p;
 
327
 
 
328
    QCOMPARE(p.values(), (QMap<int, QVariant>()));
 
329
 
 
330
    QDateTime dt = QDateTime::currentDateTime();
 
331
    QTime t = dt.time();
 
332
    t.setHMS(t.hour(), t.minute(), t.second(), 0); // milliseconds don't round trip through ISODate
 
333
    dt.setTime(t);
 
334
    QDate d = dt.date();
 
335
 
 
336
    QDateTime ddt(d); // DateTime version of a Date (QTime())
 
337
 
 
338
    p.setValue(101, "This is a string");
 
339
    p.setValue(102, d);
 
340
    p.setValue(103, dt);
 
341
    p.setValue(104, (int)6);
 
342
 
 
343
    p.setValue(105, d.toString(Qt::ISODate));
 
344
    p.setValue(106, dt.toString(Qt::ISODate));
 
345
 
 
346
    // Test the setter that takes a QString
 
347
    p.setValue(107, "123");
 
348
 
 
349
    // and the setter that takes a QL1C
 
350
    p.setValue(QOrganizerItemPriority::FieldPriority, QVariant::fromValue(static_cast<int>(QOrganizerItemPriority::ExtremelyHighPriority)));
 
351
 
 
352
    /* Presence test */
 
353
    QVERIFY(p.hasValue(101));
 
354
    QVERIFY(p.hasValue(102));
 
355
    QVERIFY(p.hasValue(103));
 
356
    QVERIFY(p.hasValue(104));
 
357
    QVERIFY(p.hasValue(105));
 
358
    QVERIFY(p.hasValue(106));
 
359
    QVERIFY(p.hasValue(107));
 
360
    QVERIFY(p.hasValue(QOrganizerItemPriority::FieldPriority));
 
361
    QVERIFY(!p.hasValue(666));
 
362
 
 
363
    QVERIFY(p.hasValue(QOrganizerItemPriority::FieldPriority));
 
364
 
 
365
    /* Variant accessor */
 
366
    QCOMPARE(p.value(101), QVariant(QString("This is a string")));
 
367
    QCOMPARE(p.value(102), QVariant(d));
 
368
    QCOMPARE(p.value(103), QVariant(dt));
 
369
    QCOMPARE(p.value(104), QVariant((int)6));
 
370
    QCOMPARE(p.value(105), QVariant(d.toString(Qt::ISODate)));
 
371
    QCOMPARE(p.value(106), QVariant(dt.toString(Qt::ISODate)));
 
372
    QCOMPARE(p.value(107), QVariant(QString("123")));
 
373
    QCOMPARE(p.value(QOrganizerItemPriority::FieldPriority).toInt(), static_cast<int>(QOrganizerItemPriority::ExtremelyHighPriority));
 
374
 
 
375
    /* Typed accessors */
 
376
    QCOMPARE(p.value<QString>(101), QString("This is a string"));
 
377
    QCOMPARE(p.value<QString>(102), d.toString(Qt::ISODate));
 
378
    QCOMPARE(p.value<QString>(103), dt.toString(Qt::ISODate));
 
379
    QCOMPARE(p.value<QString>(104), QString("6"));
 
380
    QCOMPARE(p.value<QString>(105), d.toString(Qt::ISODate));
 
381
    QCOMPARE(p.value<QString>(106), dt.toString(Qt::ISODate));
 
382
    QCOMPARE(p.value<QString>(107), QString("123"));
 
383
    QCOMPARE(p.value<int>(QOrganizerItemPriority::FieldPriority), static_cast<int>(QOrganizerItemPriority::ExtremelyHighPriority));
 
384
 
 
385
    /* Now individual original types */
 
386
    QCOMPARE(p.value<QDate>(102), d);
 
387
    QCOMPARE(p.value<QDateTime>(103), dt);
 
388
    QCOMPARE(p.value<int>(104), 6);
 
389
 
 
390
    /* Now cross types that should fail */
 
391
    QDate id;
 
392
    QDateTime idt;
 
393
    QCOMPARE(p.value<QDate>(101), id);
 
394
    QCOMPARE(p.value<QDate>(104), id);
 
395
    QCOMPARE(p.value<QDate>(107), id);
 
396
    QCOMPARE(p.value<QDateTime>(101), idt);
 
397
    QCOMPARE(p.value<QDateTime>(104), idt);
 
398
    QCOMPARE(p.value<QDateTime>(107), idt);
 
399
    QCOMPARE(p.value<int>(102), 0);
 
400
    QCOMPARE(p.value<int>(103), 0);
 
401
    QCOMPARE(p.value<int>(101), 0);
 
402
    QCOMPARE(p.value<int>(105), 0);
 
403
    QCOMPARE(p.value<int>(106), 0);
 
404
 
 
405
    /* Cross types that should work.. */
 
406
    QCOMPARE(p.value<int>(107), 123);
 
407
    QCOMPARE(p.value<QDate>(105), d);
 
408
    QCOMPARE(p.value<QDateTime>(106), dt);
 
409
    QCOMPARE(p.value<QDate>(103), d);
 
410
    QCOMPARE(p.value<QDate>(106), d);
 
411
    QCOMPARE(p.value<QDateTime>(102), ddt);
 
412
    QCOMPARE(p.value<QDateTime>(105), ddt);
 
413
 
 
414
    /* Now set everything again */
 
415
    QMap<int, QVariant> emptyValues;
 
416
    QMap<int, QVariant> values = p.values();
 
417
    QList<int> keys = values.keys();
 
418
    foreach (int key, keys)
 
419
        QVERIFY(p.setValue(key, QVariant()));
 
420
 
 
421
    QCOMPARE(p.values(), emptyValues);
 
422
    QVERIFY(p.values().count() == 0);
 
423
    QVERIFY(!p.hasValue(101));
 
424
    QVERIFY(!p.hasValue(102));
 
425
    QVERIFY(!p.hasValue(103));
 
426
    QVERIFY(!p.hasValue(104));
 
427
    QVERIFY(!p.hasValue(105));
 
428
    QVERIFY(!p.hasValue(106));
 
429
    QVERIFY(!p.hasValue(107));
 
430
    QVERIFY(!p.hasValue(666));
 
431
 
 
432
    QVERIFY(p.value(101).toString() == QString());
 
433
    QVERIFY(p.value(101) == QVariant());
 
434
 
 
435
    values.insert(101, "This is a string");
 
436
    values.insert(102, d);
 
437
    values.insert(103, dt);
 
438
    values.insert(104, (int)6);
 
439
 
 
440
    values.insert(105, d.toString(Qt::ISODate));
 
441
    values.insert(106, dt.toString(Qt::ISODate));
 
442
    values.insert(107, "123");
 
443
    values.insert(101, QString("This is a string"));
 
444
 
 
445
    /* Set values */
 
446
    keys = values.keys();
 
447
    foreach (int key, keys)
 
448
        QVERIFY(p.setValue(key, values.value(key)));
 
449
 
 
450
    /* Now repeat the tests with our bulk set map */
 
451
    QVERIFY(p.hasValue(101));
 
452
    QVERIFY(p.hasValue(102));
 
453
    QVERIFY(p.hasValue(103));
 
454
    QVERIFY(p.hasValue(104));
 
455
    QVERIFY(p.hasValue(105));
 
456
    QVERIFY(p.hasValue(106));
 
457
    QVERIFY(p.hasValue(107));
 
458
    QVERIFY(!p.hasValue(666));
 
459
 
 
460
    /* String accessors */
 
461
    QCOMPARE(p.value(101).toString(), QString("This is a string"));
 
462
    QCOMPARE(p.value(102).toString(), d.toString(Qt::ISODate));
 
463
    QCOMPARE(p.value(103).toString(), dt.toString(Qt::ISODate));
 
464
    QCOMPARE(p.value(104).toString(), QString("6"));
 
465
    QCOMPARE(p.value(105).toString(), d.toString(Qt::ISODate));
 
466
    QCOMPARE(p.value(106).toString(), dt.toString(Qt::ISODate));
 
467
    QCOMPARE(p.value(107).toString(), QString("123"));
 
468
 
 
469
    /* Typed accessors, string first */
 
470
    QCOMPARE(p.value<QString>(101), QString("This is a string"));
 
471
    QCOMPARE(p.value<QString>(102), d.toString(Qt::ISODate));
 
472
    QCOMPARE(p.value<QString>(103), dt.toString(Qt::ISODate));
 
473
    QCOMPARE(p.value<QString>(104), QString("6"));
 
474
    QCOMPARE(p.value<QString>(105), d.toString(Qt::ISODate));
 
475
    QCOMPARE(p.value<QString>(106), dt.toString(Qt::ISODate));
 
476
    QCOMPARE(p.value<QString>(107), QString("123"));
 
477
 
 
478
    /* Now individual original types */
 
479
    QCOMPARE(p.value<QDate>(102), d);
 
480
    QCOMPARE(p.value<QDateTime>(103), dt);
 
481
    QCOMPARE(p.value<int>(104), 6);
 
482
 
 
483
    /* Now cross types that should fail */
 
484
    QCOMPARE(p.value<QDate>(101), id);
 
485
    QCOMPARE(p.value<QDate>(104), id);
 
486
    QCOMPARE(p.value<QDate>(107), id);
 
487
    QCOMPARE(p.value<QDateTime>(101), idt);
 
488
    QCOMPARE(p.value<QDateTime>(104), idt);
 
489
    QCOMPARE(p.value<QDateTime>(107), idt);
 
490
    QCOMPARE(p.value<int>(101), 0);
 
491
    QCOMPARE(p.value<int>(102), 0);
 
492
    QCOMPARE(p.value<int>(103), 0);
 
493
    QCOMPARE(p.value<int>(105), 0);
 
494
    QCOMPARE(p.value<int>(106), 0);
 
495
 
 
496
    /* Cross types that should work.. */
 
497
    QCOMPARE(p.value<int>(107), 123);
 
498
    QCOMPARE(p.value<QDate>(105), d);
 
499
    QCOMPARE(p.value<QDateTime>(106), dt);
 
500
    QCOMPARE(p.value<QDate>(103), d);
 
501
    QCOMPARE(p.value<QDate>(106), d);
 
502
    QCOMPARE(p.value<QDateTime>(102), ddt);
 
503
    QCOMPARE(p.value<QDateTime>(105), ddt);
 
504
 
 
505
    /* Reset again */
 
506
    values = p.values();
 
507
    keys = values.keys();
 
508
    foreach (int key, keys)
 
509
        QVERIFY(p.setValue(key, QVariant()));
 
510
    QCOMPARE(p.values(), emptyValues);
 
511
 
 
512
    /* Check that we can add a null variant */
 
513
    //QVERIFY(p.setValue("nullvariant", QVariant()));
 
514
    //QVERIFY(p.hasValue("nullvariant"));
 
515
    //QCOMPARE(p.value("nullvariant"), QString());
 
516
    //QCOMPARE(p.value("nullvariant"), QVariant());
 
517
    //QVERIFY(p.removeValue("nullvariant"));
 
518
    //QVERIFY(p.values().count() == 0);
 
519
 
 
520
    /* Check that adding a value, then setting it to null updates it */
 
521
    //QVERIFY(p.setValue("string", QString("string value")));
 
522
    //QCOMPARE(p.values().count(), 1);
 
523
    //QCOMPARE(p.value("string"), QString("string value"));
 
524
    //QVERIFY(p.setValue("string", QVariant()));
 
525
    //QCOMPARE(p.values().count(), 1);
 
526
    //QVERIFY(p.hasValue("string"));
 
527
    //QVERIFY(p.removeValue("string"));
 
528
    //QCOMPARE(p.values().count(), 0);
 
529
 
 
530
    /* See if adding a null QString triggers the same behaviour */
 
531
    //QVERIFY(p.setValue("string", QString("string value")));
 
532
    //QCOMPARE(p.values().count(), 1);
 
533
    //QCOMPARE(p.value("string"), QString("string value"));
 
534
    //QVERIFY(p.setValue("string", QString()));
 
535
    //QCOMPARE(p.values().count(), 1);
 
536
    //QVERIFY(p.hasValue("string"));
 
537
    //QVERIFY(p.removeValue("string"));
 
538
    //QCOMPARE(p.values().count(), 0);
 
539
 
 
540
    /* Check adding a null value removes the field */
 
541
    p.setValue(101, "stringvalue");
 
542
    QVERIFY(p.values().contains(101));
 
543
    QVERIFY(p.value(101) == QString("stringvalue"));
 
544
    p.setValue(101, QVariant());
 
545
    QVERIFY(!p.values().contains(101));
 
546
 
 
547
    /* Check adding a field whose value is an empty string */
 
548
    p.setValue(101, "");
 
549
    QVERIFY(p.values().contains(101));
 
550
    QVERIFY(p.value(101) == QString(""));
 
551
 
 
552
    /* Check accessing a missing value */
 
553
    QCOMPARE(p.value(666).toString(), QString());
 
554
    QVERIFY(p.setValue(666, "changed my mind"));
 
555
    QCOMPARE(p.value(666).toString(), QString("changed my mind"));
 
556
 
 
557
    /* Check removing a missing value */
 
558
    QVERIFY(!p.removeValue(777));
 
559
    QVERIFY(!p.removeValue(QOrganizerItemComment::FieldComment));
 
560
 
 
561
    p.setValue(107, "555");
 
562
    p.setValue(QOrganizerItemPriority::FieldPriority, "1234");
 
563
 
 
564
    /* Check removing a real value */
 
565
    QVERIFY(p.removeValue(101));
 
566
    QVERIFY(p.removeValue(107));
 
567
    QVERIFY(p.removeValue(QOrganizerItemPriority::FieldPriority));
 
568
}
 
569
 
 
570
void tst_QOrganizerItemDetail::hash()
 
571
{
 
572
    QOrganizerItemDetail detail1(QOrganizerItemDetail::TypeComment);
 
573
    detail1.setValue(QOrganizerItemComment::FieldComment, "value");
 
574
    QOrganizerItemDetail detail2(QOrganizerItemDetail::TypeComment);
 
575
    detail2.setValue(QOrganizerItemComment::FieldComment, "value");
 
576
    QOrganizerItemDetail detail3(QOrganizerItemDetail::TypeComment);
 
577
    detail3.setValue(QOrganizerItemComment::FieldComment, "different value");
 
578
    QVERIFY(qHash(detail1) == qHash(detail2));
 
579
    QVERIFY(qHash(detail1) != qHash(detail3));
 
580
    QSet<QOrganizerItemDetail> set;
 
581
    set.insert(detail1);
 
582
    set.insert(detail2);
 
583
    set.insert(detail3);
 
584
    QCOMPARE(set.size(), 2);
 
585
}
 
586
 
 
587
void tst_QOrganizerItemDetail::datastream()
 
588
{
 
589
    QByteArray buffer;
 
590
    QDataStream stream1(&buffer, QIODevice::WriteOnly);
 
591
    QOrganizerItemDetail detailIn(QOrganizerItemDetail::TypeComment);
 
592
    detailIn.setValue(QOrganizerItemComment::FieldComment, "value1");
 
593
    stream1 << detailIn;
 
594
 
 
595
    QVERIFY(buffer.size() > 0);
 
596
 
 
597
    QDataStream stream2(buffer);
 
598
    QOrganizerItemDetail detailOut;
 
599
    stream2 >> detailOut;
 
600
    QCOMPARE(detailOut, detailIn);
 
601
}
 
602
 
 
603
void tst_QOrganizerItemDetail::traits()
 
604
{
 
605
    QCOMPARE(sizeof(QOrganizerItemDetail), sizeof(void *));
 
606
    QTypeInfo<QOrganizerItemDetail> ti;
 
607
    QVERIFY(ti.isComplex);
 
608
    QVERIFY(!ti.isStatic);
 
609
    QVERIFY(!ti.isLarge);
 
610
    QVERIFY(!ti.isPointer);
 
611
    QVERIFY(!ti.isDummy);
 
612
}
 
613
 
 
614
void tst_QOrganizerItemDetail::keys()
 
615
{
 
616
    QOrganizerItemDetail d;
 
617
    QOrganizerItemDetail d2;
 
618
    QVERIFY(d.key() != d2.key());
 
619
 
 
620
    d = d2;
 
621
    QVERIFY(d.key() == d2.key());
 
622
    d.resetKey();
 
623
    QVERIFY(d.key() != d2.key());
 
624
}
 
625
 
 
626
QTEST_MAIN(tst_QOrganizerItemDetail)
 
627
#include "tst_qorganizeritemdetail.moc"