← Back to branch summary

~chris.gagnon/+junk/qtpim-coverage

« back to all changes in this revision

Viewing changes to tests/auto/organizer/qorganizeritemfilter/tst_qorganizeritemfilter.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/qorganizeritemfilter/tst_qorganizeritemfilter.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
#include <QtTest/QtTest>
 
42
#include <QMetaType>
 
43
 
 
44
#include "qorganizer.h"
 
45
#include "qorganizeritemengineid.h"
 
46
 
 
47
//TESTED_COMPONENT=src/organizer
 
48
 
 
49
QTORGANIZER_USE_NAMESPACE
 
50
 
 
51
Q_DECLARE_METATYPE(QOrganizerItem)
 
52
Q_DECLARE_METATYPE(QOrganizerItemFilter)
 
53
Q_DECLARE_METATYPE(QOrganizerItemDetailFieldFilter)
 
54
 
 
55
class tst_QOrganizerItemFilter : public QObject
 
56
{
 
57
Q_OBJECT
 
58
 
 
59
public:
 
60
    tst_QOrganizerItemFilter();
 
61
    virtual ~tst_QOrganizerItemFilter();
 
62
 
 
63
public slots:
 
64
    void init();
 
65
    void cleanup();
 
66
private slots:
 
67
    void classHierarchy();
 
68
    void intersectionFilter();
 
69
    void unionFilter();
 
70
    void detailFilter();
 
71
    void detailFieldFilter();
 
72
    void detailRangeFilter();
 
73
    void boringFilters();
 
74
    void idListFilter();
 
75
    void collectionFilter();
 
76
    void canonicalizedFilter();
 
77
    void canonicalizedFilter_data();
 
78
    void testFilter();
 
79
    void testFilter_data();
 
80
 
 
81
    void datastream();
 
82
    void datastream_data();
 
83
    void traits();
 
84
 
 
85
    void sortObject(); // should perhaps be in a different test :)
 
86
    void sortTraits();
 
87
    void testDebugStreamOut();
 
88
    void testDebugStreamOut_data();
 
89
};
 
90
 
 
91
class BasicItemLocalId : public QOrganizerItemEngineId
 
92
{
 
93
public:
 
94
    BasicItemLocalId(uint id) : m_id(id) {}
 
95
    bool isEqualTo(const QOrganizerItemEngineId* other) const {
 
96
        return m_id == static_cast<const BasicItemLocalId*>(other)->m_id;
 
97
    }
 
98
    bool isLessThan(const QOrganizerItemEngineId* other) const {
 
99
        return m_id < static_cast<const BasicItemLocalId*>(other)->m_id;
 
100
    }
 
101
    QOrganizerItemEngineId* clone() const {
 
102
        BasicItemLocalId* cloned = new BasicItemLocalId(m_id);
 
103
        return cloned;
 
104
    }
 
105
    QString managerUri() const {
 
106
        static const QString uri(QStringLiteral("qtorganizer:basicItem:"));
 
107
        return uri;
 
108
    }
 
109
    QDebug& debugStreamOut(QDebug& dbg) const {
 
110
        return dbg << m_id;
 
111
    }
 
112
    QString toString() const {
 
113
        return QString::number(m_id);
 
114
    }
 
115
    uint hash() const {
 
116
        return m_id;
 
117
    }
 
118
 
 
119
private:
 
120
    uint m_id;
 
121
};
 
122
 
 
123
class BasicCollectionLocalId : public QOrganizerCollectionEngineId
 
124
{
 
125
public:
 
126
    BasicCollectionLocalId(uint id) : m_id(id) {}
 
127
    bool isEqualTo(const QOrganizerCollectionEngineId* other) const {
 
128
        return m_id == static_cast<const BasicCollectionLocalId*>(other)->m_id;
 
129
    }
 
130
    bool isLessThan(const QOrganizerCollectionEngineId* other) const {
 
131
        return m_id < static_cast<const BasicCollectionLocalId*>(other)->m_id;
 
132
    }
 
133
    QOrganizerCollectionEngineId* clone() const {
 
134
        BasicCollectionLocalId* cloned = new BasicCollectionLocalId(m_id);
 
135
        return cloned;
 
136
    }
 
137
    QString managerUri() const {
 
138
        static const QString uri(QStringLiteral("qtorganizer:basicCollection:"));
 
139
        return uri;
 
140
    }
 
141
    QDebug& debugStreamOut(QDebug& dbg) const {
 
142
        return dbg << m_id;
 
143
    }
 
144
    QString toString() const {
 
145
        return QString::number(m_id);
 
146
    }
 
147
    uint hash() const {
 
148
        return m_id;
 
149
    }
 
150
 
 
151
private:
 
152
    uint m_id;
 
153
};
 
154
 
 
155
QOrganizerItemId makeId(uint id)
 
156
{
 
157
    return QOrganizerItemId(new BasicItemLocalId(id));
 
158
}
 
159
 
 
160
QOrganizerCollectionId makeCId(uint id)
 
161
{
 
162
    return QOrganizerCollectionId(new BasicCollectionLocalId(id));
 
163
}
 
164
 
 
165
tst_QOrganizerItemFilter::tst_QOrganizerItemFilter()
 
166
{
 
167
}
 
168
 
 
169
tst_QOrganizerItemFilter::~tst_QOrganizerItemFilter()
 
170
{
 
171
}
 
172
 
 
173
void tst_QOrganizerItemFilter::init()
 
174
{
 
175
}
 
176
 
 
177
void tst_QOrganizerItemFilter::cleanup()
 
178
{
 
179
}
 
180
 
 
181
void tst_QOrganizerItemFilter::classHierarchy()
 
182
{
 
183
    /* Test "casting" up and down the hierarchy */
 
184
    QOrganizerItemDetailFieldFilter df;
 
185
    QVERIFY(df.type() == QOrganizerItemFilter::DetailFieldFilter);
 
186
    df.setDetail(QOrganizerItemDetail::TypeUndefined, 101);
 
187
    df.setValue(42);
 
188
 
 
189
    QOrganizerItemFilter f = df;
 
190
    QVERIFY(f.type() == QOrganizerItemFilter::DetailFieldFilter);
 
191
 
 
192
    QOrganizerItemDetailFieldFilter df2 = f;
 
193
    QVERIFY(df2.type() == QOrganizerItemFilter::DetailFieldFilter);
 
194
    QVERIFY(df2.detailType() == QOrganizerItemDetail::TypeUndefined);
 
195
    QVERIFY(df2.detailField() == -1);
 
196
    QVERIFY(df2.value() == 42);
 
197
 
 
198
    /* Now try to check if we dangle pointers at all */
 
199
    {
 
200
        QOrganizerItemFilter f2 = df2;
 
201
    }
 
202
    QVERIFY(df2.type() == QOrganizerItemFilter::DetailFieldFilter);
 
203
    QVERIFY(df2.detailType() == QOrganizerItemDetail::TypeUndefined);
 
204
    QVERIFY(df2.detailField() == -1);
 
205
    QVERIFY(df2.value() == 42);
 
206
 
 
207
    {
 
208
        QOrganizerItemDetailFieldFilter sdf2 = df2;
 
209
        sdf2.setDetail(QOrganizerItemDetail::TypeComment, QOrganizerItemComment::FieldComment);
 
210
        QVERIFY(sdf2.detailType() == QOrganizerItemDetail::TypeComment);
 
211
        QVERIFY(df2.detailType() == QOrganizerItemDetail::TypeUndefined);
 
212
    }
 
213
    QVERIFY(df2.type() == QOrganizerItemFilter::DetailFieldFilter);
 
214
    QVERIFY(df2.detailType() == QOrganizerItemDetail::TypeUndefined);
 
215
    QVERIFY(df2.detailField() == -1);
 
216
    QVERIFY(df2.value() == 42);
 
217
 
 
218
    /* Try creating a default filter and making sure we don't break */
 
219
    QOrganizerItemFilter deff, deff2;
 
220
 
 
221
    QVERIFY(deff.type() == QOrganizerItemFilter::DefaultFilter);
 
222
    QVERIFY(deff == deff);
 
223
    QVERIFY(deff == deff2);
 
224
    QVERIFY(deff != df2);
 
225
    QVERIFY(df2 != deff);
 
226
 
 
227
    QOrganizerItemFilter fdeff = deff;
 
228
    QVERIFY(fdeff.type() == QOrganizerItemFilter::DefaultFilter);
 
229
    QVERIFY(fdeff == deff);
 
230
    QVERIFY(fdeff == deff2);
 
231
 
 
232
    /* Now some "invalid" filters */
 
233
    QOrganizerItemInvalidFilter iff, iff2;
 
234
 
 
235
    QVERIFY(iff.type() == QOrganizerItemFilter::InvalidFilter);
 
236
    QVERIFY(iff == iff);
 
237
    QVERIFY(iff == iff2);
 
238
    QVERIFY(iff != df2);
 
239
    QVERIFY(df2 != iff);
 
240
 
 
241
    QOrganizerItemFilter fiff = iff;
 
242
    QVERIFY(fiff.type() == QOrganizerItemFilter::InvalidFilter);
 
243
    QVERIFY(fiff == iff);
 
244
    QVERIFY(fiff == iff2);
 
245
 
 
246
    /* Now test some "cross casting" */
 
247
 
 
248
}
 
249
 
 
250
void tst_QOrganizerItemFilter::intersectionFilter()
 
