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

source code of qtpim/tests/auto/organizer/qorganizeritemfilter/tst_qorganizeritemfilter.cpp