251
{
 
252
    /* Test boolean ops */
 
253
    QOrganizerItemDetailFieldFilter df;
 
254
    df.setDetail(QOrganizerItemDetail::TypeUndefined, -1);
 
255
 
 
256
    QOrganizerItemDetailFieldFilter df2;
 
257
    df2.setDetail(QOrganizerItemDetail::TypeComment, QOrganizerItemComment::FieldComment);
 
258
 
 
259
    QOrganizerItemDetailFieldFilter df3;
 
260
    df3.setDetail(QOrganizerItemDetail::TypeDescription, QOrganizerItemDescription::FieldDescription);
 
261
 
 
262
    QOrganizerItemIntersectionFilter bf;
 
263
    bf << df << df2;
 
264
 
 
265
    QOrganizerItemFilter f = df & df2;
 
266
 
 
267
    QVERIFY(bf == f);
 
268
 
 
269
    QOrganizerItemFilter f2 = bf & df3;
 
270
    QVERIFY(f2.type() == QOrganizerItemFilter::IntersectionFilter);
 
271
    QOrganizerItemIntersectionFilter bf2 = f2;
 
272
    QVERIFY(bf2 == f2);
 
273
    QCOMPARE(bf2.filters().count(), 2);
 
274
    QVERIFY(bf2.filters().at(0) == bf);
 
275
    QVERIFY(bf2.filters().at(1) == df3);
 
276
 
 
277
    f2 = df3 & bf;
 
278
    QVERIFY(f2.type() == QOrganizerItemFilter::IntersectionFilter);
 
279
    bf2 = f2;
 
280
    QVERIFY(bf2 == f2);
 
281
    QCOMPARE(bf2.filters().count(), 2);
 
282
    QVERIFY(bf2.filters().at(0) == df3);
 
283
    QVERIFY(bf2.filters().at(1) == bf);
 
284
 
 
285
    /* Save this list */
 
286
    QList<QOrganizerItemFilter> filterList = bf2.filters();
 
287
 
 
288
    f2 = df & df2 & df3;
 
289
    QVERIFY(f2.type() == QOrganizerItemFilter::IntersectionFilter);
 
290
    bf2 = f2;
 
291
    QVERIFY(bf2 == f2);
 
292
    QCOMPARE(bf2.filters().count(), 2);
 
293
    QVERIFY(bf2.filters().at(0) == (df & df2));
 
294
    QVERIFY(bf2.filters().at(1) == df3);
 
295
 
 
296
    /* Self assignment should do nothing */
 
297
    bf2 = bf2;
 
298
    QVERIFY(bf2 == f2);
 
299
 
 
300
    /* Test set filter */
 
301
    bf2.setFilters(filterList);
 
302
    QCOMPARE(bf2.filters().count(), 2);
 
303
    QVERIFY(bf2.filters().at(0) == df3);
 
304
    QVERIFY(bf2.filters().at(1) == bf);
 
305
 
 
306
    /* Test remove */
 
307
    bf2.remove(bf);
 
308
    QCOMPARE(bf2.filters().count(), 1);
 
309
    QVERIFY(bf2.filters().at(0) == df3);
 
310
 
 
311
    /* Double remove, should do nothing */
 
312
    bf2.remove(bf);
 
313
    QCOMPARE(bf2.filters().count(), 1);
 
314
    QVERIFY(bf2.filters().at(0) == df3);
 
315
 
 
316
    /* Append/prepend */
 
317
    QOrganizerItemIntersectionFilter bf3;
 
318
    bf3.append(df);
 
319
    QVERIFY(bf3.filters().count() == 1);
 
320
    bf3.prepend(df2);
 
321
    QVERIFY(bf3.filters().count() == 2);
 
322
    QVERIFY(bf3.filters().at(0) == df2);
 
323
    QVERIFY(bf3.filters().at(1) == df);
 
324
    bf3.append(df3);
 
325
    QVERIFY(bf3.filters().count() == 3);
 
326
    QVERIFY(bf3.filters().at(0) == df2);
 
327
    QVERIFY(bf3.filters().at(1) == df);
 
328
    QVERIFY(bf3.filters().at(2) == df3);
 
329
    bf3.prepend(df3);
 
330
    QVERIFY(bf3.filters().count() == 4);
 
331
    QVERIFY(bf3.filters().at(0) == df3);
 
332
    QVERIFY(bf3.filters().at(1) == df2);
 
333
    QVERIFY(bf3.filters().at(2) == df);
 
334
    QVERIFY(bf3.filters().at(3) == df3);
 
335
 
 
336
    /* Clear */
 
337
    bf3.clear();
 
338
    QVERIFY(bf3.filters().isEmpty());
 
339
}
 
340
 
 
341
void tst_QOrganizerItemFilter::unionFilter()
 
342
{
 
343
    /* Test boolean ops */
 
344
    QOrganizerItemDetailFieldFilter df;
 
345
    df.setDetail(QOrganizerItemDetail::TypeUndefined, -1);
 
346
 
 
347
    QOrganizerItemDetailFieldFilter df2;
 
348
    df2.setDetail(QOrganizerItemDetail::TypeComment, QOrganizerItemComment::FieldComment);
 
349
 
 
350
    QOrganizerItemDetailFieldFilter df3;
 
351
    df3.setDetail(QOrganizerItemDetail::TypeDescription, QOrganizerItemDescription::FieldDescription);
 
352
 
 
353
    QOrganizerItemUnionFilter bf;
 
354
    bf << df << df2;
 
355
 
 
356
    QOrganizerItemFilter f = df | df2;
 
357
 
 
358
    QVERIFY(bf == f);
 
359
 
 
360
    QOrganizerItemFilter f2 = bf | df3;
 
361
    QVERIFY(f2.type() == QOrganizerItemFilter::UnionFilter);
 
362
    QOrganizerItemUnionFilter bf2 = f2;
 
363
    QVERIFY(bf2 == f2);
 
364
    QCOMPARE(bf2.filters().count(), 3);
 
365
    QVERIFY(bf2.filters().at(0) == df);
 
366
    QVERIFY(bf2.filters().at(1) == df2);
 
367
    QVERIFY(bf2.filters().at(2) == df3);
 
368
 
 
369
    f2 = df3 | bf;
 
370
    QVERIFY(f2.type() == QOrganizerItemFilter::UnionFilter);
 
371
    bf2 = f2;
 
372
    QVERIFY(bf2 == f2);
 
373
    QCOMPARE(bf2.filters().count(), 3);
 
374
    QVERIFY(bf2.filters().at(0) == df3);
 
375
    QVERIFY(bf2.filters().at(1) == df);
 
376
    QVERIFY(bf2.filters().at(2) == df2);
 
377
 
 
378
    /* Save this list */
 
379
    QList<QOrganizerItemFilter> filterList = bf2.filters();
 
380
 
 
381
    f2 = df | df2 | df3;
 
382
    QVERIFY(f2.type() == QOrganizerItemFilter::UnionFilter);
 
383
    bf2 = f2;
 
384
    QVERIFY(bf2 == f2);
 
385
    QCOMPARE(bf2.filters().count(), 3);
 
386
    QVERIFY(bf2.filters().at(0) == df);
 
387
    QVERIFY(bf2.filters().at(1) == df2);
 
388
    QVERIFY(bf2.filters().at(2) == df3);
 
389
 
 
390
    /* Self assignment should do nothing */
 
391
    bf2 = bf2;
 
392
    QVERIFY(bf2 == f2);
 
393
 
 
394
    /* Test set filter */
 
395
    bf2.setFilters(filterList);
 
396
    QCOMPARE(bf2.filters().count(), 3);
 
397
    QVERIFY(bf2.filters().at(0) == df3);
 
398
    QVERIFY(bf2.filters().at(1) == df);
 
399
    QVERIFY(bf2.filters().at(2) == df2);
 
400
 
 
401
    /* Test remove */
 
402
    bf2.remove(df);
 
403
    QCOMPARE(bf2.filters().count(), 2);
 
404
    QVERIFY(bf2.filters().at(0) == df3);
 
405
    QVERIFY(bf2.filters().at(1) == df2);
 
406
 
 
407
    /* Double remove, should do nothing */
 
408
    bf2.remove(df);
 
409
    QCOMPARE(bf2.filters().count(), 2);
 
410
    QVERIFY(bf2.filters().at(0) == df3);
 
411
    QVERIFY(bf2.filters().at(1) == df2);
 
412
 
 
413
    /* Append/prepend */
 
414
    QOrganizerItemUnionFilter bf3;
 
415
    bf3.append(df);
 
416
    QVERIFY(bf3.filters().count() == 1);
 
417
    bf3.prepend(df2);
 
418
    QVERIFY(bf3.filters().count() == 2);
 
419
    QVERIFY(bf3.filters().at(0) == df2);
 
420
    QVERIFY(bf3.filters().at(1) == df);
 
421
    bf3.append(df3);
 
422
    QVERIFY(bf3.filters().count() == 3);
 
423
    QVERIFY(bf3.filters().at(0) == df2);
 
424
    QVERIFY(bf3.filters().at(1) == df);
 
425
    QVERIFY(bf3.filters().at(2) == df3);
 
426
    bf3.prepend(df3);
 
427
    QVERIFY(bf3.filters().count() == 4);
 
428
    QVERIFY(bf3.filters().at(0) == df3);
 
429
    QVERIFY(bf3.filters().at(1) == df2);
 
430
    QVERIFY(bf3.filters().at(2) == df);
 
431
    QVERIFY(bf3.filters().at(3) == df3);
 
432
 
 
433
    /* Clear */
 
434
    bf3.clear();
 
435
    QVERIFY(bf3.filters().isEmpty());
 
436
}
 
437
 
 
438
void tst_QOrganizerItemFilter::detailFilter()
 
439
{
 
440
    QOrganizerItemDetailFilter df;
 
441
 
 
442
    QVERIFY(df.type() == QOrganizerItemFilter::DetailFilter);
 
443
 
 
444
    QVERIFY(df.detail().type() == QOrganizerItemDetail::TypeUndefined);
 
445
    QVERIFY(df.detail().isEmpty());
 
446
 
 
447
    QOrganizerItemComment comment;
 
448
    df.setDetail(comment);
 
449
    QVERIFY(df.detail().isEmpty());
 
450
    QVERIFY(df.detail().type() == QOrganizerItemDetail::TypeComment);
 
451
    QVERIFY(!df.detail().values().keys().contains(QOrganizerItemComment::FieldComment));
 
452
    QVERIFY(df.detail().value(QOrganizerItemComment::FieldComment).isNull());
 
453
 
 
454
    comment.setComment(QStringLiteral("TestComment"));
 
455
    df.setDetail(comment);
 
456
    QVERIFY(!df.detail().isEmpty());
 
457
    QCOMPARE(df.detail().type(), QOrganizerItemDetail::TypeComment);
 
458
    QVERIFY(df.detail().values().keys().contains(QOrganizerItemComment::FieldComment));
 
459
    QCOMPARE(df.detail().value(QOrganizerItemComment::FieldComment).toString(), QString(QStringLiteral("TestComment")));
 
460
 
 
461
 
 
462
    /* Test op= */
 
463
    QOrganizerItemFilter f = df;
 
464
    QVERIFY(f == df);
 
465
 
 
466
    QOrganizerItemDetailFilter df2 = f;
 
467
    QVERIFY(df2 == df);
 
468
    QCOMPARE(df2.detail(), df.detail());
 
469
 
 
470
    /* Self assignment should do nothing */
 
471
    df2 = df2;
 
472
    QVERIFY(df2 == df);
 
473
 
 
474
    /* Some cross casting */
 
475
    QOrganizerItemDetailRangeFilter rf;
 
476
 
 
477
    /* Directly */
 
478
    df2 = rf;
 
479
    QCOMPARE(df2.type(), QOrganizerItemFilter::DetailFilter);
 
480
    QCOMPARE(df2.detail().type(), QOrganizerItemDetail::TypeUndefined);
 
481
    QVERIFY(df2.detail().isEmpty());
 
482
 
 
483
    /* reset it */
 
484
    df2 = df;
 
485
    QCOMPARE(df2.detail().type(), QOrganizerItemDetail::TypeComment);
 
486
    QVERIFY(df2.detail().values().keys().contains(QOrganizerItemComment::FieldComment));
 
487
 
 
488
    /* Through base class */
 
489
    f = rf;
 
490
    df2 = f;
 
491
    QCOMPARE(df2.detail().type(), QOrganizerItemDetail::TypeUndefined);
 
492
    QVERIFY(df2.detail().isEmpty());
 
493
 
 
494
    /* Now test copy ctor */
 
495
    QOrganizerItemDetailFilter df3(rf);
 
496
    QVERIFY(df3.type() == QOrganizerItemFilter::DetailFilter);
 
497
    QCOMPARE(df3.detail().type(), QOrganizerItemDetail::TypeUndefined);
 
498
    QVERIFY(df3.detail().isEmpty());
 
499
 
 
500
    /* reset it */
 
501
    df3 = df;
 
502
    QCOMPARE(df3.detail().type(), QOrganizerItemDetail::TypeComment);
 
503
    QVERIFY(df3.detail().values().keys().contains(QOrganizerItemComment::FieldComment));
 
504
 
 
505
    /* Now test copy ctor through base class */
 
506
    QOrganizerItemDetailFilter df4(f);
 
507
    QCOMPARE(df4.type(), QOrganizerItemFilter::DetailFilter);
 
508
    QCOMPARE(df4.detail().type(), QOrganizerItemDetail::TypeUndefined);
 
509
    QVERIFY(df4.detail().isEmpty());
 
510
 
 
511
    /* reset it */
 
512
    df4 = df;
 
513
    QCOMPARE(df4.detail().type(), QOrganizerItemDetail::TypeComment);
 
514
    QVERIFY(df4.detail().values().keys().contains(QOrganizerItemComment::FieldComment));
 
515
}
 
516
 
 
517
void tst_QOrganizerItemFilter::detailFieldFilter()
 
518
{
 
519
    QOrganizerItemDetailFieldFilter df;
 
520
 
 
521
    QVERIFY(df.type() == QOrganizerItemFilter::DetailFieldFilter);
 
522
 
 
523
    QVERIFY(df.detailType() == QOrganizerItemDetail::TypeUndefined);
 
524
    QVERIFY(df.detailField() == -1);
 
525
    QVERIFY(df.matchFlags() == 0);
 
526
    QVERIFY(df.value().isNull());
 
527
 
 
528
    df.setDetail(QOrganizerItemDetail::TypeComment, QOrganizerItemComment::FieldComment);
 
529
    QVERIFY(df.detailType() == QOrganizerItemDetail::TypeComment);
 
530
    QVERIFY(df.detailField() == QOrganizerItemComment::FieldComment);
 
531
    QVERIFY(df.matchFlags() == 0);
 
532
    QVERIFY(df.value().isNull());
 
533
 
 
534
    df.setDetail(QOrganizerItemDetail::TypeDescription, QOrganizerItemDescription::FieldDescription);
 
535
    QVERIFY(df.detailType() == QOrganizerItemDetail::TypeDescription);
 
536
    QVERIFY(df.detailField() == QOrganizerItemDescription::FieldDescription);
 
537
    QVERIFY(df.matchFlags() == 0);
 
538
    QVERIFY(df.value().isNull());
 
539
 
 
540
    df.setMatchFlags(QOrganizerItemFilter::MatchExactly);
 
541
    QVERIFY(df.matchFlags() == QOrganizerItemFilter::MatchExactly);
 
542
 
 
543
    df.setValue(5);
 
544
    QVERIFY(df.value() == 5);
 
545
 
 
546
    df.setValue("String value");
 
547
    QVERIFY(df.value() == "String value");
 
548
 
 
549
    /* Test op= */
 
550
    QOrganizerItemFilter f = df;
 
551
    QVERIFY(f == df);
 
552
 
 
553
    QOrganizerItemDetailFieldFilter df2 = f;
 
554
    QVERIFY(df2 == df);
 
555
    QVERIFY(df2.detailType() == QOrganizerItemDetail::TypeDescription);
 
556
    QVERIFY(df2.detailField() == QOrganizerItemDescription::FieldDescription);
 
557
 
 
558
    /* Self assignment should do nothing */
 
559
    df2 = df2;
 
560
    QVERIFY(df2 == df);
 
561
 
 
562
    /* Some cross casting */
 
563
    QOrganizerItemDetailRangeFilter rf;
 
564
 
 
565
    /* Directly */
 
566
    df2 = rf;
 
567
    QVERIFY(df2.type() == QOrganizerItemFilter::DetailFieldFilter);
 
568
    QVERIFY(df2.detailType() == QOrganizerItemDetail::TypeUndefined);
 
569
    QVERIFY(df2.detailField() == -1);
 
570
    QVERIFY(df2.value().isNull());
 
571
 
 
572
    /* reset it */
 
573
    df2 = df;
 
574
    QVERIFY(df2.detailType() == QOrganizerItemDetail::TypeDescription);
 
575
    QVERIFY(df2.detailField() == QOrganizerItemDescription::FieldDescription);
 
576
 
 
577
    /* Through base class */
 
578
    f = rf;
 
579
    df2 = f;
 
580
    QVERIFY(df2.detailType() == QOrganizerItemDetail::TypeUndefined);
 
581
    QVERIFY(df2.detailField() == -1);
 
582
    QVERIFY(df2.value().isNull());
 
583
 
 
584
    /* Now test copy ctor */
 
585
    QOrganizerItemDetailFieldFilter df3(rf);
 
586
    QVERIFY(df3.type() == QOrganizerItemFilter::DetailFieldFilter);
 
587
    QVERIFY(df3.detailType() == QOrganizerItemDetail::TypeUndefined);
 
588
    QVERIFY(df3.detailField() == -1);
 
589
    QVERIFY(df3.value().isNull());
 
590
 
 
591
    /* reset it */
 
592
    df3 = df;
 
593
    QVERIFY(df3.detailType() == QOrganizerItemDetail::TypeDescription);
 
594
    QVERIFY(df3.detailField() == QOrganizerItemDescription::FieldDescription);
 
595
 
 
596
    /* Now test copy ctor through base class */
 
597
    QOrganizerItemDetailFieldFilter df4(f);
 
598
    QVERIFY(df4.type() == QOrganizerItemFilter::DetailFieldFilter);
 
599
    QVERIFY(df4.detailType() == QOrganizerItemDetail::TypeUndefined);
 
600
    QVERIFY(df4.detailField() == -1);
 
601
    QVERIFY(df4.value().isNull());
 
602
 
 
603
    /* reset it */
 
604
    df4 = df;
 
605
    QVERIFY(df4.detailType() == QOrganizerItemDetail::TypeDescription);
 
606
    QVERIFY(df4.detailField() == QOrganizerItemDescription::FieldDescription);
 
607
}
 
608
 
 
609
void tst_QOrganizerItemFilter::detailRangeFilter()
 
610
{
 
611
    QOrganizerItemDetailRangeFilter rf;
 
612
 
 
613
    QVERIFY(rf.type() == QOrganizerItemFilter::DetailRangeFilter);
 
614
 
 
615
    QVERIFY(rf.detailType() == QOrganizerItemDetail::TypeUndefined);
 
616
    QVERIFY(rf.detailField() == -1);
 
617
    QVERIFY(rf.matchFlags() == 0);
 
618
 
 
619
    QVERIFY(rf.minValue().isNull());
 
620
    QVERIFY(rf.maxValue().isNull());
 
621
    QVERIFY(rf.rangeFlags() == (QOrganizerItemDetailRangeFilter::ExcludeUpper | QOrganizerItemDetailRangeFilter::IncludeLower));
 
622
 
 
623
    rf.setDetail(QOrganizerItemDetail::TypeEventTime, QOrganizerEventTime::FieldStartDateTime);
 
624
    QVERIFY(rf.detailType() == QOrganizerItemDetail::TypeEventTime);
 
625
    QVERIFY(rf.detailField() == QOrganizerEventTime::FieldStartDateTime);
 
626
    QVERIFY(rf.matchFlags() == 0);
 
627
 
 
628
    QVERIFY(rf.minValue().isNull());
 
629
    QVERIFY(rf.maxValue().isNull());
 
630
    QVERIFY(rf.rangeFlags() == (QOrganizerItemDetailRangeFilter::ExcludeUpper | QOrganizerItemDetailRangeFilter::IncludeLower));
 
631
 
 
632
    rf.setDetail(QOrganizerItemDetail::TypeEventTime, QOrganizerEventTime::FieldStartDateTime);
 
633
    QVERIFY(rf.detailType() == QOrganizerItemDetail::TypeEventTime);
 
634
    QVERIFY(rf.detailField() == QOrganizerEventTime::FieldStartDateTime);
 
635
    QVERIFY(rf.matchFlags() == 0);
 
636
 
 
637
    QVERIFY(rf.minValue().isNull());
 
638
    QVERIFY(rf.maxValue().isNull());
 
639
    QVERIFY(rf.rangeFlags() == (QOrganizerItemDetailRangeFilter::ExcludeUpper | QOrganizerItemDetailRangeFilter::IncludeLower));
 
640
 
 
641
    rf.setMatchFlags(QOrganizerItemFilter::MatchExactly);
 
642
    QVERIFY(rf.matchFlags() == QOrganizerItemFilter::MatchExactly);
 
643
 
 
644
    rf.setMatchFlags(QOrganizerItemFilter::MatchCaseSensitive);
 
645
    QVERIFY(rf.matchFlags() == QOrganizerItemFilter::MatchCaseSensitive);
 
646
 
 
647
    // Contains is not allowed
 
648
    rf.setMatchFlags(QOrganizerItemFilter::MatchCaseSensitive | QOrganizerItemFilter::MatchContains);
 
649
    QVERIFY(rf.matchFlags() == QOrganizerItemFilter::MatchCaseSensitive);
 
650
 
 
651
    rf.setMatchFlags(QOrganizerItemFilter::MatchEndsWith);
 
652
    QVERIFY(rf.matchFlags() == QOrganizerItemFilter::MatchExactly); // 0
 
653
 
 
654
    rf.setRange(5, 10);
 
655
    QVERIFY(rf.minValue() == 5);
 
656
    QVERIFY(rf.maxValue() == 10);
 
657
    QVERIFY(rf.rangeFlags() == (QOrganizerItemDetailRangeFilter::ExcludeUpper | QOrganizerItemDetailRangeFilter::IncludeLower));
 
658
 
 
659
    rf.setRange(QVariant(), 11);
 
660
    QVERIFY(rf.minValue().isNull());
 
661
    QVERIFY(rf.maxValue() == 11);
 
662
    QVERIFY(rf.rangeFlags() == (QOrganizerItemDetailRangeFilter::ExcludeUpper | QOrganizerItemDetailRangeFilter::IncludeLower));
 
663
 
 
664
    rf.setRange(6, QVariant());
 
665
    QVERIFY(rf.minValue() == 6);
 
666
    QVERIFY(rf.maxValue().isNull());
 
667
    QVERIFY(rf.rangeFlags() == (QOrganizerItemDetailRangeFilter::ExcludeUpper | QOrganizerItemDetailRangeFilter::IncludeLower));
 
668
 
 
669
    rf.setRange(QVariant(), QVariant());
 
670
    QVERIFY(rf.minValue().isNull());
 
671
    QVERIFY(rf.maxValue().isNull());
 
672
    QVERIFY(rf.rangeFlags() == (QOrganizerItemDetailRangeFilter::ExcludeUpper | QOrganizerItemDetailRangeFilter::IncludeLower));
 
673
 
 
674
    rf.setRange(5, 10, QOrganizerItemDetailRangeFilter::ExcludeLower);
 
675
    QVERIFY(rf.minValue() == 5);
 
676
    QVERIFY(rf.maxValue() == 10);
 
677
    QVERIFY(rf.rangeFlags() == (QOrganizerItemDetailRangeFilter::ExcludeUpper | QOrganizerItemDetailRangeFilter::ExcludeLower));
 
678
 
 
679
    rf.setRange(QVariant(), 11, QOrganizerItemDetailRangeFilter::IncludeUpper);
 
680
    QVERIFY(rf.minValue().isNull());
 
681
    QVERIFY(rf.maxValue() == 11);
 
682
    QVERIFY(rf.rangeFlags() == (QOrganizerItemDetailRangeFilter::IncludeUpper | QOrganizerItemDetailRangeFilter::IncludeLower));
 
683
 
 
684
    rf.setRange(6, QVariant(), QOrganizerItemDetailRangeFilter::ExcludeLower | QOrganizerItemDetailRangeFilter::IncludeUpper);
 
685
    QVERIFY(rf.minValue() == 6);
 
686
    QVERIFY(rf.maxValue().isNull());
 
687
    QVERIFY(rf.rangeFlags() == (QOrganizerItemDetailRangeFilter::IncludeUpper | QOrganizerItemDetailRangeFilter::ExcludeLower));
 
688
 
 
689
    rf.setRange(QVariant(), QVariant(), QOrganizerItemDetailRangeFilter::ExcludeUpper | QOrganizerItemDetailRangeFilter::IncludeLower);
 
690
    QVERIFY(rf.minValue().isNull());
 
691
    QVERIFY(rf.maxValue().isNull());
 
692
    QVERIFY(rf.rangeFlags() == (QOrganizerItemDetailRangeFilter::ExcludeUpper | QOrganizerItemDetailRangeFilter::IncludeLower));
 
693
 
 
694
    /* Test op= */
 
695
    QOrganizerItemFilter f = rf;
 
696
    QVERIFY(f == rf);
 
697
 
 
698
    QOrganizerItemDetailRangeFilter rf2 = f;
 
699
    QVERIFY(rf2 == rf);
 
700
 
 
701
    rf2 = rf;
 
702
    QVERIFY(rf2 == f);
 
703
 
 
704
    /* Self assignment should do nothing */
 
705
    rf2 = rf2;
 
706
    QVERIFY(rf2 == rf);
 
707
}
 
708
 
 
709
 
 
710
void tst_QOrganizerItemFilter::sortObject()
 
711
{
 
712
    QOrganizerItemSortOrder sortorder;
 
713
 
 
714
    /* Defaults */
 
715
    QVERIFY(sortorder.blankPolicy() == QOrganizerItemSortOrder::BlanksLast);
 
716
    QVERIFY(sortorder.detailType() == QOrganizerItemDetail::TypeUndefined);
 
717
    QVERIFY(sortorder.detailField() == -1);
 
718
    QVERIFY(sortorder.direction() == Qt::AscendingOrder);
 
719
    QVERIFY(sortorder.caseSensitivity() == Qt::CaseSensitive);
 
720
    QVERIFY(!sortorder.isValid());
 
721
    QVERIFY(sortorder == QOrganizerItemSortOrder());
 
722
 
 
723
    /* Blank Policy */
 
724
    sortorder.setBlankPolicy(QOrganizerItemSortOrder::BlanksFirst);
 
725
    QVERIFY(sortorder.blankPolicy() == QOrganizerItemSortOrder::BlanksFirst);
 
726
    QVERIFY(sortorder.detailType() == QOrganizerItemDetail::TypeUndefined);
 
727
    QVERIFY(sortorder.detailField() == -1);
 
728
    QVERIFY(sortorder.direction() == Qt::AscendingOrder);
 
729
    QVERIFY(sortorder.caseSensitivity() == Qt::CaseSensitive);
 
730
    QVERIFY(!sortorder.isValid());
 
731
    QVERIFY(sortorder != QOrganizerItemSortOrder());
 
732
 
 
733
    sortorder.setBlankPolicy(QOrganizerItemSortOrder::BlanksLast);
 
734
    QVERIFY(sortorder.blankPolicy() == QOrganizerItemSortOrder::BlanksLast);
 
735
    QVERIFY(sortorder.detailType() == QOrganizerItemDetail::TypeUndefined);
 
736
    QVERIFY(sortorder.detailField() == -1);
 
737
    QVERIFY(sortorder.direction() == Qt::AscendingOrder);
 
738
    QVERIFY(sortorder.caseSensitivity() == Qt::CaseSensitive);
 
739
    QVERIFY(!sortorder.isValid());
 
740
    QVERIFY(sortorder == QOrganizerItemSortOrder());
 
741
 
 
742
    /* Direction */
 
743
    sortorder.setDirection(Qt::DescendingOrder);
 
744
    QVERIFY(sortorder.direction() == Qt::DescendingOrder);
 
745
    QVERIFY(sortorder.blankPolicy() == QOrganizerItemSortOrder::BlanksLast);
 
746
    QVERIFY(sortorder.detailType() == QOrganizerItemDetail::TypeUndefined);
 
747
    QVERIFY(sortorder.detailField() == -1);
 
748
    QVERIFY(sortorder.caseSensitivity() == Qt::CaseSensitive);
 
749
    QVERIFY(!sortorder.isValid());
 
750
    QVERIFY(sortorder != QOrganizerItemSortOrder());
 
751
 
 
752
    sortorder.setDirection(Qt::AscendingOrder);
 
753
    QVERIFY(sortorder.direction() == Qt::AscendingOrder);
 
754
    QVERIFY(sortorder.blankPolicy() == QOrganizerItemSortOrder::BlanksLast);
 
755
    QVERIFY(sortorder.detailType() == QOrganizerItemDetail::TypeUndefined);
 
756
    QVERIFY(sortorder.detailField() == -1);
 
757
    QVERIFY(sortorder.caseSensitivity() == Qt::CaseSensitive);
 
758
    QVERIFY(!sortorder.isValid());
 
759
    QVERIFY(sortorder == QOrganizerItemSortOrder());
 
760
 
 
761
    /* Case sensitivity */
 
762
    sortorder.setCaseSensitivity(Qt::CaseInsensitive);
 
763
    QVERIFY(sortorder.direction() == Qt::AscendingOrder);
 
764
    QVERIFY(sortorder.blankPolicy() == QOrganizerItemSortOrder::BlanksLast);
 
765
    QVERIFY(sortorder.detailType() == QOrganizerItemDetail::TypeUndefined);
 
766
    QVERIFY(sortorder.detailField() == -1);
 
767
    QVERIFY(sortorder.caseSensitivity() == Qt::CaseInsensitive);
 
768
    QVERIFY(!sortorder.isValid());
 
769
    QVERIFY(sortorder != QOrganizerItemSortOrder());
 
770
 
 
771
    sortorder.setCaseSensitivity(Qt::CaseSensitive);
 
772
    QVERIFY(sortorder.direction() == Qt::AscendingOrder);
 
773
    QVERIFY(sortorder.blankPolicy() == QOrganizerItemSortOrder::BlanksLast);
 
774
    QVERIFY(sortorder.detailType() == QOrganizerItemDetail::TypeUndefined);
 
775
    QVERIFY(sortorder.detailField() == -1);
 
776
    QVERIFY(sortorder.caseSensitivity() == Qt::CaseSensitive);
 
777
    QVERIFY(!sortorder.isValid());
 
778
    QVERIFY(sortorder == QOrganizerItemSortOrder());
 
779
 
 
780
    /* Definitions */
 
781
    sortorder.setDetail(QOrganizerItemDetail::TypeUndefined, -1);
 
782
    QVERIFY(sortorder.direction() == Qt::AscendingOrder);
 
783
    QVERIFY(sortorder.blankPolicy() == QOrganizerItemSortOrder::BlanksLast);
 
784
    QVERIFY(sortorder.detailType() == QOrganizerItemDetail::TypeUndefined);
 
785
    QVERIFY(sortorder.detailField() == -1);
 
786
    QVERIFY(!sortorder.isValid());
 
787
 
 
788
    sortorder.setDetail(QOrganizerItemDetail::TypeComment, -1);
 
789
    QVERIFY(sortorder.direction() == Qt::AscendingOrder);
 
790
    QVERIFY(sortorder.blankPolicy() == QOrganizerItemSortOrder::BlanksLast);
 
791
    QVERIFY(sortorder.detailType() == QOrganizerItemDetail::TypeUndefined);
 
792
    QVERIFY(sortorder.detailField() == -1);
 
793
    QVERIFY(!sortorder.isValid());
 
794
    QVERIFY(sortorder == QOrganizerItemSortOrder());
 
795
 
 
796
    sortorder.setDetail(QOrganizerItemDetail::TypeComment, QOrganizerItemComment::FieldComment);
 
797
    QVERIFY(sortorder.direction() == Qt::AscendingOrder);
 
798
    QVERIFY(sortorder.blankPolicy() == QOrganizerItemSortOrder::BlanksLast);
 
799
    QVERIFY(sortorder.detailType() == QOrganizerItemDetail::TypeComment);
 
800
    QVERIFY(sortorder.detailField() == QOrganizerItemComment::FieldComment);
 
801
    QVERIFY(sortorder.isValid());
 
802
 
 
803
    sortorder.setDetail(QOrganizerItemDetail::TypeUndefined, 101);
 
804
    QVERIFY(sortorder.direction() == Qt::AscendingOrder);
 
805
    QVERIFY(sortorder.blankPolicy() == QOrganizerItemSortOrder::BlanksLast);
 
806
    QVERIFY(sortorder.detailType() == QOrganizerItemDetail::TypeUndefined);
 
807
    QVERIFY(sortorder.detailField() == -1);
 
808
    QVERIFY(!sortorder.isValid());
 
809
 
 
810
    /* Copy ctor */
 
811
    sortorder.setDetail(QOrganizerItemDetail::TypeComment, QOrganizerItemComment::FieldComment);
 
812
    sortorder.setBlankPolicy(QOrganizerItemSortOrder::BlanksFirst);
 
813
    sortorder.setDirection(Qt::DescendingOrder);
 
814
    QVERIFY(sortorder.direction() == Qt::DescendingOrder);
 
815
    QVERIFY(sortorder.blankPolicy() == QOrganizerItemSortOrder::BlanksFirst);
 
816
    QVERIFY(sortorder.detailType() == QOrganizerItemDetail::TypeComment);
 
817
    QVERIFY(sortorder.detailField() == QOrganizerItemComment::FieldComment);
 
818
    QVERIFY(sortorder.isValid());
 
819
 
 
820
    QOrganizerItemSortOrder other(sortorder);
 
821
    QVERIFY(other.direction() == Qt::DescendingOrder);
 
822
    QVERIFY(other.blankPolicy() == QOrganizerItemSortOrder::BlanksFirst);
 
823
    QVERIFY(other.detailType() == QOrganizerItemDetail::TypeComment);
 
824
    QVERIFY(other.detailField() == QOrganizerItemComment::FieldComment);
 
825
    QVERIFY(other.isValid());
 
826
    QVERIFY(other == sortorder);
 
827
    QVERIFY(!(other != sortorder));
 
828
 
 
829
    other.setDetail(QOrganizerItemDetail::TypeDescription, QOrganizerItemDescription::FieldDescription);
 
830
    QVERIFY(other != sortorder);
 
831
 
 
832
    other.setDetail(QOrganizerItemDetail::TypeComment, 2);
 
833
    QVERIFY(other != sortorder);
 
834
 
 
835
    /* Assignment operator */
 
836
    QOrganizerItemSortOrder another;
 
837
    another = other;
 
838
    QVERIFY(another.direction() == Qt::DescendingOrder);
 
839
    QVERIFY(another.blankPolicy() == QOrganizerItemSortOrder::BlanksFirst);
 
840
    QVERIFY(another.detailType() == QOrganizerItemDetail::TypeComment);
 
841
    QVERIFY(another.detailField() == 2);
 
842
    QVERIFY(another.isValid());
 
843
    QVERIFY(another == other);
 
844
    QVERIFY(!(other != another));
 
845
 
 
846
    /* Self assignment */
 
847
    another = another;
 
848
    QVERIFY(another.direction() == Qt::DescendingOrder);
 
849
    QVERIFY(another.blankPolicy() == QOrganizerItemSortOrder::BlanksFirst);
 
850
    QVERIFY(another.detailType() == QOrganizerItemDetail::TypeComment);
 
851
    QVERIFY(another.detailField() == 2);
 
852
    QVERIFY(another.isValid());
 
853
    QVERIFY(another == other);
 
854
    QVERIFY(!(other != another));
 
855
}
 
856
 
 
857
void tst_QOrganizerItemFilter::boringFilters()
 
858
{
 
859
    QOrganizerItemFilter all;
 
860
    QVERIFY(all.type() == QOrganizerItemFilter::DefaultFilter);
 
861
 
 
862
    QOrganizerItemInvalidFilter invalid;
 
863
    QVERIFY(invalid.type() == QOrganizerItemFilter::InvalidFilter);
 
864
 
 
865
    QVERIFY(all != invalid);
 
866
    QVERIFY(!(all == invalid));
 
867
 
 
868
    /* Test op= */
 
869
    QOrganizerItemFilter f = all;
 
870
    QVERIFY(f == all);
 
871
 
 
872
    QOrganizerItemFilter f2;
 
873
    f2 = f;
 
874
    QVERIFY(f2 == all);
 
875
 
 
876
    /* Self assignment should do nothing */
 
877
    f2 = f2;
 
878
    QVERIFY(f2 == all);
 
879
 
 
880
    /* InvalidFilter, op= */
 
881
    QOrganizerItemInvalidFilter inv2 = invalid;
 
882
    QVERIFY(inv2 == invalid);
 
883
 
 
884
    QOrganizerItemInvalidFilter inv3;
 
885
    inv3 = inv2;
 
886
    QVERIFY(inv3 == invalid);
 
887
 
 
888
    inv3 = inv3;
 
889
    QVERIFY(inv3 == invalid);
 
890
 
 
891
    inv3 = all;
 
892
    QVERIFY(inv3 == invalid); // won't be all
 
893
}
 
894
 
 
895
void tst_QOrganizerItemFilter::idListFilter()
 
896
{
 
897
    QOrganizerItemIdFilter idf;
 
898
 
 
899
    QVERIFY(idf.type() == QOrganizerItemFilter::IdFilter);
 
900
 
 
901
    QVERIFY(idf.ids().count() == 0);
 
902
 
 
903
    QList<QOrganizerItemId> ids;
 
904
    ids << makeId(5) << makeId(6) << makeId(17);
 
905
 
 
906
    idf.setIds(ids);
 
907
    QVERIFY(idf.ids() == ids);
 
908
 
 
909
    idf.setIds(QList<QOrganizerItemId>());
 
910
    QVERIFY(idf.ids().count() == 0);
 
911
 
 
912
    QOrganizerItemId singleId = makeId(12);
 
913
    idf.insert(singleId);
 
914
    QVERIFY(idf.ids().contains(singleId));
 
915
    idf.remove(singleId);
 
916
    QVERIFY(!idf.ids().contains(singleId));
 
917
    QList<QOrganizerItemId> allIds = idf.ids();
 
918
    idf.remove(singleId); // remove again
 
919
    QVERIFY(idf.ids() == allIds);
 
920
    idf.clear();
 
921
    QVERIFY(idf.ids().isEmpty());
 
922
    idf.setIds(allIds);
 
923
 
 
924
    /* Test op= */
 
925
    idf.setIds(ids);
 
926
    QOrganizerItemFilter f = idf;
 
927
    QVERIFY(f == idf);
 
928
 
 
929
    QOrganizerItemIdFilter idf2 = f;
 
930
    QVERIFY(idf2 == idf);
 
931
    QVERIFY(idf2.ids() == ids);
 
932
 
 
933
    idf2 = idf;
 
934
    QVERIFY(idf2 == f);
 
935
 
 
936
    /* Self assignment should do nothing */
 
937
    idf2 = idf2;
 
938
    QVERIFY(idf2 == idf);
 
939
 
 
940
    QOrganizerItemDetailFieldFilter dfil;
 
941
    QOrganizerItemIdFilter idf3(dfil);
 
942
    QVERIFY(idf3.type() == QOrganizerItemFilter::IdFilter); // should be a blank id list filter
 
943
    QOrganizerItemIdFilter idf4(idf);
 
944
    QVERIFY(idf4 == idf); // should be a copy of idf.
 
945
    idf = dfil; // now assign.
 
946
    QVERIFY(idf == idf3); // again, should be a blank id list filter.
 
947
    idf = idf3;
 
948
    idf.setIds(ids); // force a detach
 
949
}
 
950
 
 
951
void tst_QOrganizerItemFilter::collectionFilter()
 
952
{
 
953
    QOrganizerItemCollectionFilter icf;
 
954
 
 
955
    QVERIFY(icf.collectionIds().isEmpty());
 
956
 
 
957
    QOrganizerCollectionId id1 = makeCId(5);
 
958
    QOrganizerCollectionId id2 = makeCId(6);
 
959
    QOrganizerCollectionId id3 = makeCId(7);
 
960
    QOrganizerCollectionId id4 = makeCId(12);
 
961
    QSet<QOrganizerCollectionId> ids;
 
962
    ids << id1 << id2 << id3;
 
963
 
 
964
    icf.setCollectionIds(ids);
 
965
    QVERIFY(icf.collectionIds() == ids);
 
966
 
 
967
    icf.setCollectionId(id4);
 
968
    ids.clear();
 
969
    ids << id4;
 
970
    QVERIFY(icf.collectionIds() == ids);
 
971
 
 
972
    QOrganizerItemCollectionFilter icf2;
 
973
    icf2 = icf;
 
974
    QVERIFY(icf2.collectionIds() == ids);
 
975
 
 
976
    QOrganizerItemFilter fil;
 
977
    fil = icf;
 
978
    QVERIFY(fil.type() == QOrganizerItemFilter::CollectionFilter);
 
979
 
 
980
    QOrganizerItemCollectionFilter icf3(fil);
 
981
    QVERIFY(fil.type() == QOrganizerItemFilter::CollectionFilter);
 
982
    QVERIFY(icf3.collectionIds() == ids);
 
983
}
 
984
 
 
985
void tst_QOrganizerItemFilter::canonicalizedFilter()
 
986
{
 
987
    QFETCH(QOrganizerItemFilter, in);
 
988
    QFETCH(QOrganizerItemFilter, expected);
 
989
 
 
990
    QOrganizerItemFilter out = QOrganizerManagerEngine::canonicalizedFilter(in);
 
991
    QCOMPARE(out, expected);
 
992
}
 
993
 
 
994
void tst_QOrganizerItemFilter::canonicalizedFilter_data()
 
995
{
 
996
    QTest::addColumn<QOrganizerItemFilter>("in");
 
997
    QTest::addColumn<QOrganizerItemFilter>("expected");
 
998
 
 
999
    QOrganizerItemDetailFieldFilter detailFilter1;
 
1000
    detailFilter1.setDetail(QOrganizerItemDetail::TypeLocation, QOrganizerItemLocation::FieldLabel);
 
1001
    detailFilter1.setValue("1");
 
1002
    detailFilter1.setMatchFlags(QOrganizerItemFilter::MatchContains);
 
1003
    QOrganizerItemDetailFieldFilter detailFilter2;
 
1004
    detailFilter2.setDetail(QOrganizerItemDetail::TypeLocation, QOrganizerItemLocation::FieldLabel);
 
1005
    detailFilter2.setValue("2");
 
1006
    detailFilter2.setMatchFlags(QOrganizerItemFilter::MatchContains);
 
1007
    QOrganizerItemInvalidFilter invalidFilter;
 
1008
    QOrganizerItemFilter defaultFilter;
 
1009
 
 
1010
    {
 
1011
        QTest::newRow("Normal detail filter")
 
1012
                << static_cast<QOrganizerItemFilter>(detailFilter1)
 
1013
                << static_cast<QOrganizerItemFilter>(detailFilter1);
 
1014
    }
 
1015
 
 
1016
    {
 
1017
        QOrganizerItemIntersectionFilter qcif;
 
1018
        qcif << detailFilter1;
 
1019
        qcif << detailFilter2;
 
1020
        QTest::newRow("Normal intersection filter")
 
1021
                << static_cast<QOrganizerItemFilter>(qcif)
 
1022
                << static_cast<QOrganizerItemFilter>(qcif);
 
1023
    }
 
1024
 
 
1025
    {
 
1026
        QOrganizerItemUnionFilter qcuf;
 
1027
        qcuf << detailFilter1;
 
1028
        qcuf << detailFilter2;
 
1029
        QTest::newRow("Normal intersection filter")
 
1030
                << static_cast<QOrganizerItemFilter>(qcuf)
 
1031
                << static_cast<QOrganizerItemFilter>(qcuf);
 
1032
    }
 
1033
 
 
1034
    {
 
1035
        QOrganizerItemIntersectionFilter qcif;
 
1036
        QTest::newRow("Empty intersection")
 
1037
                << static_cast<QOrganizerItemFilter>(qcif)
 
1038
                << static_cast<QOrganizerItemFilter>(defaultFilter);
 
1039
    }
 
1040
 
 
1041
    {
 
1042
        QOrganizerItemUnionFilter qcuf;
 
1043
        QTest::newRow("Empty union")
 
1044
                << static_cast<QOrganizerItemFilter>(qcuf)
 
1045
                << static_cast<QOrganizerItemFilter>(invalidFilter);
 
1046
    }
 
1047
 
 
1048
    {
 
1049
        QOrganizerItemIntersectionFilter qcif;
 
1050
        qcif << detailFilter1;
 
1051
        QTest::newRow("Single entry intersection filter")
 
1052
                << static_cast<QOrganizerItemFilter>(qcif)
 
1053
                << static_cast<QOrganizerItemFilter>(detailFilter1);
 
1054
    }
 
1055
 
 
1056
    {
 
1057
        QOrganizerItemUnionFilter qcuf;
 
1058
        qcuf << detailFilter1;
 
1059
        QTest::newRow("Single entry union filter")
 
1060
                << static_cast<QOrganizerItemFilter>(qcuf)
 
1061
                << static_cast<QOrganizerItemFilter>(detailFilter1);
 
1062
    }
 
1063
 
 
1064
    {
 
1065
        QOrganizerItemIntersectionFilter qcif;
 
1066
        qcif << invalidFilter;
 
1067
        qcif << detailFilter1;
 
1068
        qcif << detailFilter2;
 
1069
        QTest::newRow("Intersection with invalid")
 
1070
                << static_cast<QOrganizerItemFilter>(qcif)
 
1071
                << static_cast<QOrganizerItemFilter>(invalidFilter);
 
1072
    }
 
1073
 
 
1074
    {
 
1075
        QOrganizerItemIntersectionFilter qcif;
 
1076
        qcif << defaultFilter;
 
1077
        qcif << detailFilter1;
 
1078
        qcif << detailFilter2;
 
1079
        QOrganizerItemIntersectionFilter expected;
 
1080
        expected << detailFilter1;
 
1081
        expected << detailFilter2;
 
1082
        QTest::newRow("Intersection with default")
 
1083
                << static_cast<QOrganizerItemFilter>(qcif)
 
1084
                << static_cast<QOrganizerItemFilter>(expected);
 
1085
    }
 
1086
 
 
1087
    {
 
1088
        QOrganizerItemUnionFilter qcuf;
 
1089
        qcuf << invalidFilter;
 
1090
        qcuf << detailFilter1;
 
1091
        qcuf << detailFilter2;
 
1092
        QOrganizerItemUnionFilter expected;
 
1093
        expected << detailFilter1;
 
1094
        expected << detailFilter2;
 
1095
        QTest::newRow("Union with invalid")
 
1096
                << static_cast<QOrganizerItemFilter>(qcuf)
 
1097
                << static_cast<QOrganizerItemFilter>(expected);
 
1098
    }
 
1099
 
 
1100
    {
 
1101
        QOrganizerItemUnionFilter qcuf;
 
1102
        qcuf << defaultFilter;
 
1103
        qcuf << detailFilter1;
 
1104
        qcuf << detailFilter2;
 
1105
        QTest::newRow("Union with default")
 
1106
                << static_cast<QOrganizerItemFilter>(qcuf)
 
1107
                << static_cast<QOrganizerItemFilter>(defaultFilter);
 
1108
    }
 
1109
 
 
1110
    {
 
1111
        QOrganizerItemIdFilter qclif;
 
1112
        QTest::newRow("Empty local id filter")
 
1113
                << static_cast<QOrganizerItemFilter>(qclif)
 
1114
                << static_cast<QOrganizerItemFilter>(invalidFilter);
 
1115
    }
 
1116
 
 
1117
    {
 
1118
        QOrganizerItemIdFilter qclif;
 
1119
        qclif.setIds(QList<QOrganizerItemId>() << makeId(1) << makeId(2));
 
1120
        QTest::newRow("Normal local id filter")
 
1121
                << static_cast<QOrganizerItemFilter>(qclif)
 
1122
                << static_cast<QOrganizerItemFilter>(qclif);
 
1123
    }
 
1124
 
 
1125
    {
 
1126
        QOrganizerItemDetailRangeFilter qcdrf;
 
1127
        qcdrf.setDetail(QOrganizerItemDetail::TypeLocation, QOrganizerItemLocation::FieldLabel);
 
1128
        QOrganizerItemDetailFieldFilter expected;
 
1129
        expected.setDetail(QOrganizerItemDetail::TypeLocation, QOrganizerItemLocation::FieldLabel);
 
1130
        QTest::newRow("Null valued range filter")
 
1131
                << static_cast<QOrganizerItemFilter>(qcdrf)
 
1132
                << static_cast<QOrganizerItemFilter>(expected);
 
1133
    }
 
1134
 
 
1135
    {
 
1136
        QOrganizerItemDetailRangeFilter qcdrf;
 
1137
        qcdrf.setDetail(QOrganizerItemDetail::TypeLocation, QOrganizerItemLocation::FieldLabel);
 
1138
        qcdrf.setRange(QStringLiteral("a"), QStringLiteral("a"));
 
1139
        qcdrf.setMatchFlags(QOrganizerItemFilter::MatchFixedString);
 
1140
        QOrganizerItemDetailFieldFilter expected;
 
1141
        expected.setDetail(QOrganizerItemDetail::TypeLocation, QOrganizerItemLocation::FieldLabel);
 
1142
        expected.setValue(QStringLiteral("a"));
 
1143
        expected.setMatchFlags(QOrganizerItemFilter::MatchFixedString);
 
1144
        QTest::newRow("Equal valued range filter")
 
1145
                << static_cast<QOrganizerItemFilter>(qcdrf)
 
1146
                << static_cast<QOrganizerItemFilter>(expected);
 
1147
    }
 
1148
 
 
1149
    {
 
1150
        QOrganizerItemDetailRangeFilter qcdrf;
 
1151
        qcdrf.setDetail(QOrganizerItemDetail::TypeLocation, QOrganizerItemLocation::FieldLabel);
 
1152
        qcdrf.setRange(QStringLiteral("a"), QStringLiteral("a"),
 
1153
               QOrganizerItemDetailRangeFilter::ExcludeLower | QOrganizerItemDetailRangeFilter::ExcludeUpper);
 
1154
        qcdrf.setMatchFlags(QOrganizerItemFilter::MatchFixedString);
 
1155
        QTest::newRow("Equal valued range filter with excluded bounds")
 
1156
                << static_cast<QOrganizerItemFilter>(qcdrf)
 
1157
                << static_cast<QOrganizerItemFilter>(invalidFilter);
 
1158
    }
 
1159
 
 
1160
    {
 
1161
        QOrganizerItemDetailRangeFilter qcdrf;
 
1162
        qcdrf.setDetail(QOrganizerItemDetail::TypeLocation, QOrganizerItemLocation::FieldLabel);
 
1163
        qcdrf.setRange(QStringLiteral("a"), QStringLiteral("b"));
 
1164
        qcdrf.setMatchFlags(QOrganizerItemFilter::MatchFixedString);
 
1165
        QTest::newRow("Normal range filter")
 
1166
                << static_cast<QOrganizerItemFilter>(qcdrf)
 
1167
                << static_cast<QOrganizerItemFilter>(qcdrf);
 
1168
    }
 
1169
 
 
1170
    {
 
1171
        QOrganizerItemDetailRangeFilter qcdrf;
 
1172
        qcdrf.setDetail(QOrganizerItemDetail::TypeLocation, QOrganizerItemLocation::FieldLabel);
 
1173
        qcdrf.setRange(QVariant(QVariant::String), QVariant(QVariant::String)); // null bounds
 
1174
        qcdrf.setMatchFlags(QOrganizerItemFilter::MatchFixedString);
 
1175
        QOrganizerItemDetailFieldFilter qcdf;
 
1176
        qcdf.setDetail(QOrganizerItemDetail::TypeLocation, QOrganizerItemLocation::FieldLabel);
 
1177
        qcdf.setMatchFlags(QOrganizerItemFilter::MatchFixedString);
 
1178
        qcdf.setValue(QVariant(QVariant::String));
 
1179
        QTest::newRow("Null valued range filter")
 
1180
                << static_cast<QOrganizerItemFilter>(qcdrf)
 
1181
                << static_cast<QOrganizerItemFilter>(qcdf);
 
1182
    }
 
1183
 
 
1184
    {
 
1185
        QOrganizerItemDetailRangeFilter qcdrf;
 
1186
        qcdrf.setDetail(QOrganizerItemDetail::TypeLocation, QOrganizerItemLocation::FieldLabel);
 
1187
        qcdrf.setRange(QVariant(QVariant::String), QStringLiteral("a")); // min is null
 
1188
        qcdrf.setMatchFlags(QOrganizerItemFilter::MatchFixedString);
 
1189
        QTest::newRow("One sided range filter")
 
1190
                << static_cast<QOrganizerItemFilter>(qcdrf)
 
1191
                << static_cast<QOrganizerItemFilter>(qcdrf);
 
1192
    }
 
1193
 
 
1194
    {
 
1195
        QOrganizerItemDetailRangeFilter qcdrf;
 
1196
        QTest::newRow("Empty range filter")
 
1197
                << static_cast<QOrganizerItemFilter>(qcdrf)
 
1198
                << static_cast<QOrganizerItemFilter>(invalidFilter);
 
1199
    }
 
1200
 
 
1201
    {
 
1202
        QOrganizerItemDetailFieldFilter qcdf;
 
1203
        QTest::newRow("Empty detail filter")
 
1204
                << static_cast<QOrganizerItemFilter>(qcdf)
 
1205
                << static_cast<QOrganizerItemFilter>(invalidFilter);
 
1206
    }
 
1207
}
 
1208
 
 
1209
void tst_QOrganizerItemFilter::testFilter()
 
1210
{
 
1211
    QFETCH(QOrganizerItem, item);
 
1212
    QFETCH(QOrganizerItemDetailFieldFilter, filter);
 
1213
    QFETCH(bool, expected);
 
1214
 
 
1215
    QCOMPARE(QOrganizerManagerEngine::testFilter(filter, item), expected);
 
1216
}
 
1217
 
 
1218
void tst_QOrganizerItemFilter::testFilter_data()
 
1219
{
 
1220
    QTest::addColumn<QOrganizerItem>("item");
 
1221
    QTest::addColumn<QOrganizerItemDetailFieldFilter>("filter");
 
1222
    QTest::addColumn<bool>("expected");
 
1223
 
 
1224
    // XXX TODO: other detail types (comment, description, ...)
 
1225
 
 
1226
    {
 
1227
        QOrganizerItem item;
 
1228
        QOrganizerItemLocation name;
 
1229
        name.setLabel("test location");
 
1230
        item.saveDetail(&name);
 
1231
 
 
1232
        QOrganizerItemDetailFieldFilter filter;
 
1233
        filter.setDetail(QOrganizerItemDetail::TypeLocation, QOrganizerItemLocation::FieldLabel);
 
1234
        filter.setMatchFlags(QOrganizerItemFilter::MatchContains);
 
1235
 
 
1236
        filter.setValue("test location");
 
1237
        QTest::newRow("QOrganizerItemLocation::match location")
 
1238
                << item
 
1239
                << filter
 
1240
                << true;
 
1241
 
 
1242
        filter.setValue("ocati");
 
1243
        QTest::newRow("QOrganizerItemLocation::match substring")
 
1244
                << item
 
1245
                << filter
 
1246
                << true;
 
1247
 
 
1248
        filter.setValue("foo");
 
1249
        QTest::newRow("QOrganizerItemLocation::match negative")
 
1250
                << item
 
1251
                << filter
 
1252
                << false;
 
1253
    }
 
1254
 
 
1255
    {
 
1256
        QOrganizerItem item;
 
1257
        item.setDisplayLabel(QStringLiteral("foo"));
 
1258
 
 
1259
        QOrganizerItemDetailFieldFilter filter;
 
1260
        filter.setDetail(QOrganizerItemDetail::TypeDisplayLabel, QOrganizerItemDisplayLabel::FieldLabel);
 
1261
        filter.setMatchFlags(QOrganizerItemFilter::MatchContains);
 
1262
 
 
1263
        filter.setValue("foo");
 
1264
        QTest::newRow("QOrganizerItemDisplayLabel::match positive")
 
1265
                << item
 
1266
                << filter
 
1267
                << true;
 
1268
 
 
1269
        filter.setValue("o");
 
1270
        QTest::newRow("QOrganizerItemDisplayLabel::match positive substring")
 
1271
                << item
 
1272
                << filter
 
1273
                << true;
 
1274
 
 
1275
        filter.setValue("bar");
 
1276
        QTest::newRow("QOrganizerItemDisplayLabel::match negative")
 
1277
                << item
 
1278
                << filter
 
1279
                << false;
 
1280
    }
 
1281
 
 
1282
    {
 
1283
        QOrganizerItem item;
 
1284
        QOrganizerItemPriority priority;
 
1285
        priority.setPriority(QOrganizerItemPriority::VeryHighPriority);
 
1286
        item.saveDetail(&priority);
 
1287
 
 
1288
        QOrganizerItemDetailFieldFilter filter;
 
1289
        filter.setDetail(QOrganizerItemDetail::TypePriority, QOrganizerItemPriority::FieldPriority);
 
1290
        filter.setMatchFlags(QOrganizerItemFilter::MatchContains);
 
1291
 
 
1292
        filter.setValue(QOrganizerItemPriority::VeryHighPriority);
 
1293
        QTest::newRow("QOrganizerItemPriority::match positive")
 
1294
                << item
 
1295
                << filter
 
1296
                << true;
 
1297
 
 
1298
        filter.setValue(QOrganizerItemPriority::VeryLowPriority);
 
1299
        QTest::newRow("QOrganizerItemPhoneNumber::match negative")
 
1300
                << item
 
1301
                << filter
 
1302
                << false;
 
1303
    }
 
1304
}
 
1305
 
 
1306
void tst_QOrganizerItemFilter::datastream()
 
1307
{
 
1308
    QFETCH(QOrganizerItemFilter, filterIn);
 
1309
 
 
1310
    QByteArray buffer;
 
1311
    QDataStream stream1(&buffer, QIODevice::WriteOnly);
 
1312
    stream1 << filterIn;
 
1313
 
 
1314
    QVERIFY(buffer.size() > 0);
 
1315
 
 
1316
    QDataStream stream2(buffer);
 
1317
    QOrganizerItemFilter filterOut;
 
1318
    stream2 >> filterOut;
 
1319
    QCOMPARE(filterOut, filterIn);
 
1320
}
 
1321
 
 
1322
void tst_QOrganizerItemFilter::datastream_data()
 
1323
{
 
1324
    QTest::addColumn<QOrganizerItemFilter>("filterIn");
 
1325
 
 
1326
    {
 
1327
        QOrganizerItemFilter filter;
 
1328
        QTest::newRow("default") << filter;
 
1329
    }
 
1330
 
 
1331
    {
 
1332
        QOrganizerItemDetailFieldFilter filter;
 
1333
        filter.setDetail(QOrganizerItemDetail::TypeComment, QOrganizerItemComment::FieldComment);
 
1334
        filter.setMatchFlags(QOrganizerItemFilter::MatchEndsWith);
 
1335
        filter.setValue("ski");
 
1336
        QTest::newRow("detail") << (QOrganizerItemFilter)filter;
 
1337
    }
 
1338
 
 
1339
    {
 
1340
        QOrganizerItemIntersectionFilter filter;
 
1341
        QTest::newRow("intersection") << (QOrganizerItemFilter)filter;
 
1342
    }
 
1343
 
 
1344
    {
 
1345
        QOrganizerItemInvalidFilter filter;
 
1346
        QTest::newRow("invalid") << (QOrganizerItemFilter)filter;
 
1347
    }
 
1348
 
 
1349
    {
 
1350
        QOrganizerItemUnionFilter filter;
 
1351
        QTest::newRow("union") << (QOrganizerItemFilter)filter;
 
1352
    }
 
1353
 
 
1354
    // NOTE: LocalIdFilter streaming is not supported
 
1355
}
 
1356
 
 
1357
void tst_QOrganizerItemFilter::traits()
 
1358
{
 
1359
    QCOMPARE(sizeof(QOrganizerItemFilter), sizeof(void *));
 
1360
    QTypeInfo<QOrganizerItemFilter> ti;
 
1361
    QVERIFY(ti.isComplex);
 
1362
    QVERIFY(!ti.isStatic);
 
1363
    QVERIFY(!ti.isLarge);
 
1364
    QVERIFY(!ti.isPointer);
 
1365
    QVERIFY(!ti.isDummy);
 
1366
}
 
1367
 
 
1368
void tst_QOrganizerItemFilter::sortTraits()
 
1369
{
 
1370
    QCOMPARE(sizeof(QOrganizerItemSortOrder), sizeof(void *));
 
1371
    QTypeInfo<QOrganizerItemSortOrder> ti;
 
1372
    QVERIFY(ti.isComplex);
 
1373
    QVERIFY(!ti.isStatic);
 
1374
    QVERIFY(!ti.isLarge);
 
1375
    QVERIFY(!ti.isPointer);
 
1376
    QVERIFY(!ti.isDummy);
 
1377
}
 
1378
 
 
1379
void tst_QOrganizerItemFilter::testDebugStreamOut()
 
1380
{
 
1381
    QFETCH(QOrganizerItemFilter, filterIn);
 
1382
    QFETCH(QString, messageExpected);
 
1383
 
 
1384
    QTest::ignoreMessage(QtDebugMsg, messageExpected.toUtf8());
 
1385
    qDebug() << filterIn;
 
1386
 
 
1387
    QOrganizerItemSortOrder sortorder;
 
1388
    QTest::ignoreMessage(QtDebugMsg, "QOrganizerItemSortOrder(detailType=0,detailField=-1,blankPolicy=1,direction=0,caseSensitivity=1)");
 
1389
    qDebug() << sortorder;
 
1390
}
 
1391
 
 
1392
void tst_QOrganizerItemFilter::testDebugStreamOut_data()
 
1393
{
 
1394
    QTest::addColumn<QOrganizerItemFilter>("filterIn");
 
1395
    QTest::addColumn<QString>("messageExpected");
 
1396
 
 
1397
    {
 
1398
        QOrganizerItemFilter filter;
 
1399
        QTest::newRow("default") << filter << "QOrganizerItemFilter((null))";
 
1400
    }
 
1401
 
 
1402
    {
 
1403
        QOrganizerItemCollectionFilter filter;
 
1404
        QOrganizerCollectionId id1 = makeCId(5);
 
1405
        QOrganizerCollectionId id2 = makeCId(6);
 
1406
        QOrganizerCollectionId id3 = makeCId(7);
 
1407
        QOrganizerCollectionId id4 = makeCId(12);
 
1408
        QSet<QOrganizerCollectionId> ids;
 
1409
        ids << id1 << id2 << id3;
 
1410
        filter.setCollectionIds(ids);
 
1411
        // Testing method setCollectionIds
 
1412
        // FIXME: QTBUG-25382: Assumes QSet is an ordered collection, which it's not
 
1413
        // QTest::newRow("collection") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemCollectionFilter(collectionIds=QSet(QOrganizerCollectionId(5), QOrganizerCollectionId(6), QOrganizerCollectionId(7)) ))";
 
1414
 
 
1415
        filter.setCollectionId(id2);
 
1416
        // Testing method setCollectionId (and the related clearing of the collection)
 
1417
        QTest::newRow("collection") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemCollectionFilter(collectionIds=QSet(QOrganizerCollectionId(6)) ))";
 
1418
        filter.setCollectionId(id4);
 
1419
        // Testing again method setCollectionId (and the related clearing of the collection)
 
1420
        QTest::newRow("collection") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemCollectionFilter(collectionIds=QSet(QOrganizerCollectionId(12)) ))";
 
1421
        ids.clear();
 
1422
        ids << id4;
 
1423
        // Testing again method setCollectionIds
 
1424
        QTest::newRow("collection") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemCollectionFilter(collectionIds=QSet(QOrganizerCollectionId(12)) ))";
 
1425
 
 
1426
        QOrganizerItemCollectionFilter filter2;
 
1427
        filter2 = filter;
 
1428
        // Testing again method setCollectionIds on the copied filter
 
1429
        QTest::newRow("collection") << (QOrganizerItemFilter)filter2 << "QOrganizerItemFilter(QOrganizerItemCollectionFilter(collectionIds=QSet(QOrganizerCollectionId(12)) ))";
 
1430
 
 
1431
        QOrganizerItemFilter fil;
 
1432
        fil = filter;
 
1433
        // Testing that the assignment/conversion went fine
 
1434
        QTest::newRow("collection") << (QOrganizerItemFilter)fil << "QOrganizerItemFilter(QOrganizerItemCollectionFilter(collectionIds=QSet(QOrganizerCollectionId(12)) ))";
 
1435
 
 
1436
        QOrganizerItemCollectionFilter filter3(fil);
 
1437
        QTest::newRow("collection") << (QOrganizerItemFilter)filter3 << "QOrganizerItemFilter(QOrganizerItemCollectionFilter(collectionIds=QSet(QOrganizerCollectionId(12)) ))";
 
1438
    }
 
1439
 
 
1440
    {
 
1441
        QOrganizerItemDetailFieldFilter filter;
 
1442
        filter.setDetail(QOrganizerItemDetail::TypeComment, QOrganizerItemComment::FieldComment);
 
1443
        filter.setMatchFlags(QOrganizerItemFilter::MatchEndsWith);
 
1444
        filter.setValue("ski");
 
1445
        QTest::newRow("detail") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemDetailFieldFilter(detailType=200,detailField=201,value=QVariant(QString, \"ski\") ,matchFlags=3))";
 
1446
    }
 
1447
 
 
1448
    {
 
1449
        QOrganizerItemDetailRangeFilter filter;
 
1450
        // Testing the empty fields
 
1451
        QTest::newRow("detailRange") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=0,detailField=-1,minValue=QVariant(Invalid) ,maxValue=QVariant(Invalid) ,matchFlags=0,rangeFlags=0))";
 
1452
 
 
1453
        // Testing the method setDetail
 
1454
        filter.setDetail(QOrganizerItemDetail::TypeLocation, QOrganizerItemLocation::FieldLabel);
 
1455
        QTest::newRow("detailRange") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(Invalid) ,maxValue=QVariant(Invalid) ,matchFlags=0,rangeFlags=0))";
 
1456
 
 
1457
        // Testing the method rangeFlags
 
1458
        filter.setMatchFlags(QOrganizerItemFilter::MatchExactly);
 
1459
        QTest::newRow("detailRange") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(Invalid) ,maxValue=QVariant(Invalid) ,matchFlags=0,rangeFlags=0))";
 
1460
 
 
1461
        // Testing the method matchFlags
 
1462
        filter.setMatchFlags(QOrganizerItemFilter::MatchCaseSensitive);
 
1463
        QTest::newRow("detailRange") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(Invalid) ,maxValue=QVariant(Invalid) ,matchFlags=16,rangeFlags=0))";
 
1464
 
 
1465
        // Contains is not allowed
 
1466
        filter.setMatchFlags(QOrganizerItemFilter::MatchCaseSensitive | QOrganizerItemFilter::MatchContains);
 
1467
        QTest::newRow("detailRange") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(Invalid) ,maxValue=QVariant(Invalid) ,matchFlags=16,rangeFlags=0))";
 
1468
        filter.setMatchFlags(QOrganizerItemFilter::MatchEndsWith);
 
1469
        QTest::newRow("detailRange") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(Invalid) ,maxValue=QVariant(Invalid) ,matchFlags=0,rangeFlags=0))";
 
1470
 
 
1471
        // Testing the minValue and maxValue
 
1472
        filter.setRange(5, 10);
 
1473
        QTest::newRow("detailRange") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(int, 5) ,maxValue=QVariant(int, 10) ,matchFlags=0,rangeFlags=0))";
 
1474
 
 
1475
        // Testing the setRange
 
1476
        filter.setRange(QVariant(), 11);
 
1477
        QTest::newRow("detailRange") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(Invalid) ,maxValue=QVariant(int, 11) ,matchFlags=0,rangeFlags=0))";
 
1478
 
 
1479
        filter.setRange(6, QVariant());
 
1480
        QTest::newRow("detailRange") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(int, 6) ,maxValue=QVariant(Invalid) ,matchFlags=0,rangeFlags=0))";
 
1481
 
 
1482
        filter.setRange(QVariant(), QVariant());
 
1483
        QTest::newRow("detailRange") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(Invalid) ,maxValue=QVariant(Invalid) ,matchFlags=0,rangeFlags=0))";
 
1484
 
 
1485
        filter.setRange(5, 10, QOrganizerItemDetailRangeFilter::ExcludeLower);
 
1486
        QTest::newRow("detailRange") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(int, 5) ,maxValue=QVariant(int, 10) ,matchFlags=0,rangeFlags=2))";  // *
 
1487
 
 
1488
        filter.setRange(QVariant(), 11, QOrganizerItemDetailRangeFilter::IncludeUpper);
 
1489
        QTest::newRow("detailRange") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(Invalid) ,maxValue=QVariant(int, 11) ,matchFlags=0,rangeFlags=1))";
 
1490
 
 
1491
        filter.setRange(6, QVariant(), QOrganizerItemDetailRangeFilter::ExcludeLower | QOrganizerItemDetailRangeFilter::IncludeUpper);
 
1492
        QTest::newRow("detailRange") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(int, 6) ,maxValue=QVariant(Invalid) ,matchFlags=0,rangeFlags=3))";
 
1493
 
 
1494
    filter.setRange(QVariant(), QVariant(), QOrganizerItemDetailRangeFilter::ExcludeUpper | QOrganizerItemDetailRangeFilter::IncludeLower);
 
1495
        QTest::newRow("detailRange") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(Invalid) ,maxValue=QVariant(Invalid) ,matchFlags=0,rangeFlags=0))";
 
1496
 
 
1497
    // Test op=
 
1498
    QOrganizerItemFilter f = filter;
 
1499
    QTest::newRow("detailRange") << (QOrganizerItemFilter)f << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(Invalid) ,maxValue=QVariant(Invalid) ,matchFlags=0,rangeFlags=0))";
 
1500
 
 
1501
    QOrganizerItemDetailRangeFilter filter2 = f;
 
1502
    QTest::newRow("detailRange") << (QOrganizerItemFilter)filter2 << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(Invalid) ,maxValue=QVariant(Invalid) ,matchFlags=0,rangeFlags=0))";
 
1503
 
 
1504
    filter2 = filter;
 
1505
    QTest::newRow("detailRange") << (QOrganizerItemFilter)filter2 << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(Invalid) ,maxValue=QVariant(Invalid) ,matchFlags=0,rangeFlags=0))";
 
1506
 
 
1507
    // Self assignment should do nothing
 
1508
    filter2 = filter2;
 
1509
    QTest::newRow("detailRange") << (QOrganizerItemFilter)filter2 << "QOrganizerItemFilter(QOrganizerItemDetailRangeFilter(detailType=700,detailField=703,minValue=QVariant(Invalid) ,maxValue=QVariant(Invalid) ,matchFlags=0,rangeFlags=0))";
 
1510
    }
 
1511
 
 
1512
    {
 
1513
        // Testing creation of an empty filter
 
1514
        QOrganizerItemIdFilter filter;
 
1515
        QTest::newRow("Id") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemIdFilter(ids=() ))";
 
1516
 
 
1517
        // Testing the method setIds
 
1518
        QList<QOrganizerItemId> ids;
 
1519
        ids << makeId(5) << makeId(6) << makeId(17);
 
1520
        filter.setIds(ids);
 
1521
        QTest::newRow("Id") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemIdFilter(ids=(QOrganizerItemId(5), QOrganizerItemId(6), QOrganizerItemId(17)) ))";
 
1522
 
 
1523
        // Resetting the list of Ids
 
1524
        filter.setIds(QList<QOrganizerItemId>());
 
1525
        QTest::newRow("Id") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemIdFilter(ids=() ))";
 
1526
 
 
1527
        // Testing the method insert
 
1528
        QOrganizerItemId singleId = makeId(12);
 
1529
        filter.insert(singleId);
 
1530
        QTest::newRow("Id") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemIdFilter(ids=(QOrganizerItemId(12)) ))";
 
1531
 
 
1532
        // Testing the method remove
 
1533
        filter.remove(singleId);
 
1534
        QTest::newRow("Id") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemIdFilter(ids=() ))";
 
1535
 
 
1536
        QList<QOrganizerItemId> allIds = filter.ids();
 
1537
        filter.remove(singleId); // remove again
 
1538
        filter.clear();
 
1539
        filter.setIds(allIds);
 
1540
        QTest::newRow("Id") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemIdFilter(ids=() ))";
 
1541
 
 
1542
        // Test op=
 
1543
        filter.setIds(ids);
 
1544
        QOrganizerItemFilter f = filter;
 
1545
        QTest::newRow("Id") << (QOrganizerItemFilter)f << "QOrganizerItemFilter(QOrganizerItemIdFilter(ids=(QOrganizerItemId(5), QOrganizerItemId(6), QOrganizerItemId(17)) ))";
 
1546
        QOrganizerItemIdFilter filter2 = f;
 
1547
        QTest::newRow("Id") << (QOrganizerItemFilter)filter2 << "QOrganizerItemFilter(QOrganizerItemIdFilter(ids=(QOrganizerItemId(5), QOrganizerItemId(6), QOrganizerItemId(17)) ))";
 
1548
        filter2 = filter;
 
1549
        QTest::newRow("Id") << (QOrganizerItemFilter)filter2 << "QOrganizerItemFilter(QOrganizerItemIdFilter(ids=(QOrganizerItemId(5), QOrganizerItemId(6), QOrganizerItemId(17)) ))";
 
1550
 
 
1551
        // Self assignment should do nothing
 
1552
        filter2 = filter2;
 
1553
        QTest::newRow("Id") << (QOrganizerItemFilter)filter2 << "QOrganizerItemFilter(QOrganizerItemIdFilter(ids=(QOrganizerItemId(5), QOrganizerItemId(6), QOrganizerItemId(17)) ))";
 
1554
 
 
1555
        QOrganizerItemDetailFieldFilter dfil;
 
1556
        QOrganizerItemIdFilter filter3(dfil);
 
1557
        QTest::newRow("Id") << (QOrganizerItemFilter)filter3 << "QOrganizerItemFilter(QOrganizerItemIdFilter(ids=() ))";
 
1558
 
 
1559
        QOrganizerItemIdFilter filter4(filter);
 
1560
        QTest::newRow("Id") << (QOrganizerItemFilter)filter4 << "QOrganizerItemFilter(QOrganizerItemIdFilter(ids=(QOrganizerItemId(5), QOrganizerItemId(6), QOrganizerItemId(17)) ))";
 
1561
        filter = dfil; // now assign.
 
1562
        QTest::newRow("Id") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemIdFilter(ids=() ))";
 
1563
        QTest::newRow("Id") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemIdFilter(ids=() ))";
 
1564
        filter = filter3;
 
1565
        filter.setIds(ids); // force a detach
 
1566
        QTest::newRow("Id") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemIdFilter(ids=(QOrganizerItemId(5), QOrganizerItemId(6), QOrganizerItemId(17)) ))";
 
1567
    }
 
1568
 
 
1569
    {
 
1570
 
 
1571
        // Test empty filter
 
1572
        QOrganizerItemIntersectionFilter filter;
 
1573
        QTest::newRow("intersection") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemIntersectionFilter(filters=() ))";
 
1574
 
 
1575
        // Test boolean ops
 
1576
        QOrganizerItemDetailFieldFilter filter1;
 
1577
        filter1.setDetail(QOrganizerItemDetail::TypeComment, QOrganizerItemComment::FieldComment);
 
1578
 
 
1579
        QOrganizerItemDetailFieldFilter filter2;
 
1580
        filter2.setDetail(QOrganizerItemDetail::TypeDescription, QOrganizerItemDescription::FieldDescription);
 
1581
 
 
1582
        QOrganizerItemDetailFieldFilter filter3;
 
1583
        filter3.setDetail(QOrganizerItemDetail::TypeDisplayLabel, QOrganizerItemDisplayLabel::FieldLabel);
 
1584
 
 
1585
        filter << filter1 << filter2;
 
1586
        QTest::newRow("intersection") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemIntersectionFilter(filters=(QOrganizerItemFilter(QOrganizerItemDetailFieldFilter(detailType=200,detailField=201,value=QVariant(Invalid) ,matchFlags=0)), QOrganizerItemFilter(QOrganizerItemDetailFieldFilter(detailType=300,detailField=301,value=QVariant(Invalid) ,matchFlags=0))) ))";
 
1587
    }
 
1588
 
 
1589
    {
 
1590
        QOrganizerItemInvalidFilter filter;
 
1591
        QTest::newRow("invalid") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemInvalidFilter())";
 
1592
    }
 
1593
 
 
1594
    {
 
1595
        QOrganizerItemUnionFilter filter;
 
1596
        QTest::newRow("union") << (QOrganizerItemFilter)filter << "QOrganizerItemFilter(QOrganizerItemUnionFilter(filters=() ))";
 
1597
 
 
1598
        // Test boolean ops
 
1599
        QOrganizerItemDetailFieldFilter df;
 
1600
        df.setDetail(QOrganizerItemDetail::TypeComment, QOrganizerItemComment::FieldComment);
 
1601
 
 
1602
        QOrganizerItemDetailFieldFilter df2;
 
1603
        df2.setDetail(QOrganizerItemDetail::TypeDescription, QOrganizerItemDescription::FieldDescription);
 
1604
 
 
1605
        QOrganizerItemDetailFieldFilter df3;
 
1606
        df3.setDetail(QOrganizerItemDetail::TypeDisplayLabel, QOrganizerItemDisplayLabel::FieldLabel);
 
1607
 
 
1608
        QOrganizerItemUnionFilter bf;
 
1609
        bf << df << df2;
 
1610
        QTest::newRow("union") << (QOrganizerItemFilter)bf << "QOrganizerItemFilter(QOrganizerItemUnionFilter(filters=(QOrganizerItemFilter(QOrganizerItemDetailFieldFilter(detailType=200,detailField=201,value=QVariant(Invalid) ,matchFlags=0)), QOrganizerItemFilter(QOrganizerItemDetailFieldFilter(detailType=300,detailField=301,value=QVariant(Invalid) ,matchFlags=0))) ))";
 
1611
    }
 
1612
 
 
1613
}
 
1614
 
 
1615
 
 
1616
QTEST_MAIN(tst_QOrganizerItemFilter)
 
1617
#include "tst_qorganizeritemfilter.moc"