|
1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Main test class for hspluginmodel library. |
|
15 * |
|
16 */ |
|
17 |
|
18 #include <QScopedPointer> |
|
19 #include <qservicemanager.h> |
|
20 |
|
21 #include "t_caclient.h" |
|
22 #include "caservice.h" |
|
23 #include "canotifier.h" |
|
24 #include "canotifierfilter.h" |
|
25 #include "caquery.h" |
|
26 #include "t_caclientNotifier.h" |
|
27 |
|
28 const int entryIdFake(-1); |
|
29 const int waitTime500ms(500); |
|
30 const int waitTime1sec(1000); |
|
31 |
|
32 QTM_USE_NAMESPACE |
|
33 |
|
34 QStringList pluginPaths; |
|
35 QString xmlName("caapphandlerplugin.xml"); |
|
36 |
|
37 // --------------------------------------------------------------------------- |
|
38 // --------------------------------------------------------------------------- |
|
39 // |
|
40 void TestCaClient::initTestCase() |
|
41 { |
|
42 #ifdef Q_OS_SYMBIAN |
|
43 startThread(); |
|
44 #endif //Q_OS_SYMBIAN |
|
45 mService = CaService::instance(); |
|
46 } |
|
47 // --------------------------------------------------------------------------- |
|
48 // --------------------------------------------------------------------------- |
|
49 // |
|
50 void TestCaClient::cleanupTestCase() |
|
51 { |
|
52 #ifdef Q_OS_SYMBIAN |
|
53 stopThread(); |
|
54 #endif //Q_OS_SYMBIAN |
|
55 QSharedPointer<CaService> serviceNull(NULL); |
|
56 mService = serviceNull; |
|
57 QTest::qWait(5000); |
|
58 } |
|
59 |
|
60 |
|
61 // --------------------------------------------------------------------------- |
|
62 // --------------------------------------------------------------------------- |
|
63 int threadFunction(void *params) |
|
64 { |
|
65 #ifdef Q_OS_SYMBIAN |
|
66 while (ETrue) { |
|
67 User::ResetInactivityTime();//it should help for Viewserver11 panic |
|
68 User::After(5000000); |
|
69 } |
|
70 #endif //Q_OS_SYMBIAN |
|
71 return 0; |
|
72 } |
|
73 |
|
74 // --------------------------------------------------------------------------- |
|
75 // --------------------------------------------------------------------------- |
|
76 // |
|
77 void TestCaClient::startThread() |
|
78 { |
|
79 #ifdef Q_OS_SYMBIAN |
|
80 User::LeaveIfError(iThread.Create( |
|
81 _L("thread_kill_viewsrv11"), |
|
82 threadFunction, |
|
83 16384, |
|
84 4000, |
|
85 4000, |
|
86 NULL)); |
|
87 iThread.Resume(); |
|
88 #endif //Q_OS_SYMBIAN |
|
89 } |
|
90 // --------------------------------------------------------------------------- |
|
91 // --------------------------------------------------------------------------- |
|
92 // |
|
93 void TestCaClient::stopThread() |
|
94 { |
|
95 #ifdef Q_OS_SYMBIAN |
|
96 iThread.Close(); |
|
97 #endif //Q_OS_SYMBIAN |
|
98 } |
|
99 |
|
100 |
|
101 // --------------------------------------------------------------------------- |
|
102 // |
|
103 void TestCaClient::TestAssignmentOperatorNotifier() |
|
104 { |
|
105 #ifdef Q_OS_SYMBIAN |
|
106 #ifdef UT_MEMORY_CHECK |
|
107 // __UHEAP_MARK; |
|
108 #endif//UT_MEMORY_CHECK |
|
109 #endif//Q_OS_SYMBIAN |
|
110 { |
|
111 CaNotifierFilter filter; |
|
112 filter.setEntryRole(ItemEntryRole); |
|
113 filter.setTypeNames(QStringList() << "typeName1" << "typeName2"); |
|
114 filter.setParentId(22); |
|
115 filter.setIds(QList<int>() << 11 << 22); |
|
116 |
|
117 CaNotifierFilter filterAssign; |
|
118 filterAssign = filter; |
|
119 QCOMPARE(filterAssign.getEntryRole(), filter.getEntryRole()); |
|
120 QCOMPARE(filterAssign.getParentId(), filter.getParentId()); |
|
121 for (int i(0); i < filter.getIds().count(); i++) { |
|
122 QCOMPARE(filterAssign.getIds().at(i), |
|
123 filter.getIds().at(i)); |
|
124 } |
|
125 for (int i(0); i < filter.getTypeNames().count(); i++) { |
|
126 QCOMPARE(filterAssign.getTypeNames().at(i), |
|
127 filter.getTypeNames().at(i)); |
|
128 } |
|
129 |
|
130 filter.setEntryRole(GroupEntryRole); |
|
131 filter.getTypeNames().clear(); |
|
132 filter.setTypeNames(QStringList() << "typeName3" << "typeName4"); |
|
133 filter.setParentId(55); |
|
134 filter.getIds().clear(); |
|
135 filter.setIds(QList<int>() << 33 << 44); |
|
136 |
|
137 QVERIFY(filterAssign.getEntryRole() != filter.getEntryRole()); |
|
138 QVERIFY(filterAssign.getParentId() != filter.getParentId()); |
|
139 for (int i(0); i < filter.getIds().count(); i++) { |
|
140 QVERIFY(filterAssign.getIds().at(i) |
|
141 != filter.getIds().at(i)); |
|
142 } |
|
143 for (int i(0); i < filter.getTypeNames().count(); i++) { |
|
144 QVERIFY(filterAssign.getTypeNames().at(i) |
|
145 != filter.getTypeNames().at(i)); |
|
146 } |
|
147 |
|
148 CaNotifierFilter filterCopyConstructor(filter); |
|
149 QCOMPARE(filterCopyConstructor.getEntryRole(), filter.getEntryRole()); |
|
150 QCOMPARE(filterCopyConstructor.getParentId(), filter.getParentId()); |
|
151 for (int i(0); i < filter.getIds().count(); i++) { |
|
152 QCOMPARE(filterCopyConstructor.getIds().at(i), |
|
153 filter.getIds().at(i)); |
|
154 } |
|
155 for (int i(0); i < filter.getTypeNames().count(); i++) { |
|
156 QCOMPARE(filterCopyConstructor.getTypeNames().at(i), |
|
157 filter.getTypeNames().at(i)); |
|
158 } |
|
159 |
|
160 CaQuery query; |
|
161 query.setEntryRoles(GroupEntryRole); |
|
162 query.setEntryTypeNames(QStringList() << "Query1" << "Query2"); |
|
163 query.setParentId(77); |
|
164 |
|
165 CaNotifierFilter filterQuery(query); |
|
166 QCOMPARE(filterQuery.getEntryRole(), query.entryRoles()); |
|
167 QCOMPARE(filterQuery.getParentId(), query.parentId()); |
|
168 QCOMPARE(filterQuery.getIds().count(), 0); |
|
169 for (int i(0); i < query.entryTypeNames().count(); i++) { |
|
170 QCOMPARE(filterQuery.getTypeNames().at(i), |
|
171 query.entryTypeNames().at(i)); |
|
172 } |
|
173 } |
|
174 #ifdef Q_OS_SYMBIAN |
|
175 #ifdef UT_MEMORY_CHECK |
|
176 // __UHEAP_MARKEND; |
|
177 #endif//UT_MEMORY_CHECK |
|
178 #endif//Q_OS_SYMBIAN |
|
179 } |
|
180 // --------------------------------------------------------------------------- |
|
181 // --------------------------------------------------------------------------- |
|
182 // |
|
183 void TestCaClient::TestAddItemChangeTypeNotifier() |
|
184 { |
|
185 #ifdef Q_OS_SYMBIAN |
|
186 #ifdef UT_MEMORY_CHECK |
|
187 // __UHEAP_MARK; |
|
188 #endif//UT_MEMORY_CHECK |
|
189 #endif//Q_OS_SYMBIAN |
|
190 { |
|
191 CaNotifierFilter *filter = new CaNotifierFilter(); |
|
192 filter->setEntryRole(ItemEntryRole); |
|
193 QStringList strList; |
|
194 strList.append("TypeName"); |
|
195 filter->setTypeNames(strList); |
|
196 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter); |
|
197 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
198 |
|
199 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
200 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
201 QTest::qWait(waitTime1sec); |
|
202 CaEntry item; |
|
203 item.setText("Text"); |
|
204 item.setEntryTypeName("TypeName"); |
|
205 QSharedPointer<CaEntry> entry = mService->createEntry(item); |
|
206 QTest::qWait(waitTime1sec); |
|
207 |
|
208 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
209 QVERIFY(clientNotifier->mEntryId > 0); |
|
210 QCOMPARE(clientNotifier->mEntryId, entry->id()); |
|
211 |
|
212 // cleanup |
|
213 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
214 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
215 QTest::qWait(waitTime500ms); |
|
216 delete clientNotifier; |
|
217 delete filter; |
|
218 mService->removeEntry(entry->id()); |
|
219 QTest::qWait(waitTime500ms); |
|
220 QTest::qWait(waitTime500ms); |
|
221 } |
|
222 #ifdef Q_OS_SYMBIAN |
|
223 #ifdef UT_MEMORY_CHECK |
|
224 // __UHEAP_MARKEND; |
|
225 #endif//UT_MEMORY_CHECK |
|
226 #endif//Q_OS_SYMBIAN |
|
227 } |
|
228 // --------------------------------------------------------------------------- |
|
229 // |
|
230 void TestCaClient::TestAddGroupChangeTypeNotifier() |
|
231 { |
|
232 #ifdef Q_OS_SYMBIAN |
|
233 #ifdef UT_MEMORY_CHECK |
|
234 // __UHEAP_MARK; |
|
235 #endif//UT_MEMORY_CHECK |
|
236 #endif//Q_OS_SYMBIAN |
|
237 { |
|
238 |
|
239 CaNotifierFilter *filter = new CaNotifierFilter(); |
|
240 filter->setEntryRole(GroupEntryRole); |
|
241 filter->setTypeNames(QStringList() << "TypeName"); |
|
242 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter); |
|
243 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
244 |
|
245 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
246 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
247 QTest::qWait(waitTime500ms); |
|
248 CaEntry group(GroupEntryRole); |
|
249 group.setText("Text"); |
|
250 group.setEntryTypeName("TypeName"); |
|
251 |
|
252 QSharedPointer<CaEntry> entry = mService->createEntry(group); |
|
253 QTest::qWait(waitTime1sec); |
|
254 |
|
255 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
256 QVERIFY(clientNotifier->mEntryId > 0); |
|
257 QCOMPARE(clientNotifier->mEntryId, entry->id()); |
|
258 |
|
259 // cleanup |
|
260 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
261 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
262 QTest::qWait(waitTime500ms); |
|
263 delete clientNotifier; |
|
264 mService->removeEntry(entry->id()); |
|
265 } |
|
266 #ifdef Q_OS_SYMBIAN |
|
267 #ifdef UT_MEMORY_CHECK |
|
268 // __UHEAP_MARKEND; |
|
269 #endif//UT_MEMORY_CHECK |
|
270 #endif//Q_OS_SYMBIAN |
|
271 } |
|
272 // --------------------------------------------------------------------------- |
|
273 // |
|
274 void TestCaClient::TestRemoveEntryChangeTypeNotifier() |
|
275 { |
|
276 #ifdef Q_OS_SYMBIAN |
|
277 #ifdef UT_MEMORY_CHECK |
|
278 // __UHEAP_MARK; |
|
279 #endif//UT_MEMORY_CHECK |
|
280 #endif//Q_OS_SYMBIAN |
|
281 { |
|
282 |
|
283 CaNotifierFilter *filter = new CaNotifierFilter(); |
|
284 filter->setEntryRole(ItemEntryRole); |
|
285 filter->setTypeNames(QStringList() << "TypeName"); |
|
286 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter); |
|
287 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
288 |
|
289 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
290 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
291 QTest::qWait(waitTime500ms); |
|
292 connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
293 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
294 QTest::qWait(waitTime500ms); |
|
295 CaEntry item; |
|
296 item.setText("Text"); |
|
297 item.setEntryTypeName("TypeName"); |
|
298 |
|
299 QSharedPointer<CaEntry> entry = mService->createEntry(item); |
|
300 QTest::qWait(waitTime1sec); |
|
301 |
|
302 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
303 QVERIFY(clientNotifier->mEntryId > 0); |
|
304 QCOMPARE(clientNotifier->mEntryId, entry->id()); |
|
305 |
|
306 int entryId = clientNotifier->mEntryId; |
|
307 clientNotifier->mEntryId = 0; |
|
308 |
|
309 bool removed = mService->removeEntry(*entry); |
|
310 QTest::qWait(waitTime1sec); |
|
311 |
|
312 QCOMPARE(clientNotifier->mChangeType, RemoveChangeType); |
|
313 QVERIFY(clientNotifier->mEntryId > 0); |
|
314 QCOMPARE(clientNotifier->mEntryId, entryId); |
|
315 QCOMPARE(removed, TRUE); |
|
316 |
|
317 // cleanup |
|
318 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
319 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
320 disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
321 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
322 QTest::qWait(waitTime500ms); |
|
323 delete clientNotifier; |
|
324 mService->removeEntry(entry->id()); |
|
325 } |
|
326 #ifdef Q_OS_SYMBIAN |
|
327 #ifdef UT_MEMORY_CHECK |
|
328 // __UHEAP_MARKEND; |
|
329 #endif//UT_MEMORY_CHECK |
|
330 #endif//Q_OS_SYMBIAN |
|
331 } |
|
332 // --------------------------------------------------------------------------- |
|
333 // |
|
334 void TestCaClient::TestRemoveEntryIdChangeTypeNotifier() |
|
335 { |
|
336 #ifdef Q_OS_SYMBIAN |
|
337 #ifdef UT_MEMORY_CHECK |
|
338 // __UHEAP_MARK; |
|
339 #endif//UT_MEMORY_CHECK |
|
340 #endif//Q_OS_SYMBIAN |
|
341 { |
|
342 |
|
343 |
|
344 CaEntry item; |
|
345 item.setText("Text"); |
|
346 item.setEntryTypeName("TypeName"); |
|
347 |
|
348 QSharedPointer<CaEntry> entry = mService->createEntry(item); |
|
349 QTest::qWait(waitTime1sec); |
|
350 |
|
351 CaNotifierFilter *filter = new CaNotifierFilter(); |
|
352 filter->setEntryRole(ItemEntryRole); |
|
353 filter->setTypeNames(QStringList() << "TypeName"); |
|
354 filter->setIds(QList<int>() << entry->id()); |
|
355 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter); |
|
356 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
357 |
|
358 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
359 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
360 connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
361 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
362 QTest::qWait(waitTime500ms); |
|
363 |
|
364 int entryId = entry->id(); |
|
365 clientNotifier->mEntryId = 0; |
|
366 |
|
367 bool removed = mService->removeEntry(entryId); |
|
368 QTest::qWait(waitTime1sec); |
|
369 |
|
370 QCOMPARE(clientNotifier->mChangeType, RemoveChangeType); |
|
371 QVERIFY(clientNotifier->mEntryId > 0); |
|
372 QCOMPARE(clientNotifier->mEntryId, entryId); |
|
373 QCOMPARE(removed, TRUE); |
|
374 |
|
375 // cleanup |
|
376 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
377 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
378 disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
379 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
380 QTest::qWait(waitTime500ms); |
|
381 delete clientNotifier; |
|
382 delete filter; |
|
383 mService->removeEntry(entry->id()); |
|
384 } |
|
385 #ifdef Q_OS_SYMBIAN |
|
386 #ifdef UT_MEMORY_CHECK |
|
387 // __UHEAP_MARKEND; |
|
388 #endif//UT_MEMORY_CHECK |
|
389 #endif//Q_OS_SYMBIAN |
|
390 } |
|
391 // --------------------------------------------------------------------------- |
|
392 // |
|
393 void TestCaClient::TestRemoveEntryChangeTypeNotifierFake() |
|
394 { |
|
395 #ifdef Q_OS_SYMBIAN |
|
396 #ifdef UT_MEMORY_CHECK |
|
397 // __UHEAP_MARK; |
|
398 #endif//UT_MEMORY_CHECK |
|
399 #endif//Q_OS_SYMBIAN |
|
400 { |
|
401 |
|
402 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
403 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
404 |
|
405 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
406 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
407 connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
408 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
409 QTest::qWait(waitTime500ms); |
|
410 CaEntry item; |
|
411 item.setText("Text"); |
|
412 item.setEntryTypeName("TypeName"); |
|
413 |
|
414 QSharedPointer<CaEntry> entry = mService->createEntry(item); |
|
415 QTest::qWait(waitTime1sec); |
|
416 |
|
417 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
418 QVERIFY(clientNotifier->mEntryId > 0); |
|
419 QCOMPARE(clientNotifier->mEntryId, entry->id()); |
|
420 |
|
421 clientNotifier->mEntryId = 0; |
|
422 CaEntry *entryFake = new CaEntry(); |
|
423 entryFake->setText("Text"); |
|
424 entryFake->setEntryTypeName("TypeName"); |
|
425 |
|
426 bool removed = mService->removeEntry(*entryFake); |
|
427 |
|
428 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
429 QCOMPARE(clientNotifier->mEntryId, 0); |
|
430 QCOMPARE(removed, FALSE); |
|
431 |
|
432 // cleanup |
|
433 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
434 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
435 disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
436 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
437 QTest::qWait(waitTime500ms); |
|
438 delete clientNotifier; |
|
439 mService->removeEntry(entry->id()); |
|
440 delete entryFake; |
|
441 } |
|
442 #ifdef Q_OS_SYMBIAN |
|
443 #ifdef UT_MEMORY_CHECK |
|
444 // __UHEAP_MARKEND; |
|
445 #endif//UT_MEMORY_CHECK |
|
446 #endif//Q_OS_SYMBIAN |
|
447 } |
|
448 // --------------------------------------------------------------------------- |
|
449 // |
|
450 void TestCaClient::TestRemoveEntryIdChangeTypeNotifierFake() |
|
451 { |
|
452 #ifdef Q_OS_SYMBIAN |
|
453 #ifdef UT_MEMORY_CHECK |
|
454 // __UHEAP_MARK; |
|
455 #endif//UT_MEMORY_CHECK |
|
456 #endif//Q_OS_SYMBIAN |
|
457 { |
|
458 |
|
459 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
460 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
461 |
|
462 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
463 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
464 connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
465 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
466 QTest::qWait(waitTime500ms); |
|
467 CaEntry item; |
|
468 item.setText("Text"); |
|
469 item.setEntryTypeName("TypeName"); |
|
470 QSharedPointer<CaEntry> entry = mService->createEntry(item); |
|
471 QTest::qWait(waitTime1sec); |
|
472 |
|
473 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
474 QVERIFY(clientNotifier->mEntryId > 0); |
|
475 QCOMPARE(clientNotifier->mEntryId, entry->id()); |
|
476 |
|
477 clientNotifier->mEntryId = 0; |
|
478 bool removed = mService->removeEntry(entryIdFake); |
|
479 QTest::qWait(waitTime1sec); |
|
480 |
|
481 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
482 QCOMPARE(clientNotifier->mEntryId, 0); |
|
483 QCOMPARE(removed, FALSE); |
|
484 |
|
485 // cleanup |
|
486 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
487 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
488 disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
489 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
490 QTest::qWait(waitTime500ms); |
|
491 delete clientNotifier; |
|
492 mService->removeEntry(entry->id()); |
|
493 } |
|
494 #ifdef Q_OS_SYMBIAN |
|
495 #ifdef UT_MEMORY_CHECK |
|
496 // __UHEAP_MARKEND; |
|
497 #endif//UT_MEMORY_CHECK |
|
498 #endif//Q_OS_SYMBIAN |
|
499 } |
|
500 // --------------------------------------------------------------------------- |
|
501 // |
|
502 void TestCaClient::TestRemoveEntriesChangeTypeNotifier() |
|
503 { |
|
504 #ifdef Q_OS_SYMBIAN |
|
505 #ifdef UT_MEMORY_CHECK |
|
506 // __UHEAP_MARK; |
|
507 #endif//UT_MEMORY_CHECK |
|
508 #endif//Q_OS_SYMBIAN |
|
509 { |
|
510 |
|
511 |
|
512 CaEntry item1; |
|
513 item1.setText("Text"); |
|
514 item1.setEntryTypeName("TypeName"); |
|
515 QSharedPointer<CaEntry> entry1 = mService->createEntry(item1); |
|
516 QTest::qWait(waitTime1sec); |
|
517 CaEntry item2; |
|
518 item2.setText("Text"); |
|
519 item2.setEntryTypeName("TypeName"); |
|
520 QSharedPointer<CaEntry> entry2 = mService->createEntry(item2); |
|
521 QTest::qWait(waitTime1sec); |
|
522 CaEntry item3; |
|
523 item3.setText("Text"); |
|
524 item3.setEntryTypeName("TypeName"); |
|
525 QSharedPointer<CaEntry> entry3 = mService->createEntry(item3); |
|
526 QTest::qWait(waitTime1sec); |
|
527 CaEntry item4; |
|
528 item4.setText("Text"); |
|
529 item4.setEntryTypeName("TypeName"); |
|
530 QSharedPointer<CaEntry> entry4 = mService->createEntry(item4); |
|
531 QTest::qWait(waitTime1sec); |
|
532 |
|
533 QList< QSharedPointer<CaEntry> > entriesList; |
|
534 entriesList.append(entry1); |
|
535 entriesList.append(entry2); |
|
536 entriesList.append(entry3); |
|
537 entriesList.append(entry4); |
|
538 |
|
539 CaNotifierFilter *filter = new CaNotifierFilter(); |
|
540 filter->setEntryRole(ItemEntryRole); |
|
541 filter->setTypeNames(QStringList() << "TypeName"); |
|
542 filter->setIds(QList<int>() << entry2->id() << entry3->id()); |
|
543 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter); |
|
544 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
545 |
|
546 connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
547 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
548 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
549 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
550 QTest::qWait(waitTime500ms); |
|
551 |
|
552 clientNotifier->mEntryId = 0; |
|
553 |
|
554 bool removed = mService->removeEntries(entriesList); |
|
555 QTest::qWait(waitTime1sec); |
|
556 |
|
557 QCOMPARE(clientNotifier->mChangeType, RemoveChangeType); |
|
558 QVERIFY(clientNotifier->mEntryId > 0); |
|
559 QCOMPARE(clientNotifier->mEntryId, entry3->id()); |
|
560 QCOMPARE(removed, TRUE); |
|
561 |
|
562 // cleanup |
|
563 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
564 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
565 disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
566 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
567 QTest::qWait(waitTime500ms); |
|
568 delete clientNotifier; |
|
569 delete filter; |
|
570 mService->removeEntries(entriesList); |
|
571 QTest::qWait(waitTime500ms); |
|
572 entriesList.clear(); |
|
573 } |
|
574 #ifdef Q_OS_SYMBIAN |
|
575 #ifdef UT_MEMORY_CHECK |
|
576 // __UHEAP_MARKEND; |
|
577 #endif//UT_MEMORY_CHECK |
|
578 #endif//Q_OS_SYMBIAN |
|
579 } |
|
580 // --------------------------------------------------------------------------- |
|
581 // |
|
582 void TestCaClient::TestRemoveEntriesIdsChangeTypeNotifier() |
|
583 { |
|
584 #ifdef Q_OS_SYMBIAN |
|
585 #ifdef UT_MEMORY_CHECK |
|
586 // __UHEAP_MARK; |
|
587 #endif//UT_MEMORY_CHECK |
|
588 #endif//Q_OS_SYMBIAN |
|
589 { |
|
590 |
|
591 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
592 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
593 |
|
594 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
595 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
596 connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
597 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
598 QTest::qWait(waitTime500ms); |
|
599 CaEntry item1; |
|
600 item1.setText("Text"); |
|
601 item1.setEntryTypeName("TypeName"); |
|
602 QSharedPointer<CaEntry> entry1 = mService->createEntry(item1); |
|
603 QTest::qWait(waitTime1sec); |
|
604 CaEntry item2; |
|
605 item2.setText("Text"); |
|
606 item2.setEntryTypeName("TypeName"); |
|
607 QSharedPointer<CaEntry> entry2 = mService->createEntry(item2); |
|
608 QTest::qWait(waitTime1sec); |
|
609 CaEntry item3; |
|
610 item3.setText("Text"); |
|
611 item3.setEntryTypeName("TypeName"); |
|
612 QSharedPointer<CaEntry> entry3 = mService->createEntry(item3); |
|
613 QTest::qWait(waitTime1sec); |
|
614 CaEntry item4; |
|
615 item4.setText("Text"); |
|
616 item4.setEntryTypeName("TypeName"); |
|
617 QSharedPointer<CaEntry> entry4 = mService->createEntry(item4); |
|
618 QTest::qWait(waitTime1sec); |
|
619 |
|
620 QList<int> entriesIdsList; |
|
621 entriesIdsList.append(entry1->id()); |
|
622 entriesIdsList.append(entry2->id()); |
|
623 entriesIdsList.append(entry3->id()); |
|
624 entriesIdsList.append(entry4->id()); |
|
625 |
|
626 clientNotifier->mEntryId = 0; |
|
627 |
|
628 bool removed = mService->removeEntries(entriesIdsList); |
|
629 QTest::qWait(waitTime1sec); |
|
630 |
|
631 QCOMPARE(clientNotifier->mChangeType, RemoveChangeType); |
|
632 QVERIFY(clientNotifier->mEntryId > 0); |
|
633 QCOMPARE(clientNotifier->mEntryId, entry4->id()); |
|
634 QCOMPARE(removed, TRUE); |
|
635 |
|
636 // cleanup |
|
637 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
638 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
639 disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
640 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
641 QTest::qWait(waitTime500ms); |
|
642 delete clientNotifier; |
|
643 mService->removeEntries(entriesIdsList); |
|
644 QTest::qWait(waitTime500ms); |
|
645 entriesIdsList.clear(); |
|
646 } |
|
647 #ifdef Q_OS_SYMBIAN |
|
648 #ifdef UT_MEMORY_CHECK |
|
649 // __UHEAP_MARKEND; |
|
650 #endif//UT_MEMORY_CHECK |
|
651 #endif//Q_OS_SYMBIAN |
|
652 } |
|
653 // --------------------------------------------------------------------------- |
|
654 // |
|
655 void TestCaClient::TestRemoveEntriesChangeTypeNotifierFake() |
|
656 { |
|
657 #ifdef Q_OS_SYMBIAN |
|
658 #ifdef UT_MEMORY_CHECK |
|
659 // __UHEAP_MARK; |
|
660 #endif//UT_MEMORY_CHECK |
|
661 #endif//Q_OS_SYMBIAN |
|
662 { |
|
663 |
|
664 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
665 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
666 |
|
667 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
668 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
669 connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
670 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
671 QTest::qWait(waitTime500ms); |
|
672 CaEntry item1; |
|
673 item1.setText("Text"); |
|
674 item1.setEntryTypeName("TypeName"); |
|
675 QSharedPointer<CaEntry> entry1 = mService->createEntry(item1); |
|
676 QTest::qWait(waitTime1sec); |
|
677 CaEntry item2; |
|
678 item2.setText("Text"); |
|
679 item2.setEntryTypeName("TypeName"); |
|
680 QSharedPointer<CaEntry> entry2 = mService->createEntry(item2); |
|
681 QTest::qWait(waitTime1sec); |
|
682 CaEntry item3; |
|
683 item3.setText("Text"); |
|
684 item3.setEntryTypeName("TypeName"); |
|
685 QSharedPointer<CaEntry> entry3 = mService->createEntry(item3); |
|
686 QTest::qWait(waitTime1sec); |
|
687 CaEntry item4; |
|
688 item4.setText("Text"); |
|
689 item4.setEntryTypeName("TypeName"); |
|
690 QSharedPointer<CaEntry> entry4 = mService->createEntry(item4); |
|
691 QTest::qWait(waitTime1sec); |
|
692 |
|
693 QList<QSharedPointer<CaEntry> > entriesList; |
|
694 entriesList.append(entry1); |
|
695 entriesList.append(entry2); |
|
696 entriesList.append(entry3); |
|
697 entriesList.append(entry4); |
|
698 |
|
699 clientNotifier->mEntryId = 0; |
|
700 |
|
701 CaEntry itemFake1; |
|
702 itemFake1.setText("Text"); |
|
703 itemFake1.setEntryTypeName("TypeName"); |
|
704 QSharedPointer<CaEntry> entryFake1 = mService->createEntry(itemFake1); |
|
705 int entryFake1Id = entryFake1->id(); |
|
706 entryFake1->setId(entryIdFake); |
|
707 QTest::qWait(waitTime1sec); |
|
708 CaEntry itemFake2; |
|
709 itemFake2.setText("Text"); |
|
710 itemFake2.setEntryTypeName("TypeName"); |
|
711 QSharedPointer<CaEntry> entryFake2 = mService->createEntry(itemFake2); |
|
712 int entryFake2Id = entryFake2->id(); |
|
713 entryFake2->setId(entryIdFake); |
|
714 QTest::qWait(waitTime1sec); |
|
715 QList<QSharedPointer<CaEntry> > entriesListFake; |
|
716 entriesListFake.append(entryFake1); |
|
717 entriesListFake.append(entryFake2); |
|
718 |
|
719 clientNotifier->mEntryId = 0; |
|
720 clientNotifier->mChangeType = AddChangeType; |
|
721 |
|
722 bool removed = mService->removeEntries(entriesListFake); |
|
723 QTest::qWait(waitTime1sec); |
|
724 |
|
725 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
726 QCOMPARE(clientNotifier->mEntryId, 0); |
|
727 QCOMPARE(removed, FALSE); |
|
728 |
|
729 entryFake1->setId(entryFake1Id); |
|
730 entryFake2->setId(entryFake2Id); |
|
731 |
|
732 // cleanup |
|
733 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
734 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
735 disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
736 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
737 QTest::qWait(waitTime500ms); |
|
738 delete clientNotifier; |
|
739 mService->removeEntries(entriesList); |
|
740 mService->removeEntries(entriesListFake); |
|
741 QTest::qWait(waitTime500ms); |
|
742 entriesList.clear(); |
|
743 entriesListFake.clear(); |
|
744 } |
|
745 #ifdef Q_OS_SYMBIAN |
|
746 #ifdef UT_MEMORY_CHECK |
|
747 // __UHEAP_MARKEND; |
|
748 #endif//UT_MEMORY_CHECK |
|
749 #endif//Q_OS_SYMBIAN |
|
750 } |
|
751 // --------------------------------------------------------------------------- |
|
752 // |
|
753 void TestCaClient::TestRemoveEntriesIdsChangeTypeNotifierFake() |
|
754 { |
|
755 #ifdef Q_OS_SYMBIAN |
|
756 #ifdef UT_MEMORY_CHECK |
|
757 // __UHEAP_MARK; |
|
758 #endif//UT_MEMORY_CHECK |
|
759 #endif//Q_OS_SYMBIAN |
|
760 |
|
761 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
762 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
763 |
|
764 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
765 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
766 connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
767 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
768 QTest::qWait(waitTime500ms); |
|
769 CaEntry item1; |
|
770 item1.setText("Text"); |
|
771 item1.setEntryTypeName("TypeName"); |
|
772 QSharedPointer<CaEntry> entry1 = mService->createEntry(item1); |
|
773 QTest::qWait(waitTime1sec); |
|
774 CaEntry item2; |
|
775 item2.setText("Text"); |
|
776 item2.setEntryTypeName("TypeName"); |
|
777 QSharedPointer<CaEntry> entry2 = mService->createEntry(item2); |
|
778 QTest::qWait(waitTime1sec); |
|
779 CaEntry item3; |
|
780 item3.setText("Text"); |
|
781 item3.setEntryTypeName("TypeName"); |
|
782 QSharedPointer<CaEntry> entry3 = mService->createEntry(item3); |
|
783 QTest::qWait(waitTime1sec); |
|
784 CaEntry item4; |
|
785 item4.setText("Text"); |
|
786 item4.setEntryTypeName("TypeName"); |
|
787 QSharedPointer<CaEntry> entry4 = mService->createEntry(item4); |
|
788 QTest::qWait(waitTime1sec); |
|
789 |
|
790 QList<int> entriesIdsList; |
|
791 entriesIdsList.append(entry1->id()); |
|
792 entriesIdsList.append(entry2->id()); |
|
793 entriesIdsList.append(entry3->id()); |
|
794 entriesIdsList.append(entry4->id()); |
|
795 |
|
796 CaEntry itemFake1; |
|
797 itemFake1.setText("Text"); |
|
798 itemFake1.setEntryTypeName("TypeName"); |
|
799 QSharedPointer<CaEntry> entryFake1 = mService->createEntry(itemFake1); |
|
800 int entryFake1Id = entryFake1->id(); |
|
801 entryFake1->setId(entryIdFake); |
|
802 QTest::qWait(waitTime1sec); |
|
803 CaEntry itemFake2; |
|
804 itemFake2.setText("Text"); |
|
805 itemFake2.setEntryTypeName("TypeName"); |
|
806 QSharedPointer<CaEntry> entryFake2 = mService->createEntry(itemFake2); |
|
807 int entryFake2Id = entryFake2->id(); |
|
808 entryFake2->setId(entryIdFake); |
|
809 QTest::qWait(waitTime1sec); |
|
810 QList<int> entriesIdsListFake; |
|
811 entriesIdsListFake.append(entryFake1->id()); |
|
812 entriesIdsListFake.append(entryFake2->id()); |
|
813 |
|
814 clientNotifier->mEntryId = 0; |
|
815 clientNotifier->mChangeType = AddChangeType; |
|
816 |
|
817 bool removed = mService->removeEntries(entriesIdsListFake); |
|
818 QTest::qWait(waitTime1sec); |
|
819 |
|
820 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
821 QCOMPARE(clientNotifier->mEntryId, 0); |
|
822 QCOMPARE(removed, FALSE); |
|
823 |
|
824 entryFake1->setId(entryFake1Id); |
|
825 entryFake2->setId(entryFake2Id); |
|
826 |
|
827 // cleanup |
|
828 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
829 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
830 disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
831 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
832 QTest::qWait(waitTime500ms); |
|
833 delete clientNotifier; |
|
834 mService->removeEntries(entriesIdsList); |
|
835 mService->removeEntry(*entryFake1); |
|
836 mService->removeEntry(*entryFake2); |
|
837 QTest::qWait(waitTime1sec); |
|
838 entriesIdsList.clear(); |
|
839 entriesIdsListFake.clear(); |
|
840 |
|
841 #ifdef Q_OS_SYMBIAN |
|
842 #ifdef UT_MEMORY_CHECK |
|
843 // __UHEAP_MARKEND; |
|
844 #endif//UT_MEMORY_CHECK |
|
845 #endif//Q_OS_SYMBIAN |
|
846 } |
|
847 // --------------------------------------------------------------------------- |
|
848 // |
|
849 void TestCaClient::TestRemoveGroupChangeTypeNotifier() |
|
850 { |
|
851 #ifdef Q_OS_SYMBIAN |
|
852 #ifdef UT_MEMORY_CHECK |
|
853 // __UHEAP_MARK; |
|
854 #endif//UT_MEMORY_CHECK |
|
855 #endif//Q_OS_SYMBIAN |
|
856 |
|
857 |
|
858 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
859 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
860 |
|
861 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
862 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
863 connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
864 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
865 QTest::qWait(waitTime500ms); |
|
866 CaEntry group(GroupEntryRole); |
|
867 group.setText("Text"); |
|
868 group.setEntryTypeName("TypeName"); |
|
869 QSharedPointer<CaEntry> entry = mService->createEntry(group); |
|
870 QTest::qWait(waitTime1sec); |
|
871 |
|
872 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
873 QVERIFY(clientNotifier->mEntryId > 0); |
|
874 QCOMPARE(clientNotifier->mEntryId, entry->id()); |
|
875 |
|
876 int entryId = clientNotifier->mEntryId; |
|
877 clientNotifier->mEntryId = 0; |
|
878 |
|
879 bool removed = mService->removeEntry(*entry); |
|
880 QTest::qWait(waitTime1sec); |
|
881 |
|
882 QCOMPARE(clientNotifier->mChangeType, RemoveChangeType); |
|
883 QVERIFY(clientNotifier->mEntryId > 0); |
|
884 QCOMPARE(clientNotifier->mEntryId, entryId); |
|
885 QCOMPARE(removed, TRUE); |
|
886 |
|
887 // cleanup |
|
888 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
889 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
890 disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
891 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
892 QTest::qWait(waitTime500ms); |
|
893 delete clientNotifier; |
|
894 mService->removeEntry(entry->id()); |
|
895 QTest::qWait(waitTime1sec); |
|
896 |
|
897 #ifdef Q_OS_SYMBIAN |
|
898 #ifdef UT_MEMORY_CHECK |
|
899 // __UHEAP_MARKEND; |
|
900 #endif//UT_MEMORY_CHECK |
|
901 #endif//Q_OS_SYMBIAN |
|
902 } |
|
903 // --------------------------------------------------------------------------- |
|
904 // |
|
905 void TestCaClient::TestRemoveGroupsChangeTypeNotifier() |
|
906 { |
|
907 #ifdef Q_OS_SYMBIAN |
|
908 #ifdef UT_MEMORY_CHECK |
|
909 // __UHEAP_MARK; |
|
910 #endif//UT_MEMORY_CHECK |
|
911 #endif//Q_OS_SYMBIAN |
|
912 |
|
913 |
|
914 |
|
915 CaEntry group1(GroupEntryRole); |
|
916 group1.setText("Text"); |
|
917 group1.setEntryTypeName("TypeName1"); |
|
918 QSharedPointer<CaEntry> entry1 = mService->createEntry(group1); |
|
919 QTest::qWait(waitTime1sec); |
|
920 CaEntry group2(GroupEntryRole); |
|
921 group2.setText("Text"); |
|
922 group2.setEntryTypeName("TypeName2"); |
|
923 QSharedPointer<CaEntry> entry2 = mService->createEntry(group2); |
|
924 QTest::qWait(waitTime1sec); |
|
925 CaEntry group3(GroupEntryRole); |
|
926 group3.setText("Text"); |
|
927 group3.setEntryTypeName("TypeName3"); |
|
928 QSharedPointer<CaEntry> entry3 = mService->createEntry(group3); |
|
929 QTest::qWait(waitTime1sec); |
|
930 CaEntry group4(GroupEntryRole); |
|
931 group4.setText("Text"); |
|
932 group4.setEntryTypeName("TypeName4"); |
|
933 QSharedPointer<CaEntry> entry4 = mService->createEntry(group4); |
|
934 QTest::qWait(waitTime1sec); |
|
935 |
|
936 QList< QSharedPointer<CaEntry> > entriesList; |
|
937 entriesList.append(entry1); |
|
938 entriesList.append(entry2); |
|
939 entriesList.append(entry3); |
|
940 entriesList.append(entry4); |
|
941 |
|
942 CaNotifierFilter *filter = new CaNotifierFilter(); |
|
943 filter->setEntryRole(GroupEntryRole); |
|
944 filter->setTypeNames(QStringList() << "TypeName3" << "TypeName4"); |
|
945 filter->setIds(QList<int>() << entry3->id()); |
|
946 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter); |
|
947 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
948 |
|
949 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
950 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
951 connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
952 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
953 QTest::qWait(waitTime500ms); |
|
954 |
|
955 clientNotifier->mEntryId = 0; |
|
956 |
|
957 bool removed = mService->removeEntries(entriesList); |
|
958 QTest::qWait(waitTime1sec); |
|
959 |
|
960 QCOMPARE(clientNotifier->mChangeType, RemoveChangeType); |
|
961 QVERIFY(clientNotifier->mEntryId > 0); |
|
962 QCOMPARE(clientNotifier->mEntryId, entry3->id()); |
|
963 QCOMPARE(removed, TRUE); |
|
964 |
|
965 // cleanup |
|
966 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
967 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
968 disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
969 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
970 QTest::qWait(waitTime500ms); |
|
971 delete clientNotifier; |
|
972 delete filter; |
|
973 mService->removeEntries(entriesList); |
|
974 QTest::qWait(waitTime1sec); |
|
975 entriesList.clear(); |
|
976 |
|
977 #ifdef Q_OS_SYMBIAN |
|
978 #ifdef UT_MEMORY_CHECK |
|
979 // __UHEAP_MARK; |
|
980 #endif//UT_MEMORY_CHECK |
|
981 #endif//Q_OS_SYMBIAN |
|
982 } |
|
983 // --------------------------------------------------------------------------- |
|
984 // --------------------------------------------------------------------------- |
|
985 // |
|
986 void TestCaClient::TestUpdateChangeTypeNotifier() |
|
987 { |
|
988 #ifdef Q_OS_SYMBIAN |
|
989 #ifdef UT_MEMORY_CHECK |
|
990 // __UHEAP_MARK; |
|
991 #endif//UT_MEMORY_CHECK |
|
992 #endif//Q_OS_SYMBIAN |
|
993 |
|
994 |
|
995 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
996 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
997 |
|
998 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
999 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
1000 connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
1001 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
1002 QTest::qWait(waitTime500ms); |
|
1003 |
|
1004 CaEntry item; |
|
1005 item.setText("Text"); |
|
1006 item.setEntryTypeName("TypeName"); |
|
1007 item.setDescription("description"); |
|
1008 |
|
1009 QSharedPointer<CaEntry> entry = mService->createEntry(item); |
|
1010 |
|
1011 QTest::qWait(waitTime1sec); |
|
1012 |
|
1013 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
1014 QVERIFY(clientNotifier->mEntryId > 0); |
|
1015 QCOMPARE(clientNotifier->mEntryId, entry->id()); |
|
1016 |
|
1017 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
1018 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
1019 disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
1020 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
1021 QTest::qWait(waitTime500ms); |
|
1022 int entryId = clientNotifier->mEntryId; |
|
1023 delete clientNotifier; |
|
1024 |
|
1025 CaNotifierFilter *filter = new CaNotifierFilter(); |
|
1026 filter->setEntryRole(ItemEntryRole); |
|
1027 filter->setIds(QList<int>() << entry->id()); |
|
1028 TestCaClientNotifier *clientNotifierUpdate = new TestCaClientNotifier(*mService, filter); |
|
1029 CaNotifier *notifierUpdate = clientNotifierUpdate->getNotifier(); |
|
1030 |
|
1031 connect(notifierUpdate, SIGNAL(entryChanged(int,ChangeType)), |
|
1032 clientNotifierUpdate, SLOT(entryChanged(int,ChangeType))); |
|
1033 connect(notifierUpdate, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
1034 clientNotifierUpdate, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
1035 QTest::qWait(waitTime500ms); |
|
1036 |
|
1037 bool updated = mService->updateEntry(*entry); |
|
1038 QTest::qWait(waitTime1sec); |
|
1039 |
|
1040 QCOMPARE(clientNotifierUpdate->mChangeType, UpdateChangeType); |
|
1041 QVERIFY(clientNotifierUpdate->mEntryId > 0); |
|
1042 QCOMPARE(clientNotifierUpdate->mEntryId, entryId); |
|
1043 QCOMPARE(clientNotifierUpdate->mEntryId, entry->id()); |
|
1044 QCOMPARE(clientNotifierUpdate->mEntry->description(), QString("description")); |
|
1045 QCOMPARE(updated, TRUE); |
|
1046 |
|
1047 // cleanup |
|
1048 disconnect(notifierUpdate, SIGNAL(entryChanged(int,ChangeType)), |
|
1049 clientNotifierUpdate, SLOT(entryChanged(int,ChangeType))); |
|
1050 disconnect(notifierUpdate, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
1051 clientNotifierUpdate, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
1052 QTest::qWait(waitTime500ms); |
|
1053 |
|
1054 delete clientNotifierUpdate; |
|
1055 delete filter; |
|
1056 mService->removeEntry(entry->id()); |
|
1057 QTest::qWait(waitTime1sec); |
|
1058 |
|
1059 #ifdef Q_OS_SYMBIAN |
|
1060 #ifdef UT_MEMORY_CHECK |
|
1061 // __UHEAP_MARK; |
|
1062 #endif//UT_MEMORY_CHECK |
|
1063 #endif//Q_OS_SYMBIAN |
|
1064 } |
|
1065 // --------------------------------------------------------------------------- |
|
1066 // |
|
1067 void TestCaClient::TestUpdateChangeTypeNotifierFake() |
|
1068 { |
|
1069 #ifdef Q_OS_SYMBIAN |
|
1070 #ifdef UT_MEMORY_CHECK |
|
1071 // __UHEAP_MARK; |
|
1072 #endif//UT_MEMORY_CHECK |
|
1073 #endif//Q_OS_SYMBIAN |
|
1074 |
|
1075 |
|
1076 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
1077 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
1078 |
|
1079 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
1080 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
1081 connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
1082 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
1083 |
|
1084 QTest::qWait(waitTime500ms); |
|
1085 CaEntry item; |
|
1086 item.setText("Text"); |
|
1087 item.setEntryTypeName("TypeName"); |
|
1088 QSharedPointer<CaEntry> entry = mService->createEntry(item); |
|
1089 QTest::qWait(waitTime1sec); |
|
1090 |
|
1091 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
1092 QVERIFY(clientNotifier->mEntryId > 0); |
|
1093 QCOMPARE(clientNotifier->mEntryId, entry->id()); |
|
1094 |
|
1095 |
|
1096 int entryId = clientNotifier->mEntryId; |
|
1097 clientNotifier->mEntryId = 0; |
|
1098 CaEntry itemFake; |
|
1099 itemFake.setText("Text"); |
|
1100 itemFake.setEntryTypeName("TypeName"); |
|
1101 |
|
1102 bool updated = mService->updateEntry(itemFake); |
|
1103 QTest::qWait(waitTime1sec); |
|
1104 |
|
1105 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
1106 QCOMPARE(clientNotifier->mEntryId, 0); |
|
1107 QCOMPARE(updated, FALSE); |
|
1108 |
|
1109 // cleanup |
|
1110 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
1111 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
1112 disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
1113 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
1114 QTest::qWait(waitTime500ms); |
|
1115 delete clientNotifier; |
|
1116 mService->removeEntry(entry->id()); |
|
1117 QTest::qWait(waitTime1sec); |
|
1118 |
|
1119 #ifdef Q_OS_SYMBIAN |
|
1120 #ifdef UT_MEMORY_CHECK |
|
1121 // __UHEAP_MARKEND; |
|
1122 #endif//UT_MEMORY_CHECK |
|
1123 #endif//Q_OS_SYMBIAN |
|
1124 } |
|
1125 // --------------------------------------------------------------------------- |
|
1126 // |
|
1127 void TestCaClient::TestAddUpdateRemove() |
|
1128 { |
|
1129 #ifdef Q_OS_SYMBIAN |
|
1130 #ifdef UT_MEMORY_CHECK |
|
1131 // __UHEAP_MARK; |
|
1132 #endif//UT_MEMORY_CHECK |
|
1133 #endif//Q_OS_SYMBIAN |
|
1134 |
|
1135 |
|
1136 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
1137 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
1138 |
|
1139 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
1140 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
1141 connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
1142 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
1143 QTest::qWait(waitTime500ms); |
|
1144 |
|
1145 CaEntry item; |
|
1146 item.setText("Text"); |
|
1147 item.setEntryTypeName("TypeName"); |
|
1148 QSharedPointer<CaEntry> entry = mService->createEntry(item); |
|
1149 QTest::qWait(waitTime1sec); |
|
1150 |
|
1151 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
1152 QVERIFY(clientNotifier->mEntryId > 0); |
|
1153 QCOMPARE(clientNotifier->mEntryId, entry->id()); |
|
1154 |
|
1155 |
|
1156 int entryId = clientNotifier->mEntryId; |
|
1157 clientNotifier->mEntryId = 0; |
|
1158 |
|
1159 bool updated = mService->updateEntry(*entry); |
|
1160 QTest::qWait(waitTime1sec); |
|
1161 |
|
1162 QCOMPARE(clientNotifier->mChangeType, UpdateChangeType); |
|
1163 QVERIFY(clientNotifier->mEntryId > 0); |
|
1164 QCOMPARE(clientNotifier->mEntryId, entry->id()); |
|
1165 QCOMPARE(updated, TRUE); |
|
1166 |
|
1167 entryId = clientNotifier->mEntryId; |
|
1168 clientNotifier->mEntryId = 0; |
|
1169 |
|
1170 bool removed = mService->removeEntry(entryId); |
|
1171 QTest::qWait(waitTime1sec); |
|
1172 |
|
1173 QCOMPARE(clientNotifier->mChangeType, RemoveChangeType); |
|
1174 QVERIFY(clientNotifier->mEntryId > 0); |
|
1175 QCOMPARE(removed, TRUE); |
|
1176 |
|
1177 // cleanup |
|
1178 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
1179 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
1180 disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
1181 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
1182 QTest::qWait(waitTime500ms); |
|
1183 delete clientNotifier; |
|
1184 mService->removeEntry(entry->id()); |
|
1185 QTest::qWait(waitTime1sec); |
|
1186 |
|
1187 #ifdef Q_OS_SYMBIAN |
|
1188 #ifdef UT_MEMORY_CHECK |
|
1189 // __UHEAP_MARKEND; |
|
1190 #endif//UT_MEMORY_CHECK |
|
1191 #endif//Q_OS_SYMBIAN |
|
1192 } |
|
1193 // --------------------------------------------------------------------------- |
|
1194 // |
|
1195 void TestCaClient::TestRegisterNotifier() |
|
1196 { |
|
1197 #ifdef Q_OS_SYMBIAN |
|
1198 #ifdef UT_MEMORY_CHECK |
|
1199 // __UHEAP_MARK; |
|
1200 #endif//UT_MEMORY_CHECK |
|
1201 #endif//Q_OS_SYMBIAN |
|
1202 |
|
1203 |
|
1204 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
1205 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
1206 |
|
1207 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
1208 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
1209 connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
1210 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
1211 connect(notifier, SIGNAL(entryTouched(int)), |
|
1212 clientNotifier, SLOT(entryTouched(int))); |
|
1213 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
1214 clientNotifier, SLOT(groupContentChanged(int))); |
|
1215 QTest::qWait(waitTime1sec); |
|
1216 QCOMPARE(notifier->receivers(SIGNAL(entryChanged(int,ChangeType))), 1); |
|
1217 QCOMPARE(notifier->receivers(SIGNAL(entryChanged(CaEntry,ChangeType))), 1); |
|
1218 QCOMPARE(notifier->receivers(SIGNAL(entryTouched(int))), 1); |
|
1219 QCOMPARE(notifier->receivers(SIGNAL(groupContentChanged(int))), 1); |
|
1220 |
|
1221 // cleanup |
|
1222 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
1223 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
1224 disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
1225 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
1226 disconnect(notifier, SIGNAL(entryTouched(int)), |
|
1227 clientNotifier, SLOT(entryTouched(int))); |
|
1228 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
1229 clientNotifier, SLOT(groupContentChanged(int))); |
|
1230 QTest::qWait(waitTime1sec); |
|
1231 |
|
1232 QCOMPARE(notifier->receivers(SIGNAL(entryChanged(int,ChangeType))), 0); |
|
1233 QCOMPARE(notifier->receivers(SIGNAL(entryChanged(CaEntry,ChangeType))), 0); |
|
1234 QCOMPARE(notifier->receivers(SIGNAL(entryTouched(int))), 0); |
|
1235 QCOMPARE(notifier->receivers(SIGNAL(groupContentChanged(int))), 0); |
|
1236 |
|
1237 delete clientNotifier; |
|
1238 |
|
1239 #ifdef Q_OS_SYMBIAN |
|
1240 #ifdef UT_MEMORY_CHECK |
|
1241 // __UHEAP_MARKEND; |
|
1242 #endif//UT_MEMORY_CHECK |
|
1243 #endif//Q_OS_SYMBIAN |
|
1244 } |
|
1245 // --------------------------------------------------------------------------- |
|
1246 // |
|
1247 void TestCaClient::TestUnregisterNotifier() |
|
1248 { |
|
1249 #ifdef Q_OS_SYMBIAN |
|
1250 #ifdef UT_MEMORY_CHECK |
|
1251 // __UHEAP_MARK; |
|
1252 #endif//UT_MEMORY_CHECK |
|
1253 #endif//Q_OS_SYMBIAN |
|
1254 |
|
1255 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
1256 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
1257 |
|
1258 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
1259 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
1260 connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
1261 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
1262 connect(notifier, SIGNAL(entryTouched(int)), |
|
1263 clientNotifier, SLOT(entryTouched(int))); |
|
1264 QTest::qWait(waitTime500ms); |
|
1265 disconnect(notifier, SIGNAL(entryTouched(int)), |
|
1266 clientNotifier, SLOT(entryTouched(int))); |
|
1267 connect(notifier, SIGNAL(entryTouched(int)), |
|
1268 clientNotifier, SLOT(entryTouched(int))); |
|
1269 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
1270 clientNotifier, SLOT(groupContentChanged(int))); |
|
1271 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
1272 clientNotifier, SLOT(groupContentChanged(int))); |
|
1273 QTest::qWait(waitTime500ms); |
|
1274 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
1275 clientNotifier, SLOT(groupContentChanged(int))); |
|
1276 QTest::qWait(waitTime500ms); |
|
1277 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
1278 clientNotifier, SLOT(groupContentChanged(int))); |
|
1279 QTest::qWait(waitTime500ms); |
|
1280 |
|
1281 QCOMPARE(notifier->receivers(SIGNAL(entryChanged(int,ChangeType))), 1); |
|
1282 QCOMPARE(notifier->receivers(SIGNAL(entryChanged(CaEntry,ChangeType))), 1); |
|
1283 QCOMPARE(notifier->receivers(SIGNAL(entryTouched(int))), 1); |
|
1284 QCOMPARE(notifier->receivers(SIGNAL(groupContentChanged(int))), 1); |
|
1285 |
|
1286 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
1287 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
1288 disconnect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
1289 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
1290 disconnect(notifier, SIGNAL(entryTouched(int)), |
|
1291 clientNotifier, SLOT(entryTouched(int))); |
|
1292 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
1293 clientNotifier, SLOT(groupContentChanged(int))); |
|
1294 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
1295 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
1296 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
1297 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
1298 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
1299 clientNotifier, SLOT(groupContentChanged(int))); |
|
1300 QTest::qWait(waitTime1sec); |
|
1301 |
|
1302 QCOMPARE(notifier->receivers(SIGNAL(entryChanged(int,ChangeType))), 0); |
|
1303 QCOMPARE(notifier->receivers(SIGNAL(entryChanged(CaEntry,ChangeType))), 0); |
|
1304 QCOMPARE(notifier->receivers(SIGNAL(entryTouched(int))), 0); |
|
1305 QCOMPARE(notifier->receivers(SIGNAL(groupContentChanged(int))), 0); |
|
1306 |
|
1307 delete clientNotifier; |
|
1308 QTest::qWait(waitTime500ms); |
|
1309 |
|
1310 #ifdef Q_OS_SYMBIAN |
|
1311 #ifdef UT_MEMORY_CHECK |
|
1312 // __UHEAP_MARKEND; |
|
1313 #endif//UT_MEMORY_CHECK |
|
1314 #endif//Q_OS_SYMBIAN |
|
1315 } |
|
1316 // --------------------------------------------------------------------------- |
|
1317 // |
|
1318 void TestCaClient::TestTouchEntryNotifier() |
|
1319 { |
|
1320 #ifdef Q_OS_SYMBIAN |
|
1321 #ifdef UT_MEMORY_CHECK |
|
1322 // __UHEAP_MARK; |
|
1323 #endif//UT_MEMORY_CHECK |
|
1324 #endif//Q_OS_SYMBIAN |
|
1325 |
|
1326 CaEntry item; |
|
1327 item.setText("Text"); |
|
1328 item.setEntryTypeName("TypeName"); |
|
1329 QSharedPointer<CaEntry> entry = mService->createEntry(item); |
|
1330 QTest::qWait(waitTime1sec); |
|
1331 |
|
1332 CaNotifierFilter *filter = new CaNotifierFilter(); |
|
1333 filter->setEntryRole(ItemEntryRole); |
|
1334 filter->setIds(QList<int>() << entry->id()); |
|
1335 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter); |
|
1336 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
1337 |
|
1338 connect(notifier, SIGNAL(entryTouched(int)), |
|
1339 clientNotifier, SLOT(entryTouched(int))); |
|
1340 QTest::qWait(waitTime500ms); |
|
1341 |
|
1342 bool touched = mService->touch(*entry); |
|
1343 QTest::qWait(waitTime1sec); |
|
1344 |
|
1345 QVERIFY(clientNotifier->mEntryId > 0); |
|
1346 QCOMPARE(clientNotifier->mEntryId, entry->id()); |
|
1347 QCOMPARE(touched, TRUE); |
|
1348 |
|
1349 // cleanup |
|
1350 disconnect(notifier, SIGNAL(entryTouched(int)), |
|
1351 clientNotifier, SLOT(entryTouched(int))); |
|
1352 QTest::qWait(waitTime500ms); |
|
1353 delete clientNotifier; |
|
1354 delete filter; |
|
1355 mService->removeEntry(entry->id()); |
|
1356 QTest::qWait(waitTime1sec); |
|
1357 |
|
1358 #ifdef Q_OS_SYMBIAN |
|
1359 #ifdef UT_MEMORY_CHECK |
|
1360 // __UHEAP_MARKEND; |
|
1361 #endif//UT_MEMORY_CHECK |
|
1362 #endif//Q_OS_SYMBIAN |
|
1363 } |
|
1364 // --------------------------------------------------------------------------- |
|
1365 // |
|
1366 void TestCaClient::TestTouchEntryIdNotifier() |
|
1367 { |
|
1368 #ifdef Q_OS_SYMBIAN |
|
1369 #ifdef UT_MEMORY_CHECK |
|
1370 // __UHEAP_MARK; |
|
1371 #endif//UT_MEMORY_CHECK |
|
1372 #endif//Q_OS_SYMBIAN |
|
1373 |
|
1374 |
|
1375 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
1376 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
1377 |
|
1378 connect(notifier, SIGNAL(entryTouched(int)), |
|
1379 clientNotifier, SLOT(entryTouched(int))); |
|
1380 QTest::qWait(waitTime500ms); |
|
1381 CaEntry item; |
|
1382 item.setText("Text"); |
|
1383 item.setEntryTypeName("TypeName"); |
|
1384 QSharedPointer<CaEntry> entry = mService->createEntry(item); |
|
1385 QTest::qWait(waitTime1sec); |
|
1386 QCOMPARE(clientNotifier->mEntryId, 0); |
|
1387 |
|
1388 bool touched = mService->touch(*entry); |
|
1389 QTest::qWait(waitTime1sec); |
|
1390 |
|
1391 QVERIFY(clientNotifier->mEntryId > 0); |
|
1392 QCOMPARE(clientNotifier->mEntryId, entry->id()); |
|
1393 QCOMPARE(touched, TRUE); |
|
1394 |
|
1395 // cleanup |
|
1396 disconnect(notifier, SIGNAL(entryTouched(int)), |
|
1397 clientNotifier, SLOT(entryTouched(int))); |
|
1398 QTest::qWait(waitTime500ms); |
|
1399 delete clientNotifier; |
|
1400 mService->removeEntry(entry->id()); |
|
1401 QTest::qWait(waitTime1sec); |
|
1402 |
|
1403 #ifdef Q_OS_SYMBIAN |
|
1404 #ifdef UT_MEMORY_CHECK |
|
1405 // __UHEAP_MARKEND; |
|
1406 #endif//UT_MEMORY_CHECK |
|
1407 #endif//Q_OS_SYMBIAN |
|
1408 } |
|
1409 // --------------------------------------------------------------------------- |
|
1410 // |
|
1411 void TestCaClient::TestTouchEntryNotifierFake() |
|
1412 { |
|
1413 #ifdef Q_OS_SYMBIAN |
|
1414 #ifdef UT_MEMORY_CHECK |
|
1415 // __UHEAP_MARK; |
|
1416 #endif//UT_MEMORY_CHECK |
|
1417 #endif//Q_OS_SYMBIAN |
|
1418 |
|
1419 |
|
1420 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
1421 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
1422 |
|
1423 connect(notifier, SIGNAL(entryTouched(int)), |
|
1424 clientNotifier, SLOT(entryTouched(int))); |
|
1425 QTest::qWait(waitTime500ms); |
|
1426 CaEntry item; |
|
1427 item.setText("Text"); |
|
1428 item.setEntryTypeName("TypeName"); |
|
1429 QSharedPointer<CaEntry> entry = mService->createEntry(item); |
|
1430 QTest::qWait(waitTime1sec); |
|
1431 |
|
1432 QCOMPARE(clientNotifier->mEntryId, 0); |
|
1433 |
|
1434 CaEntry *entryFake = new CaEntry(); |
|
1435 entryFake->setText("Text"); |
|
1436 entryFake->setEntryTypeName("TypeName"); |
|
1437 |
|
1438 bool touched = mService->touch(*entryFake); |
|
1439 QTest::qWait(waitTime1sec); |
|
1440 |
|
1441 QCOMPARE(clientNotifier->mEntryId, 0); |
|
1442 QCOMPARE(touched, FALSE); |
|
1443 |
|
1444 // cleanup |
|
1445 disconnect(notifier, SIGNAL(entryTouched(int)), |
|
1446 clientNotifier, SLOT(entryTouched(int))); |
|
1447 QTest::qWait(waitTime500ms); |
|
1448 delete clientNotifier; |
|
1449 mService->removeEntry(entry->id()); |
|
1450 QTest::qWait(waitTime1sec); |
|
1451 delete entryFake; |
|
1452 |
|
1453 #ifdef Q_OS_SYMBIAN |
|
1454 #ifdef UT_MEMORY_CHECK |
|
1455 // __UHEAP_MARKEND; |
|
1456 #endif//UT_MEMORY_CHECK |
|
1457 #endif//Q_OS_SYMBIAN |
|
1458 } |
|
1459 |
|
1460 |
|
1461 void TestCaClient::TestTouchEntryUidNotifier() |
|
1462 { |
|
1463 #ifdef Q_OS_SYMBIAN |
|
1464 #ifdef UT_MEMORY_CHECK |
|
1465 // __UHEAP_MARK; |
|
1466 #endif//UT_MEMORY_CHECK |
|
1467 #endif//Q_OS_SYMBIAN |
|
1468 |
|
1469 |
|
1470 QScopedPointer<TestCaClientNotifier> clientNotifier( |
|
1471 new TestCaClientNotifier(*mService)); |
|
1472 |
|
1473 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
1474 |
|
1475 connect(notifier, SIGNAL(entryTouched(int)), |
|
1476 clientNotifier.data(), SLOT(entryTouched(int))); |
|
1477 |
|
1478 CaEntry item; |
|
1479 item.setText("Text"); |
|
1480 item.setEntryTypeName("application"); |
|
1481 item.setAttribute( |
|
1482 "application:uid", |
|
1483 "-3"); |
|
1484 |
|
1485 QSharedPointer<CaEntry> entry = mService->createEntry(item); |
|
1486 |
|
1487 QTest::qWait(waitTime1sec); |
|
1488 |
|
1489 QVERIFY(!entry.isNull()); |
|
1490 |
|
1491 const int expectedEntryId = entry->id(); |
|
1492 |
|
1493 entry->setId(0); |
|
1494 |
|
1495 QCOMPARE(clientNotifier->mEntryId, 0); |
|
1496 |
|
1497 bool touched = mService->touch(*entry); |
|
1498 |
|
1499 QTest::qWait(waitTime1sec); |
|
1500 |
|
1501 QCOMPARE(clientNotifier->mEntryId, expectedEntryId); |
|
1502 QCOMPARE(touched, true); |
|
1503 |
|
1504 // cleanup |
|
1505 disconnect(notifier, SIGNAL(entryTouched(int)), |
|
1506 clientNotifier.data(), SLOT(entryTouched(int))); |
|
1507 |
|
1508 QTest::qWait(waitTime500ms); |
|
1509 |
|
1510 mService->removeEntry(expectedEntryId); |
|
1511 QTest::qWait(waitTime1sec); |
|
1512 |
|
1513 #ifdef Q_OS_SYMBIAN |
|
1514 #ifdef UT_MEMORY_CHECK |
|
1515 // __UHEAP_MARKEND; |
|
1516 #endif//UT_MEMORY_CHECK |
|
1517 #endif//Q_OS_SYMBIAN |
|
1518 } |
|
1519 |
|
1520 |
|
1521 // --------------------------------------------------------------------------- |
|
1522 // |
|
1523 void TestCaClient::TestTouchEntryIdNotifierFake() |
|
1524 { |
|
1525 #ifdef Q_OS_SYMBIAN |
|
1526 #ifdef UT_MEMORY_CHECK |
|
1527 // __UHEAP_MARK; |
|
1528 #endif//UT_MEMORY_CHECK |
|
1529 #endif//Q_OS_SYMBIAN |
|
1530 |
|
1531 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
1532 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
1533 |
|
1534 connect(notifier, SIGNAL(entryTouched(int)), |
|
1535 clientNotifier, SLOT(entryTouched(int))); |
|
1536 QTest::qWait(waitTime500ms); |
|
1537 CaEntry item; |
|
1538 item.setText("Text"); |
|
1539 item.setEntryTypeName("TypeName"); |
|
1540 QSharedPointer<CaEntry> entry = mService->createEntry(item); |
|
1541 QTest::qWait(waitTime1sec); |
|
1542 |
|
1543 QCOMPARE(clientNotifier->mEntryId, 0); |
|
1544 |
|
1545 QScopedPointer<CaEntry> entryFake(new CaEntry()); |
|
1546 entryFake->setText("Text"); |
|
1547 entryFake->setEntryTypeName("TypeName"); |
|
1548 entryFake->setId(entryIdFake); |
|
1549 |
|
1550 bool touched = mService->touch(*entryFake); |
|
1551 QTest::qWait(waitTime1sec); |
|
1552 |
|
1553 QCOMPARE(clientNotifier->mEntryId, 0); |
|
1554 QCOMPARE(touched, FALSE); |
|
1555 |
|
1556 // cleanup |
|
1557 disconnect(notifier, SIGNAL(entryTouched(int)), |
|
1558 clientNotifier, SLOT(entryTouched(int))); |
|
1559 QTest::qWait(waitTime500ms); |
|
1560 delete clientNotifier; |
|
1561 mService->removeEntry(entry->id()); |
|
1562 QTest::qWait(waitTime1sec); |
|
1563 |
|
1564 #ifdef Q_OS_SYMBIAN |
|
1565 #ifdef UT_MEMORY_CHECK |
|
1566 // __UHEAP_MARKEND; |
|
1567 #endif//UT_MEMORY_CHECK |
|
1568 #endif//Q_OS_SYMBIAN |
|
1569 } |
|
1570 // --------------------------------------------------------------------------- |
|
1571 // |
|
1572 void TestCaClient::TestTouchGroupNotifier() |
|
1573 { |
|
1574 #ifdef Q_OS_SYMBIAN |
|
1575 #ifdef UT_MEMORY_CHECK |
|
1576 // __UHEAP_MARK; |
|
1577 #endif//UT_MEMORY_CHECK |
|
1578 #endif//Q_OS_SYMBIAN |
|
1579 |
|
1580 |
|
1581 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
1582 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
1583 |
|
1584 connect(notifier, SIGNAL(entryTouched(int)), |
|
1585 clientNotifier, SLOT(entryTouched(int))); |
|
1586 QTest::qWait(waitTime500ms); |
|
1587 CaEntry group(GroupEntryRole); |
|
1588 group.setText("Text"); |
|
1589 group.setEntryTypeName("TypeName"); |
|
1590 QSharedPointer<CaEntry> entry = mService->createEntry(group); |
|
1591 QTest::qWait(waitTime1sec); |
|
1592 |
|
1593 QCOMPARE(clientNotifier->mEntryId, 0); |
|
1594 |
|
1595 bool touched = mService->touch(*entry); |
|
1596 QTest::qWait(waitTime1sec); |
|
1597 |
|
1598 QVERIFY(clientNotifier->mEntryId > 0); |
|
1599 QCOMPARE(clientNotifier->mEntryId, entry->id()); |
|
1600 QCOMPARE(touched, TRUE); |
|
1601 |
|
1602 // cleanup |
|
1603 disconnect(notifier, SIGNAL(entryTouched(int)), |
|
1604 clientNotifier, SLOT(entryTouched(int))); |
|
1605 QTest::qWait(waitTime500ms); |
|
1606 delete clientNotifier; |
|
1607 mService->removeEntry(entry->id()); |
|
1608 QTest::qWait(waitTime1sec); |
|
1609 |
|
1610 #ifdef Q_OS_SYMBIAN |
|
1611 #ifdef UT_MEMORY_CHECK |
|
1612 // __UHEAP_MARKEND; |
|
1613 #endif//UT_MEMORY_CHECK |
|
1614 #endif//Q_OS_SYMBIAN |
|
1615 } |
|
1616 // --------------------------------------------------------------------------- |
|
1617 // |
|
1618 void TestCaClient::TestAppendEntryGroupNotifier() |
|
1619 { |
|
1620 #ifdef Q_OS_SYMBIAN |
|
1621 #ifdef UT_MEMORY_CHECK |
|
1622 // __UHEAP_MARK; |
|
1623 #endif//UT_MEMORY_CHECK |
|
1624 #endif//Q_OS_SYMBIAN |
|
1625 |
|
1626 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
1627 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
1628 |
|
1629 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
1630 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
1631 QTest::qWait(waitTime500ms); |
|
1632 CaEntry group(GroupEntryRole); |
|
1633 group.setText("Text"); |
|
1634 group.setEntryTypeName("TypeName"); |
|
1635 QSharedPointer<CaEntry> entryG = mService->createEntry(group); |
|
1636 QTest::qWait(waitTime1sec); |
|
1637 |
|
1638 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
1639 QVERIFY(clientNotifier->mEntryId > 0); |
|
1640 QCOMPARE(clientNotifier->mEntryId, entryG->id()); |
|
1641 |
|
1642 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
1643 clientNotifier, SLOT(groupContentChanged(int))); |
|
1644 QTest::qWait(waitTime500ms); |
|
1645 CaEntry item; |
|
1646 item.setText("Text"); |
|
1647 item.setEntryTypeName("TypeName"); |
|
1648 QSharedPointer<CaEntry> entryI = mService->createEntry(item); |
|
1649 QTest::qWait(waitTime1sec); |
|
1650 int groupId = entryG->id(); |
|
1651 |
|
1652 clientNotifier->mChangeType = RemoveChangeType; |
|
1653 clientNotifier->mEntryId = 0; |
|
1654 clientNotifier->mGroupId = 0; |
|
1655 |
|
1656 bool appended = mService->appendEntryToGroup((CaEntry &)(*entryG), *entryI); |
|
1657 QTest::qWait(waitTime1sec); |
|
1658 |
|
1659 QVERIFY(clientNotifier->mGroupId > 0); |
|
1660 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
1661 QCOMPARE(clientNotifier->mGroupId, entryG->id()); |
|
1662 QCOMPARE(appended, TRUE); |
|
1663 |
|
1664 // cleanup |
|
1665 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
1666 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
1667 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
1668 clientNotifier, SLOT(groupContentChanged(int))); |
|
1669 QTest::qWait(waitTime500ms); |
|
1670 delete clientNotifier; |
|
1671 mService->removeEntry(entryI->id()); |
|
1672 QTest::qWait(waitTime1sec); |
|
1673 mService->removeEntry(entryG->id()); |
|
1674 QTest::qWait(waitTime1sec); |
|
1675 |
|
1676 #ifdef Q_OS_SYMBIAN |
|
1677 #ifdef UT_MEMORY_CHECK |
|
1678 // __UHEAP_MARKEND; |
|
1679 #endif//UT_MEMORY_CHECK |
|
1680 #endif//Q_OS_SYMBIAN |
|
1681 } |
|
1682 // --------------------------------------------------------------------------- |
|
1683 // |
|
1684 void TestCaClient::TestAppendEntryGroupIdNotifier() |
|
1685 { |
|
1686 #ifdef Q_OS_SYMBIAN |
|
1687 #ifdef UT_MEMORY_CHECK |
|
1688 // __UHEAP_MARK; |
|
1689 #endif//UT_MEMORY_CHECK |
|
1690 #endif//Q_OS_SYMBIAN |
|
1691 |
|
1692 |
|
1693 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
1694 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
1695 |
|
1696 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
1697 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
1698 QTest::qWait(waitTime500ms); |
|
1699 CaEntry group(GroupEntryRole); |
|
1700 group.setText("Text"); |
|
1701 group.setEntryTypeName("TypeName"); |
|
1702 QSharedPointer<CaEntry> entryG = mService->createEntry(group); |
|
1703 QTest::qWait(waitTime1sec); |
|
1704 |
|
1705 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
1706 QVERIFY(clientNotifier->mEntryId > 0); |
|
1707 QCOMPARE(clientNotifier->mEntryId, entryG->id()); |
|
1708 |
|
1709 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
1710 clientNotifier, SLOT(groupContentChanged(int))); |
|
1711 QTest::qWait(waitTime500ms); |
|
1712 CaEntry item; |
|
1713 item.setText("Text"); |
|
1714 item.setEntryTypeName("TypeName"); |
|
1715 QSharedPointer<CaEntry> entryI = mService->createEntry(item); |
|
1716 QTest::qWait(waitTime1sec); |
|
1717 int groupId = entryG->id(); |
|
1718 |
|
1719 clientNotifier->mChangeType = RemoveChangeType; |
|
1720 clientNotifier->mEntryId = 0; |
|
1721 clientNotifier->mGroupId = 0; |
|
1722 |
|
1723 bool appended = mService->appendEntryToGroup(((CaEntry &)*entryG).id(), (*entryI).id()); |
|
1724 QTest::qWait(waitTime1sec); |
|
1725 |
|
1726 QVERIFY(clientNotifier->mGroupId > 0); |
|
1727 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
1728 QCOMPARE(clientNotifier->mGroupId, entryG->id()); |
|
1729 QCOMPARE(appended, TRUE); |
|
1730 |
|
1731 // cleanup |
|
1732 disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
1733 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
1734 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
1735 clientNotifier, SLOT(groupContentChanged(int))); |
|
1736 QTest::qWait(waitTime500ms); |
|
1737 delete clientNotifier; |
|
1738 mService->removeEntry(entryI->id()); |
|
1739 QTest::qWait(waitTime1sec); |
|
1740 mService->removeEntry(entryG->id()); |
|
1741 QTest::qWait(waitTime1sec); |
|
1742 |
|
1743 #ifdef Q_OS_SYMBIAN |
|
1744 #ifdef UT_MEMORY_CHECK |
|
1745 // __UHEAP_MARKEND; |
|
1746 #endif//UT_MEMORY_CHECK |
|
1747 #endif//Q_OS_SYMBIAN |
|
1748 } |
|
1749 // --------------------------------------------------------------------------- |
|
1750 // |
|
1751 void TestCaClient::TestAppendEntriesGroupNotifier() |
|
1752 { |
|
1753 #ifdef Q_OS_SYMBIAN |
|
1754 #ifdef UT_MEMORY_CHECK |
|
1755 // __UHEAP_MARK; |
|
1756 #endif//UT_MEMORY_CHECK |
|
1757 #endif//Q_OS_SYMBIAN |
|
1758 |
|
1759 |
|
1760 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
1761 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
1762 |
|
1763 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
1764 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
1765 QTest::qWait(waitTime500ms); |
|
1766 CaEntry group(GroupEntryRole); |
|
1767 group.setText("Text"); |
|
1768 group.setEntryTypeName("TypeName"); |
|
1769 QSharedPointer<CaEntry> entryGroup = mService->createEntry(group); |
|
1770 QTest::qWait(waitTime1sec); |
|
1771 int groupId = entryGroup->id(); |
|
1772 |
|
1773 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
1774 QVERIFY(clientNotifier->mEntryId > 0); |
|
1775 QCOMPARE(clientNotifier->mEntryId, entryGroup->id()); |
|
1776 |
|
1777 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
1778 clientNotifier, SLOT(groupContentChanged(int))); |
|
1779 QTest::qWait(waitTime500ms); |
|
1780 CaEntry item1; |
|
1781 item1.setText("Text"); |
|
1782 item1.setEntryTypeName("TypeName"); |
|
1783 QSharedPointer<CaEntry> entry1 = mService->createEntry(item1); |
|
1784 QTest::qWait(waitTime1sec); |
|
1785 CaEntry item2; |
|
1786 item2.setText("Text"); |
|
1787 item2.setEntryTypeName("TypeName"); |
|
1788 QSharedPointer<CaEntry> entry2 = mService->createEntry(item2); |
|
1789 QTest::qWait(waitTime1sec); |
|
1790 |
|
1791 QList< QSharedPointer<CaEntry> > entriesList; |
|
1792 entriesList.append(entry1); |
|
1793 entriesList.append(entry2); |
|
1794 |
|
1795 clientNotifier->mChangeType = RemoveChangeType; |
|
1796 clientNotifier->mEntryId = 0; |
|
1797 clientNotifier->mGroupId = 0; |
|
1798 |
|
1799 bool appended = mService->appendEntriesToGroup((CaEntry &)*entryGroup, entriesList); |
|
1800 QTest::qWait(waitTime1sec); |
|
1801 |
|
1802 QVERIFY(clientNotifier->mGroupId > 0); |
|
1803 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
1804 QCOMPARE(clientNotifier->mGroupId, entryGroup->id()); |
|
1805 QCOMPARE(appended, TRUE); |
|
1806 |
|
1807 // cleanup |
|
1808 disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
1809 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
1810 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
1811 clientNotifier, SLOT(groupContentChanged(int))); |
|
1812 QTest::qWait(waitTime500ms); |
|
1813 delete clientNotifier; |
|
1814 mService->removeEntries(entriesList); |
|
1815 QTest::qWait(waitTime1sec); |
|
1816 mService->removeEntry(entryGroup->id()); |
|
1817 QTest::qWait(waitTime1sec); |
|
1818 entriesList.clear(); |
|
1819 |
|
1820 #ifdef Q_OS_SYMBIAN |
|
1821 #ifdef UT_MEMORY_CHECK |
|
1822 // __UHEAP_MARKEND; |
|
1823 #endif//UT_MEMORY_CHECK |
|
1824 #endif//Q_OS_SYMBIAN |
|
1825 } |
|
1826 // --------------------------------------------------------------------------- |
|
1827 // |
|
1828 void TestCaClient::TestAppendEntriesGroupIdNotifier() |
|
1829 { |
|
1830 #ifdef Q_OS_SYMBIAN |
|
1831 #ifdef UT_MEMORY_CHECK |
|
1832 // __UHEAP_MARK; |
|
1833 #endif//UT_MEMORY_CHECK |
|
1834 #endif//Q_OS_SYMBIAN |
|
1835 |
|
1836 |
|
1837 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
1838 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
1839 |
|
1840 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
1841 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
1842 QTest::qWait(waitTime500ms); |
|
1843 CaEntry group(GroupEntryRole); |
|
1844 group.setText("Text"); |
|
1845 group.setEntryTypeName("TypeName"); |
|
1846 QSharedPointer<CaEntry> entryGroup = mService->createEntry(group); |
|
1847 QTest::qWait(waitTime1sec); |
|
1848 int groupId = entryGroup->id(); |
|
1849 |
|
1850 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
1851 QVERIFY(clientNotifier->mEntryId > 0); |
|
1852 QCOMPARE(clientNotifier->mEntryId, entryGroup->id()); |
|
1853 |
|
1854 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
1855 clientNotifier, SLOT(groupContentChanged(int))); |
|
1856 QTest::qWait(waitTime500ms); |
|
1857 CaEntry item1; |
|
1858 item1.setText("Text"); |
|
1859 item1.setEntryTypeName("TypeName"); |
|
1860 QSharedPointer<CaEntry> entryItem1 = mService->createEntry(item1); |
|
1861 QTest::qWait(waitTime1sec); |
|
1862 CaEntry item2; |
|
1863 item2.setText("Text"); |
|
1864 item2.setEntryTypeName("TypeName"); |
|
1865 QSharedPointer<CaEntry> entryItem2 = mService->createEntry(item2); |
|
1866 QTest::qWait(waitTime1sec); |
|
1867 |
|
1868 QList<int> entriesIdsList; |
|
1869 entriesIdsList.append(entryItem1->id()); |
|
1870 entriesIdsList.append(entryItem2->id()); |
|
1871 |
|
1872 clientNotifier->mChangeType = RemoveChangeType; |
|
1873 clientNotifier->mEntryId = 0; |
|
1874 clientNotifier->mGroupId = 0; |
|
1875 |
|
1876 bool appended = mService->appendEntriesToGroup(((CaEntry &)*entryGroup).id(), entriesIdsList); |
|
1877 QTest::qWait(waitTime1sec); |
|
1878 |
|
1879 QVERIFY(clientNotifier->mGroupId > 0); |
|
1880 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
1881 QCOMPARE(clientNotifier->mGroupId, entryGroup->id()); |
|
1882 QCOMPARE(appended, TRUE); |
|
1883 |
|
1884 // cleanup |
|
1885 disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
1886 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
1887 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
1888 clientNotifier, SLOT(groupContentChanged(int))); |
|
1889 QTest::qWait(waitTime500ms); |
|
1890 delete clientNotifier; |
|
1891 mService->removeEntries(entriesIdsList); |
|
1892 QTest::qWait(waitTime1sec); |
|
1893 mService->removeEntry(entryGroup->id()); |
|
1894 QTest::qWait(waitTime1sec); |
|
1895 entriesIdsList.clear(); |
|
1896 |
|
1897 #ifdef Q_OS_SYMBIAN |
|
1898 #ifdef UT_MEMORY_CHECK |
|
1899 // __UHEAP_MARKEND; |
|
1900 #endif//UT_MEMORY_CHECK |
|
1901 #endif//Q_OS_SYMBIAN |
|
1902 } |
|
1903 // --------------------------------------------------------------------------- |
|
1904 // |
|
1905 void TestCaClient::TestPrependEntryGroupNotifier() |
|
1906 { |
|
1907 #ifdef Q_OS_SYMBIAN |
|
1908 #ifdef UT_MEMORY_CHECK |
|
1909 // __UHEAP_MARK; |
|
1910 #endif//UT_MEMORY_CHECK |
|
1911 #endif//Q_OS_SYMBIAN |
|
1912 |
|
1913 |
|
1914 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
1915 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
1916 |
|
1917 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
1918 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
1919 QTest::qWait(waitTime500ms); |
|
1920 CaEntry group(GroupEntryRole); |
|
1921 group.setText("Text"); |
|
1922 group.setEntryTypeName("TypeName"); |
|
1923 QSharedPointer<CaEntry> entryG = mService->createEntry(group); |
|
1924 QTest::qWait(waitTime1sec); |
|
1925 |
|
1926 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
1927 QVERIFY(clientNotifier->mEntryId > 0); |
|
1928 QCOMPARE(clientNotifier->mEntryId, entryG->id()); |
|
1929 |
|
1930 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
1931 clientNotifier, SLOT(groupContentChanged(int))); |
|
1932 QTest::qWait(waitTime500ms); |
|
1933 CaEntry item; |
|
1934 item.setText("Text"); |
|
1935 item.setEntryTypeName("TypeName"); |
|
1936 QSharedPointer<CaEntry> entryI = mService->createEntry(item); |
|
1937 QTest::qWait(waitTime1sec); |
|
1938 int groupId = entryG->id(); |
|
1939 |
|
1940 clientNotifier->mChangeType = RemoveChangeType; |
|
1941 clientNotifier->mEntryId = 0; |
|
1942 clientNotifier->mGroupId = 0; |
|
1943 |
|
1944 bool appended = mService->prependEntryToGroup((CaEntry &)(*entryG), *entryI); |
|
1945 QTest::qWait(waitTime1sec); |
|
1946 |
|
1947 QVERIFY(clientNotifier->mGroupId > 0); |
|
1948 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
1949 QCOMPARE(clientNotifier->mGroupId, entryG->id()); |
|
1950 QCOMPARE(appended, TRUE); |
|
1951 |
|
1952 // cleanup |
|
1953 disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
1954 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
1955 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
1956 clientNotifier, SLOT(groupContentChanged(int))); |
|
1957 QTest::qWait(waitTime500ms); |
|
1958 delete clientNotifier; |
|
1959 mService->removeEntry(entryI->id()); |
|
1960 QTest::qWait(waitTime1sec); |
|
1961 mService->removeEntry(entryG->id()); |
|
1962 QTest::qWait(waitTime1sec); |
|
1963 |
|
1964 #ifdef Q_OS_SYMBIAN |
|
1965 #ifdef UT_MEMORY_CHECK |
|
1966 // __UHEAP_MARKEND; |
|
1967 #endif//UT_MEMORY_CHECK |
|
1968 #endif//Q_OS_SYMBIAN |
|
1969 } |
|
1970 // --------------------------------------------------------------------------- |
|
1971 // |
|
1972 void TestCaClient::TestPrependEntryGroupIdNotifier() |
|
1973 { |
|
1974 #ifdef Q_OS_SYMBIAN |
|
1975 #ifdef UT_MEMORY_CHECK |
|
1976 // __UHEAP_MARK; |
|
1977 #endif//UT_MEMORY_CHECK |
|
1978 #endif//Q_OS_SYMBIAN |
|
1979 |
|
1980 |
|
1981 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
1982 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
1983 |
|
1984 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
1985 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
1986 QTest::qWait(waitTime500ms); |
|
1987 CaEntry group(GroupEntryRole); |
|
1988 group.setText("Text"); |
|
1989 group.setEntryTypeName("TypeName"); |
|
1990 QSharedPointer<CaEntry> entryG = mService->createEntry(group); |
|
1991 QTest::qWait(waitTime1sec); |
|
1992 |
|
1993 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
1994 QVERIFY(clientNotifier->mEntryId > 0); |
|
1995 QCOMPARE(clientNotifier->mEntryId, entryG->id()); |
|
1996 |
|
1997 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
1998 clientNotifier, SLOT(groupContentChanged(int))); |
|
1999 QTest::qWait(waitTime500ms); |
|
2000 CaEntry item; |
|
2001 item.setText("Text"); |
|
2002 item.setEntryTypeName("TypeName"); |
|
2003 QSharedPointer<CaEntry> entryI = mService->createEntry(item); |
|
2004 QTest::qWait(waitTime1sec); |
|
2005 int groupId = entryG->id(); |
|
2006 |
|
2007 clientNotifier->mChangeType = RemoveChangeType; |
|
2008 clientNotifier->mEntryId = 0; |
|
2009 clientNotifier->mGroupId = 0; |
|
2010 |
|
2011 bool appended = mService->prependEntryToGroup(((CaEntry &)*entryG).id(), (*entryI).id()); |
|
2012 QTest::qWait(waitTime1sec); |
|
2013 |
|
2014 QVERIFY(clientNotifier->mGroupId > 0); |
|
2015 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
2016 QCOMPARE(clientNotifier->mGroupId, entryG->id()); |
|
2017 QCOMPARE(appended, TRUE); |
|
2018 |
|
2019 // cleanup |
|
2020 disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2021 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2022 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
2023 clientNotifier, SLOT(groupContentChanged(int))); |
|
2024 QTest::qWait(waitTime500ms); |
|
2025 delete clientNotifier; |
|
2026 mService->removeEntry(entryI->id()); |
|
2027 QTest::qWait(waitTime1sec); |
|
2028 mService->removeEntry(entryG->id()); |
|
2029 QTest::qWait(waitTime1sec); |
|
2030 |
|
2031 #ifdef Q_OS_SYMBIAN |
|
2032 #ifdef UT_MEMORY_CHECK |
|
2033 // __UHEAP_MARKEND; |
|
2034 #endif//UT_MEMORY_CHECK |
|
2035 #endif//Q_OS_SYMBIAN |
|
2036 } |
|
2037 // --------------------------------------------------------------------------- |
|
2038 // |
|
2039 void TestCaClient::TestPrependEntriesGroupNotifier() |
|
2040 { |
|
2041 #ifdef Q_OS_SYMBIAN |
|
2042 #ifdef UT_MEMORY_CHECK |
|
2043 // __UHEAP_MARK; |
|
2044 #endif//UT_MEMORY_CHECK |
|
2045 #endif//Q_OS_SYMBIAN |
|
2046 |
|
2047 |
|
2048 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
2049 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
2050 |
|
2051 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2052 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2053 QTest::qWait(waitTime500ms); |
|
2054 CaEntry group(GroupEntryRole); |
|
2055 group.setText("Text"); |
|
2056 group.setEntryTypeName("TypeName"); |
|
2057 QSharedPointer<CaEntry> entryGroup = mService->createEntry(group); |
|
2058 QTest::qWait(waitTime1sec); |
|
2059 int groupId = entryGroup->id(); |
|
2060 |
|
2061 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
2062 QVERIFY(clientNotifier->mEntryId > 0); |
|
2063 QCOMPARE(clientNotifier->mEntryId, entryGroup->id()); |
|
2064 |
|
2065 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
2066 clientNotifier, SLOT(groupContentChanged(int))); |
|
2067 QTest::qWait(waitTime500ms); |
|
2068 CaEntry item1; |
|
2069 item1.setText("Text"); |
|
2070 item1.setEntryTypeName("TypeName"); |
|
2071 QSharedPointer<CaEntry> entry1 = mService->createEntry(item1); |
|
2072 QTest::qWait(waitTime1sec); |
|
2073 CaEntry item2; |
|
2074 item2.setText("Text"); |
|
2075 item2.setEntryTypeName("TypeName"); |
|
2076 QSharedPointer<CaEntry> entry2 = mService->createEntry(item2); |
|
2077 QTest::qWait(waitTime1sec); |
|
2078 |
|
2079 QList< QSharedPointer<CaEntry> > entriesList; |
|
2080 entriesList.append(entry1); |
|
2081 entriesList.append(entry2); |
|
2082 |
|
2083 clientNotifier->mChangeType = RemoveChangeType; |
|
2084 clientNotifier->mEntryId = 0; |
|
2085 clientNotifier->mGroupId = 0; |
|
2086 |
|
2087 bool appended = mService->prependEntriesToGroup((CaEntry &)*entryGroup, entriesList); |
|
2088 QTest::qWait(waitTime1sec); |
|
2089 |
|
2090 QVERIFY(clientNotifier->mGroupId > 0); |
|
2091 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
2092 QCOMPARE(clientNotifier->mGroupId, entryGroup->id()); |
|
2093 QCOMPARE(appended, TRUE); |
|
2094 |
|
2095 // cleanup |
|
2096 disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2097 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2098 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
2099 clientNotifier, SLOT(groupContentChanged(int))); |
|
2100 QTest::qWait(waitTime500ms); |
|
2101 delete clientNotifier; |
|
2102 mService->removeEntries(entriesList); |
|
2103 QTest::qWait(waitTime1sec); |
|
2104 mService->removeEntry(entryGroup->id()); |
|
2105 QTest::qWait(waitTime1sec); |
|
2106 entriesList.clear(); |
|
2107 |
|
2108 #ifdef Q_OS_SYMBIAN |
|
2109 #ifdef UT_MEMORY_CHECK |
|
2110 // __UHEAP_MARKEND; |
|
2111 #endif//UT_MEMORY_CHECK |
|
2112 #endif//Q_OS_SYMBIAN |
|
2113 } |
|
2114 // --------------------------------------------------------------------------- |
|
2115 // |
|
2116 void TestCaClient::TestPrependEntriesGroupIdNotifier() |
|
2117 { |
|
2118 #ifdef Q_OS_SYMBIAN |
|
2119 #ifdef UT_MEMORY_CHECK |
|
2120 // __UHEAP_MARK; |
|
2121 #endif//UT_MEMORY_CHECK |
|
2122 #endif//Q_OS_SYMBIAN |
|
2123 |
|
2124 |
|
2125 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
2126 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
2127 |
|
2128 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2129 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2130 QTest::qWait(waitTime500ms); |
|
2131 CaEntry group(GroupEntryRole); |
|
2132 group.setText("Text"); |
|
2133 group.setEntryTypeName("TypeName"); |
|
2134 QSharedPointer<CaEntry> entryGroup = mService->createEntry(group); |
|
2135 QTest::qWait(waitTime1sec); |
|
2136 int groupId = entryGroup->id(); |
|
2137 |
|
2138 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
2139 QVERIFY(clientNotifier->mEntryId > 0); |
|
2140 QCOMPARE(clientNotifier->mEntryId, entryGroup->id()); |
|
2141 |
|
2142 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
2143 clientNotifier, SLOT(groupContentChanged(int))); |
|
2144 QTest::qWait(waitTime500ms); |
|
2145 CaEntry item1; |
|
2146 item1.setText("Text"); |
|
2147 item1.setEntryTypeName("TypeName"); |
|
2148 QSharedPointer<CaEntry> entryItem1 = mService->createEntry(item1); |
|
2149 QTest::qWait(waitTime1sec); |
|
2150 CaEntry item2; |
|
2151 item2.setText("Text"); |
|
2152 item2.setEntryTypeName("TypeName"); |
|
2153 QSharedPointer<CaEntry> entryItem2 = mService->createEntry(item2); |
|
2154 QTest::qWait(waitTime1sec); |
|
2155 |
|
2156 QList<int> entriesIdsList; |
|
2157 entriesIdsList.append(entryItem1->id()); |
|
2158 entriesIdsList.append(entryItem2->id()); |
|
2159 |
|
2160 clientNotifier->mChangeType = RemoveChangeType; |
|
2161 clientNotifier->mEntryId = 0; |
|
2162 clientNotifier->mGroupId = 0; |
|
2163 |
|
2164 bool appended = mService->prependEntriesToGroup(((CaEntry &)*entryGroup).id(), entriesIdsList); |
|
2165 QTest::qWait(waitTime1sec); |
|
2166 |
|
2167 QVERIFY(clientNotifier->mGroupId > 0); |
|
2168 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
2169 QCOMPARE(clientNotifier->mGroupId, entryGroup->id()); |
|
2170 QCOMPARE(appended, TRUE); |
|
2171 |
|
2172 // cleanup |
|
2173 disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2174 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2175 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
2176 clientNotifier, SLOT(groupContentChanged(int))); |
|
2177 QTest::qWait(waitTime500ms); |
|
2178 delete clientNotifier; |
|
2179 mService->removeEntries(entriesIdsList); |
|
2180 QTest::qWait(waitTime1sec); |
|
2181 mService->removeEntry(entryGroup->id()); |
|
2182 QTest::qWait(waitTime1sec); |
|
2183 entriesIdsList.clear(); |
|
2184 |
|
2185 #ifdef Q_OS_SYMBIAN |
|
2186 #ifdef UT_MEMORY_CHECK |
|
2187 // __UHEAP_MARKEND; |
|
2188 #endif//UT_MEMORY_CHECK |
|
2189 #endif//Q_OS_SYMBIAN |
|
2190 } |
|
2191 // --------------------------------------------------------------------------- |
|
2192 // |
|
2193 void TestCaClient::TestRemoveEntryGroupNotifier() |
|
2194 { |
|
2195 #ifdef Q_OS_SYMBIAN |
|
2196 #ifdef UT_MEMORY_CHECK |
|
2197 // __UHEAP_MARK; |
|
2198 #endif//UT_MEMORY_CHECK |
|
2199 #endif//Q_OS_SYMBIAN |
|
2200 |
|
2201 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
2202 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
2203 |
|
2204 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2205 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2206 QTest::qWait(waitTime500ms); |
|
2207 CaEntry group(GroupEntryRole); |
|
2208 group.setText("Text"); |
|
2209 group.setEntryTypeName("TypeName"); |
|
2210 QSharedPointer<CaEntry> entryGroup = mService->createEntry(group); |
|
2211 QTest::qWait(waitTime1sec); |
|
2212 int groupId = entryGroup->id(); |
|
2213 |
|
2214 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
2215 QVERIFY(clientNotifier->mEntryId > 0); |
|
2216 QCOMPARE(clientNotifier->mEntryId, entryGroup->id()); |
|
2217 |
|
2218 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
2219 clientNotifier, SLOT(groupContentChanged(int))); |
|
2220 QTest::qWait(waitTime500ms); |
|
2221 CaEntry item1; |
|
2222 item1.setText("Text"); |
|
2223 item1.setEntryTypeName("TypeName"); |
|
2224 QSharedPointer<CaEntry> entry1 = mService->createEntry(item1); |
|
2225 QTest::qWait(waitTime1sec); |
|
2226 CaEntry item2; |
|
2227 item2.setText("Text"); |
|
2228 item2.setEntryTypeName("TypeName"); |
|
2229 QSharedPointer<CaEntry> entry2 = mService->createEntry(item2); |
|
2230 QTest::qWait(waitTime1sec); |
|
2231 |
|
2232 QList< QSharedPointer<CaEntry> > entriesList; |
|
2233 entriesList.append(entry1); |
|
2234 entriesList.append(entry2); |
|
2235 |
|
2236 bool appended = mService->appendEntriesToGroup((CaEntry &)*entryGroup, entriesList); |
|
2237 QTest::qWait(waitTime1sec); |
|
2238 QCOMPARE(appended, TRUE); |
|
2239 |
|
2240 clientNotifier->mChangeType = AddChangeType; |
|
2241 clientNotifier->mEntryId = 0; |
|
2242 clientNotifier->mGroupId = 0; |
|
2243 bool removed = mService->removeEntryFromGroup((CaEntry &)*entryGroup, *entry1); |
|
2244 QTest::qWait(waitTime1sec); |
|
2245 |
|
2246 QVERIFY(clientNotifier->mGroupId > 0); |
|
2247 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
2248 QCOMPARE(clientNotifier->mGroupId, entryGroup->id()); |
|
2249 QCOMPARE(removed, TRUE); |
|
2250 |
|
2251 clientNotifier->mChangeType = AddChangeType; |
|
2252 clientNotifier->mEntryId = 0; |
|
2253 clientNotifier->mGroupId = 0; |
|
2254 removed = mService->removeEntryFromGroup((CaEntry &)*entryGroup, *entry2); |
|
2255 QTest::qWait(waitTime1sec); |
|
2256 |
|
2257 QVERIFY(clientNotifier->mGroupId > 0); |
|
2258 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
2259 QCOMPARE(clientNotifier->mGroupId, entryGroup->id()); |
|
2260 QCOMPARE(removed, TRUE); |
|
2261 |
|
2262 // cleanup |
|
2263 disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2264 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2265 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
2266 clientNotifier, SLOT(groupContentChanged(int))); |
|
2267 QTest::qWait(waitTime500ms); |
|
2268 delete clientNotifier; |
|
2269 mService->removeEntries(entriesList); |
|
2270 QTest::qWait(waitTime1sec); |
|
2271 mService->removeEntry(entryGroup->id()); |
|
2272 QTest::qWait(waitTime1sec); |
|
2273 entriesList.clear(); |
|
2274 |
|
2275 #ifdef Q_OS_SYMBIAN |
|
2276 #ifdef UT_MEMORY_CHECK |
|
2277 // __UHEAP_MARKEND; |
|
2278 #endif//UT_MEMORY_CHECK |
|
2279 #endif//Q_OS_SYMBIAN |
|
2280 } |
|
2281 // --------------------------------------------------------------------------- |
|
2282 // |
|
2283 void TestCaClient::TestRemoveEntryGroupIdNotifier() |
|
2284 { |
|
2285 #ifdef Q_OS_SYMBIAN |
|
2286 #ifdef UT_MEMORY_CHECK |
|
2287 // __UHEAP_MARK; |
|
2288 #endif//UT_MEMORY_CHECK |
|
2289 #endif//Q_OS_SYMBIAN |
|
2290 |
|
2291 |
|
2292 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
2293 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
2294 |
|
2295 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2296 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2297 QTest::qWait(waitTime500ms); |
|
2298 CaEntry group(GroupEntryRole); |
|
2299 group.setText("Text"); |
|
2300 group.setEntryTypeName("TypeName"); |
|
2301 QSharedPointer<CaEntry> entryGroup = mService->createEntry(group); |
|
2302 QTest::qWait(waitTime1sec); |
|
2303 int groupId = entryGroup->id(); |
|
2304 |
|
2305 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
2306 QVERIFY(clientNotifier->mEntryId > 0); |
|
2307 QCOMPARE(clientNotifier->mEntryId, entryGroup->id()); |
|
2308 |
|
2309 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
2310 clientNotifier, SLOT(groupContentChanged(int))); |
|
2311 QTest::qWait(waitTime500ms); |
|
2312 CaEntry item1; |
|
2313 item1.setText("Text"); |
|
2314 item1.setEntryTypeName("TypeName"); |
|
2315 QSharedPointer<CaEntry> entry1 = mService->createEntry(item1); |
|
2316 QTest::qWait(waitTime1sec); |
|
2317 CaEntry item2; |
|
2318 item2.setText("Text"); |
|
2319 item2.setEntryTypeName("TypeName"); |
|
2320 QSharedPointer<CaEntry> entry2 = mService->createEntry(item2); |
|
2321 QTest::qWait(waitTime1sec); |
|
2322 |
|
2323 QList< QSharedPointer<CaEntry> > entriesList; |
|
2324 entriesList.append(entry1); |
|
2325 entriesList.append(entry2); |
|
2326 |
|
2327 bool appended = mService->appendEntriesToGroup((CaEntry &)*entryGroup, entriesList); |
|
2328 QTest::qWait(waitTime1sec); |
|
2329 QCOMPARE(appended, TRUE); |
|
2330 |
|
2331 clientNotifier->mEntryId = 0; |
|
2332 clientNotifier->mGroupId = 0; |
|
2333 bool removed = mService->removeEntryFromGroup(entryGroup->id(), entry1->id()); |
|
2334 QTest::qWait(waitTime1sec); |
|
2335 |
|
2336 QVERIFY(clientNotifier->mGroupId > 0); |
|
2337 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
2338 QCOMPARE(clientNotifier->mGroupId, entryGroup->id()); |
|
2339 QCOMPARE(removed, TRUE); |
|
2340 |
|
2341 clientNotifier->mEntryId = 0; |
|
2342 clientNotifier->mGroupId = 0; |
|
2343 removed = mService->removeEntryFromGroup(entryGroup->id(), entry2->id()); |
|
2344 QTest::qWait(waitTime1sec); |
|
2345 |
|
2346 QVERIFY(clientNotifier->mGroupId > 0); |
|
2347 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
2348 QCOMPARE(clientNotifier->mGroupId, entryGroup->id()); |
|
2349 QCOMPARE(removed, TRUE); |
|
2350 |
|
2351 // cleanup |
|
2352 disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2353 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2354 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
2355 clientNotifier, SLOT(groupContentChanged(int))); |
|
2356 QTest::qWait(waitTime500ms); |
|
2357 delete clientNotifier; |
|
2358 mService->removeEntries(entriesList); |
|
2359 QTest::qWait(waitTime1sec); |
|
2360 mService->removeEntry(entryGroup->id()); |
|
2361 QTest::qWait(waitTime1sec); |
|
2362 entriesList.clear(); |
|
2363 |
|
2364 #ifdef Q_OS_SYMBIAN |
|
2365 #ifdef UT_MEMORY_CHECK |
|
2366 // __UHEAP_MARKEND; |
|
2367 #endif//UT_MEMORY_CHECK |
|
2368 #endif//Q_OS_SYMBIAN |
|
2369 } |
|
2370 // --------------------------------------------------------------------------- |
|
2371 // |
|
2372 void TestCaClient::TestRemoveEntriesGroupNotifier() |
|
2373 { |
|
2374 #ifdef Q_OS_SYMBIAN |
|
2375 #ifdef UT_MEMORY_CHECK |
|
2376 // __UHEAP_MARK; |
|
2377 #endif//UT_MEMORY_CHECK |
|
2378 #endif//Q_OS_SYMBIAN |
|
2379 |
|
2380 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
2381 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
2382 |
|
2383 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2384 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2385 QTest::qWait(waitTime500ms); |
|
2386 CaEntry group(GroupEntryRole); |
|
2387 group.setText("Text"); |
|
2388 group.setEntryTypeName("TypeName"); |
|
2389 QSharedPointer<CaEntry> entryGroup = mService->createEntry(group); |
|
2390 QTest::qWait(waitTime1sec); |
|
2391 int groupId = entryGroup->id(); |
|
2392 |
|
2393 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
2394 QVERIFY(clientNotifier->mEntryId > 0); |
|
2395 QCOMPARE(clientNotifier->mEntryId, entryGroup->id()); |
|
2396 |
|
2397 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
2398 clientNotifier, SLOT(groupContentChanged(int))); |
|
2399 QTest::qWait(waitTime500ms); |
|
2400 CaEntry item1; |
|
2401 item1.setText("Text"); |
|
2402 item1.setEntryTypeName("TypeName"); |
|
2403 QSharedPointer<CaEntry> entry1 = mService->createEntry(item1); |
|
2404 QTest::qWait(waitTime1sec); |
|
2405 CaEntry item2; |
|
2406 item2.setText("Text"); |
|
2407 item2.setEntryTypeName("TypeName"); |
|
2408 QSharedPointer<CaEntry> entry2 = mService->createEntry(item2); |
|
2409 QTest::qWait(waitTime1sec); |
|
2410 |
|
2411 QList<QSharedPointer<CaEntry> > entriesList; |
|
2412 entriesList.append(entry1); |
|
2413 entriesList.append(entry2); |
|
2414 |
|
2415 bool appended = mService->appendEntriesToGroup((CaEntry &)*entryGroup, entriesList); |
|
2416 QTest::qWait(waitTime1sec); |
|
2417 QCOMPARE(appended, TRUE); |
|
2418 |
|
2419 clientNotifier->mEntryId = 0; |
|
2420 clientNotifier->mGroupId = 0; |
|
2421 bool removed = mService->removeEntriesFromGroup((CaEntry &)*entryGroup, entriesList); |
|
2422 QTest::qWait(waitTime1sec); |
|
2423 |
|
2424 QVERIFY(clientNotifier->mGroupId > 0); |
|
2425 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
2426 QCOMPARE(clientNotifier->mGroupId, entryGroup->id()); |
|
2427 QCOMPARE(removed, TRUE); |
|
2428 |
|
2429 // cleanup |
|
2430 disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2431 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2432 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
2433 clientNotifier, SLOT(groupContentChanged(int))); |
|
2434 QTest::qWait(waitTime500ms); |
|
2435 delete clientNotifier; |
|
2436 mService->removeEntries(entriesList); |
|
2437 QTest::qWait(waitTime1sec); |
|
2438 mService->removeEntry(entryGroup->id()); |
|
2439 QTest::qWait(waitTime1sec); |
|
2440 entriesList.clear(); |
|
2441 |
|
2442 #ifdef Q_OS_SYMBIAN |
|
2443 #ifdef UT_MEMORY_CHECK |
|
2444 // __UHEAP_MARKEND; |
|
2445 #endif//UT_MEMORY_CHECK |
|
2446 #endif//Q_OS_SYMBIAN |
|
2447 } |
|
2448 // --------------------------------------------------------------------------- |
|
2449 // |
|
2450 void TestCaClient::TestRemoveEntriesGroupIdNotifier() |
|
2451 { |
|
2452 #ifdef Q_OS_SYMBIAN |
|
2453 #ifdef UT_MEMORY_CHECK |
|
2454 // __UHEAP_MARK; |
|
2455 #endif//UT_MEMORY_CHECK |
|
2456 #endif//Q_OS_SYMBIAN |
|
2457 |
|
2458 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
2459 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
2460 |
|
2461 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2462 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2463 QTest::qWait(waitTime500ms); |
|
2464 CaEntry group(GroupEntryRole); |
|
2465 group.setText("Text"); |
|
2466 group.setEntryTypeName("TypeName"); |
|
2467 QSharedPointer<CaEntry> entryGroup = mService->createEntry(group); |
|
2468 QTest::qWait(waitTime1sec); |
|
2469 int groupId = entryGroup->id(); |
|
2470 |
|
2471 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
2472 QVERIFY(clientNotifier->mEntryId > 0); |
|
2473 QCOMPARE(clientNotifier->mEntryId, entryGroup->id()); |
|
2474 |
|
2475 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
2476 clientNotifier, SLOT(groupContentChanged(int))); |
|
2477 QTest::qWait(waitTime500ms); |
|
2478 CaEntry item1; |
|
2479 item1.setText("Text"); |
|
2480 item1.setEntryTypeName("TypeName"); |
|
2481 QSharedPointer<CaEntry> entry1 = mService->createEntry(item1); |
|
2482 QTest::qWait(waitTime1sec); |
|
2483 CaEntry item2; |
|
2484 item2.setText("Text"); |
|
2485 item2.setEntryTypeName("TypeName"); |
|
2486 QSharedPointer<CaEntry> entry2 = mService->createEntry(item2); |
|
2487 QTest::qWait(waitTime1sec); |
|
2488 |
|
2489 QList<QSharedPointer<CaEntry> > entriesList; |
|
2490 entriesList.append(entry1); |
|
2491 entriesList.append(entry2); |
|
2492 |
|
2493 bool appended = mService->appendEntriesToGroup((CaEntry &)*entryGroup, entriesList); |
|
2494 QTest::qWait(waitTime1sec); |
|
2495 QCOMPARE(appended, TRUE); |
|
2496 |
|
2497 QList<int> entriesIdList; |
|
2498 entriesIdList.append(entry1->id()); |
|
2499 entriesIdList.append(entry2->id()); |
|
2500 clientNotifier->mEntryId = 0; |
|
2501 clientNotifier->mGroupId = 0; |
|
2502 bool removed = mService->removeEntriesFromGroup(entryGroup->id(), entriesIdList); |
|
2503 QTest::qWait(waitTime1sec); |
|
2504 |
|
2505 QVERIFY(clientNotifier->mGroupId > 0); |
|
2506 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
2507 QCOMPARE(clientNotifier->mGroupId, entryGroup->id()); |
|
2508 QCOMPARE(removed, TRUE); |
|
2509 |
|
2510 // cleanup |
|
2511 disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2512 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2513 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
2514 clientNotifier, SLOT(groupContentChanged(int))); |
|
2515 QTest::qWait(waitTime500ms); |
|
2516 delete clientNotifier; |
|
2517 mService->removeEntries(entriesList); |
|
2518 QTest::qWait(waitTime1sec); |
|
2519 mService->removeEntry(entryGroup->id()); |
|
2520 QTest::qWait(waitTime1sec); |
|
2521 entriesList.clear(); |
|
2522 entriesIdList.clear(); |
|
2523 |
|
2524 #ifdef Q_OS_SYMBIAN |
|
2525 #ifdef UT_MEMORY_CHECK |
|
2526 // __UHEAP_MARKEND; |
|
2527 #endif//UT_MEMORY_CHECK |
|
2528 #endif//Q_OS_SYMBIAN |
|
2529 } |
|
2530 // --------------------------------------------------------------------------- |
|
2531 // |
|
2532 void TestCaClient::TestInsertEntryGroupNotifier() |
|
2533 { |
|
2534 #ifdef Q_OS_SYMBIAN |
|
2535 #ifdef UT_MEMORY_CHECK |
|
2536 // __UHEAP_MARK; |
|
2537 #endif//UT_MEMORY_CHECK |
|
2538 #endif//Q_OS_SYMBIAN |
|
2539 |
|
2540 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
2541 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
2542 |
|
2543 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2544 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2545 QTest::qWait(waitTime500ms); |
|
2546 CaEntry group(GroupEntryRole); |
|
2547 group.setText("Text"); |
|
2548 group.setEntryTypeName("TypeName"); |
|
2549 QSharedPointer<CaEntry> entryG = mService->createEntry(group); |
|
2550 QTest::qWait(waitTime1sec); |
|
2551 int groupId = entryG->id(); |
|
2552 |
|
2553 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
2554 QVERIFY(clientNotifier->mEntryId > 0); |
|
2555 QCOMPARE(clientNotifier->mEntryId, entryG->id()); |
|
2556 |
|
2557 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
2558 clientNotifier, SLOT(groupContentChanged(int))); |
|
2559 QTest::qWait(waitTime500ms); |
|
2560 CaEntry item1; |
|
2561 item1.setText("Text1"); |
|
2562 item1.setEntryTypeName("TypeName1"); |
|
2563 QSharedPointer<CaEntry> entryI1 = mService->createEntry(item1); |
|
2564 QTest::qWait(waitTime1sec); |
|
2565 CaEntry item2; |
|
2566 item2.setText("Text2"); |
|
2567 item2.setEntryTypeName("TypeName2"); |
|
2568 QSharedPointer<CaEntry> entryI2 = mService->createEntry(item2); |
|
2569 QTest::qWait(waitTime1sec); |
|
2570 |
|
2571 bool appended = mService->appendEntryToGroup((CaEntry &)(*entryG), *entryI1); |
|
2572 QTest::qWait(waitTime500ms); |
|
2573 QCOMPARE(appended, TRUE); |
|
2574 appended = mService->prependEntryToGroup((CaEntry &)(*entryG), *entryI2); |
|
2575 QTest::qWait(waitTime500ms); |
|
2576 QCOMPARE(appended, TRUE); |
|
2577 |
|
2578 CaEntry item3; |
|
2579 item3.setText("Text3"); |
|
2580 item3.setEntryTypeName("TypeName3"); |
|
2581 QSharedPointer<CaEntry> entryI3 = mService->createEntry(item3); |
|
2582 QTest::qWait(waitTime1sec); |
|
2583 clientNotifier->mEntryId = 0; |
|
2584 clientNotifier->mGroupId = 0; |
|
2585 |
|
2586 bool inserted = mService->insertEntryIntoGroup((CaEntry &)*entryG, *entryI3, entryI2->id()); |
|
2587 QTest::qWait(waitTime1sec); |
|
2588 |
|
2589 QVERIFY(clientNotifier->mGroupId > 0); |
|
2590 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
2591 QCOMPARE(clientNotifier->mGroupId, entryG->id()); |
|
2592 QCOMPARE(inserted, TRUE); |
|
2593 |
|
2594 // cleanup |
|
2595 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
2596 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
2597 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
2598 clientNotifier, SLOT(groupContentChanged(int))); |
|
2599 QTest::qWait(waitTime500ms); |
|
2600 delete clientNotifier; |
|
2601 mService->removeEntry(entryI1->id()); |
|
2602 QTest::qWait(waitTime500ms); |
|
2603 mService->removeEntry(entryI2->id()); |
|
2604 QTest::qWait(waitTime500ms); |
|
2605 mService->removeEntry(entryI3->id()); |
|
2606 QTest::qWait(waitTime500ms); |
|
2607 mService->removeEntry(entryG->id()); |
|
2608 QTest::qWait(waitTime1sec); |
|
2609 |
|
2610 #ifdef Q_OS_SYMBIAN |
|
2611 #ifdef UT_MEMORY_CHECK |
|
2612 // __UHEAP_MARKEND; |
|
2613 #endif//UT_MEMORY_CHECK |
|
2614 #endif//Q_OS_SYMBIAN |
|
2615 } |
|
2616 // --------------------------------------------------------------------------- |
|
2617 // |
|
2618 // --------------------------------------------------------------------------- |
|
2619 // |
|
2620 void TestCaClient::TestInsertEntryGroupIdNotifier() |
|
2621 { |
|
2622 #ifdef Q_OS_SYMBIAN |
|
2623 #ifdef UT_MEMORY_CHECK |
|
2624 // __UHEAP_MARK; |
|
2625 #endif//UT_MEMORY_CHECK |
|
2626 #endif//Q_OS_SYMBIAN |
|
2627 |
|
2628 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
2629 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
2630 |
|
2631 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2632 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2633 QTest::qWait(waitTime500ms); |
|
2634 CaEntry group(GroupEntryRole); |
|
2635 group.setText("Text"); |
|
2636 group.setEntryTypeName("TypeName"); |
|
2637 QSharedPointer<CaEntry> entryG = mService->createEntry(group); |
|
2638 QTest::qWait(waitTime1sec); |
|
2639 int groupId = entryG->id(); |
|
2640 |
|
2641 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
2642 QVERIFY(clientNotifier->mEntryId > 0); |
|
2643 QCOMPARE(clientNotifier->mEntryId, entryG->id()); |
|
2644 |
|
2645 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
2646 clientNotifier, SLOT(groupContentChanged(int))); |
|
2647 QTest::qWait(waitTime500ms); |
|
2648 CaEntry item1; |
|
2649 item1.setText("Text1"); |
|
2650 item1.setEntryTypeName("TypeName1"); |
|
2651 QSharedPointer<CaEntry> entryI1 = mService->createEntry(item1); |
|
2652 QTest::qWait(waitTime1sec); |
|
2653 CaEntry item2; |
|
2654 item2.setText("Text2"); |
|
2655 item2.setEntryTypeName("TypeName2"); |
|
2656 QSharedPointer<CaEntry> entryI2 = mService->createEntry(item2); |
|
2657 QTest::qWait(waitTime1sec); |
|
2658 |
|
2659 bool appended = mService->appendEntryToGroup(entryG->id(), entryI1->id()); |
|
2660 QTest::qWait(waitTime500ms); |
|
2661 QCOMPARE(appended, TRUE); |
|
2662 appended = mService->prependEntryToGroup(entryG->id(), entryI2->id()); |
|
2663 QTest::qWait(waitTime500ms); |
|
2664 QCOMPARE(appended, TRUE); |
|
2665 |
|
2666 CaEntry item3; |
|
2667 item3.setText("Text3"); |
|
2668 item3.setEntryTypeName("TypeName3"); |
|
2669 QSharedPointer<CaEntry> entryI3 = mService->createEntry(item3); |
|
2670 QTest::qWait(waitTime1sec); |
|
2671 clientNotifier->mEntryId = 0; |
|
2672 clientNotifier->mGroupId = 0; |
|
2673 |
|
2674 bool inserted = mService->insertEntryIntoGroup(entryG->id(), entryI3->id(), entryI2->id()); |
|
2675 QTest::qWait(waitTime1sec); |
|
2676 |
|
2677 QVERIFY(clientNotifier->mGroupId > 0); |
|
2678 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
2679 QCOMPARE(clientNotifier->mGroupId, entryG->id()); |
|
2680 QCOMPARE(inserted, TRUE); |
|
2681 |
|
2682 // cleanup |
|
2683 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
2684 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
2685 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
2686 clientNotifier, SLOT(groupContentChanged(int))); |
|
2687 QTest::qWait(waitTime500ms); |
|
2688 delete clientNotifier; |
|
2689 mService->removeEntry(entryI1->id()); |
|
2690 QTest::qWait(waitTime500ms); |
|
2691 mService->removeEntry(entryI2->id()); |
|
2692 QTest::qWait(waitTime500ms); |
|
2693 mService->removeEntry(entryI3->id()); |
|
2694 QTest::qWait(waitTime500ms); |
|
2695 mService->removeEntry(entryG->id()); |
|
2696 QTest::qWait(waitTime1sec); |
|
2697 |
|
2698 #ifdef Q_OS_SYMBIAN |
|
2699 #ifdef UT_MEMORY_CHECK |
|
2700 // __UHEAP_MARKEND; |
|
2701 #endif//UT_MEMORY_CHECK |
|
2702 #endif//Q_OS_SYMBIAN |
|
2703 } |
|
2704 // --------------------------------------------------------------------------- |
|
2705 // |
|
2706 void TestCaClient::TestInsertEntriesGroupNotifier() |
|
2707 { |
|
2708 #ifdef Q_OS_SYMBIAN |
|
2709 #ifdef UT_MEMORY_CHECK |
|
2710 // __UHEAP_MARK; |
|
2711 #endif//UT_MEMORY_CHECK |
|
2712 #endif//Q_OS_SYMBIAN |
|
2713 |
|
2714 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
2715 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
2716 |
|
2717 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2718 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2719 QTest::qWait(waitTime500ms); |
|
2720 CaEntry group(GroupEntryRole); |
|
2721 group.setText("Text"); |
|
2722 group.setEntryTypeName("TypeName"); |
|
2723 QSharedPointer<CaEntry> entryG = mService->createEntry(group); |
|
2724 QTest::qWait(waitTime1sec); |
|
2725 int groupId = entryG->id(); |
|
2726 |
|
2727 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
2728 QVERIFY(clientNotifier->mEntryId > 0); |
|
2729 QCOMPARE(clientNotifier->mEntryId, entryG->id()); |
|
2730 |
|
2731 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
2732 clientNotifier, SLOT(groupContentChanged(int))); |
|
2733 QTest::qWait(waitTime500ms); |
|
2734 CaEntry item1; |
|
2735 item1.setText("Text1"); |
|
2736 item1.setEntryTypeName("TypeName1"); |
|
2737 QSharedPointer<CaEntry> entryI1 = mService->createEntry(item1); |
|
2738 QTest::qWait(waitTime1sec); |
|
2739 CaEntry item2; |
|
2740 item2.setText("Text2"); |
|
2741 item2.setEntryTypeName("TypeName2"); |
|
2742 QSharedPointer<CaEntry> entryI2 = mService->createEntry(item2); |
|
2743 QTest::qWait(waitTime1sec); |
|
2744 |
|
2745 bool appended = mService->appendEntryToGroup((CaEntry &)(*entryG), *entryI1); |
|
2746 QTest::qWait(waitTime500ms); |
|
2747 QCOMPARE(appended, TRUE); |
|
2748 appended = mService->prependEntryToGroup((CaEntry &)(*entryG), *entryI2); |
|
2749 QTest::qWait(waitTime500ms); |
|
2750 QCOMPARE(appended, TRUE); |
|
2751 |
|
2752 CaEntry item3; |
|
2753 item3.setText("Text3"); |
|
2754 item3.setEntryTypeName("TypeName3"); |
|
2755 QSharedPointer<CaEntry> entryI3 = mService->createEntry(item3); |
|
2756 QTest::qWait(waitTime1sec); |
|
2757 CaEntry item4; |
|
2758 item4.setText("Text4"); |
|
2759 item4.setEntryTypeName("TypeName4"); |
|
2760 QSharedPointer<CaEntry> entryI4 = mService->createEntry(item4); |
|
2761 QTest::qWait(waitTime1sec); |
|
2762 |
|
2763 QList<QSharedPointer<CaEntry> > entriesList; |
|
2764 entriesList.append(entryI3); |
|
2765 entriesList.append(entryI4); |
|
2766 clientNotifier->mEntryId = 0; |
|
2767 clientNotifier->mGroupId = 0; |
|
2768 |
|
2769 bool inserted = mService->insertEntriesIntoGroup((CaEntry &)*entryG, entriesList, entryI2->id()); |
|
2770 QTest::qWait(waitTime1sec); |
|
2771 |
|
2772 QVERIFY(clientNotifier->mGroupId > 0); |
|
2773 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
2774 QCOMPARE(clientNotifier->mGroupId, entryG->id()); |
|
2775 QCOMPARE(inserted, TRUE); |
|
2776 |
|
2777 // cleanup |
|
2778 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
2779 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
2780 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
2781 clientNotifier, SLOT(groupContentChanged(int))); |
|
2782 QTest::qWait(waitTime500ms); |
|
2783 delete clientNotifier; |
|
2784 mService->removeEntry(entryI1->id()); |
|
2785 QTest::qWait(waitTime500ms); |
|
2786 mService->removeEntry(entryI2->id()); |
|
2787 QTest::qWait(waitTime500ms); |
|
2788 mService->removeEntry(entryI3->id()); |
|
2789 QTest::qWait(waitTime500ms); |
|
2790 mService->removeEntry(entryI4->id()); |
|
2791 QTest::qWait(waitTime500ms); |
|
2792 mService->removeEntry(entryG->id()); |
|
2793 QTest::qWait(waitTime1sec); |
|
2794 entriesList.clear(); |
|
2795 #ifdef Q_OS_SYMBIAN |
|
2796 #ifdef UT_MEMORY_CHECK |
|
2797 // __UHEAP_MARKEND; |
|
2798 #endif//UT_MEMORY_CHECK |
|
2799 #endif//Q_OS_SYMBIAN |
|
2800 } |
|
2801 // --------------------------------------------------------------------------- |
|
2802 // |
|
2803 void TestCaClient::TestInsertEntriesGroupIdNotifier() |
|
2804 { |
|
2805 #ifdef Q_OS_SYMBIAN |
|
2806 #ifdef UT_MEMORY_CHECK |
|
2807 // __UHEAP_MARK; |
|
2808 #endif//UT_MEMORY_CHECK |
|
2809 #endif//Q_OS_SYMBIAN |
|
2810 |
|
2811 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService); |
|
2812 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
2813 |
|
2814 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2815 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2816 QTest::qWait(waitTime500ms); |
|
2817 CaEntry group(GroupEntryRole); |
|
2818 group.setText("Text"); |
|
2819 group.setEntryTypeName("TypeName"); |
|
2820 QSharedPointer<CaEntry> entryG = mService->createEntry(group); |
|
2821 QTest::qWait(waitTime1sec); |
|
2822 int groupId = entryG->id(); |
|
2823 |
|
2824 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
2825 QVERIFY(clientNotifier->mEntryId > 0); |
|
2826 QCOMPARE(clientNotifier->mEntryId, entryG->id()); |
|
2827 |
|
2828 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
2829 clientNotifier, SLOT(groupContentChanged(int))); |
|
2830 QTest::qWait(waitTime500ms); |
|
2831 CaEntry item1; |
|
2832 item1.setText("Text1"); |
|
2833 item1.setEntryTypeName("TypeName1"); |
|
2834 QSharedPointer<CaEntry> entryI1 = mService->createEntry(item1); |
|
2835 QTest::qWait(waitTime1sec); |
|
2836 CaEntry item2; |
|
2837 item2.setText("Text2"); |
|
2838 item2.setEntryTypeName("TypeName2"); |
|
2839 QSharedPointer<CaEntry> entryI2 = mService->createEntry(item2); |
|
2840 QTest::qWait(waitTime1sec); |
|
2841 |
|
2842 bool appended = mService->appendEntryToGroup((CaEntry &)(*entryG), *entryI1); |
|
2843 QTest::qWait(waitTime500ms); |
|
2844 QCOMPARE(appended, TRUE); |
|
2845 appended = mService->prependEntryToGroup((CaEntry &)(*entryG), *entryI2); |
|
2846 QTest::qWait(waitTime500ms); |
|
2847 QCOMPARE(appended, TRUE); |
|
2848 |
|
2849 CaEntry item3; |
|
2850 item3.setText("Text3"); |
|
2851 item3.setEntryTypeName("TypeName3"); |
|
2852 QSharedPointer<CaEntry> entryI3 = mService->createEntry(item3); |
|
2853 QTest::qWait(waitTime1sec); |
|
2854 CaEntry item4; |
|
2855 item4.setText("Text4"); |
|
2856 item4.setEntryTypeName("TypeName4"); |
|
2857 QSharedPointer<CaEntry> entryI4 = mService->createEntry(item4); |
|
2858 QTest::qWait(waitTime1sec); |
|
2859 |
|
2860 QList<int> entriesIdsList; |
|
2861 entriesIdsList.append(entryI3->id()); |
|
2862 entriesIdsList.append(entryI4->id()); |
|
2863 clientNotifier->mEntryId = 0; |
|
2864 clientNotifier->mGroupId = 0; |
|
2865 |
|
2866 bool inserted = mService->insertEntriesIntoGroup(entryG->id(), entriesIdsList, entryI2->id()); |
|
2867 QTest::qWait(waitTime1sec); |
|
2868 |
|
2869 QVERIFY(clientNotifier->mGroupId > 0); |
|
2870 QCOMPARE(clientNotifier->mGroupId, groupId); |
|
2871 QCOMPARE(clientNotifier->mGroupId, entryG->id()); |
|
2872 QCOMPARE(inserted, TRUE); |
|
2873 |
|
2874 // cleanup |
|
2875 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
2876 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
2877 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
2878 clientNotifier, SLOT(groupContentChanged(int))); |
|
2879 QTest::qWait(waitTime500ms); |
|
2880 delete clientNotifier; |
|
2881 mService->removeEntry(entryI1->id()); |
|
2882 QTest::qWait(waitTime500ms); |
|
2883 mService->removeEntry(entryI2->id()); |
|
2884 QTest::qWait(waitTime500ms); |
|
2885 mService->removeEntry(entryI3->id()); |
|
2886 QTest::qWait(waitTime500ms); |
|
2887 mService->removeEntry(entryI4->id()); |
|
2888 QTest::qWait(waitTime500ms); |
|
2889 mService->removeEntry(entryG->id()); |
|
2890 QTest::qWait(waitTime1sec); |
|
2891 entriesIdsList.clear(); |
|
2892 |
|
2893 #ifdef Q_OS_SYMBIAN |
|
2894 #ifdef UT_MEMORY_CHECK |
|
2895 // __UHEAP_MARKEND; |
|
2896 #endif//UT_MEMORY_CHECK |
|
2897 #endif//Q_OS_SYMBIAN |
|
2898 } |
|
2899 |
|
2900 // --------------------------------------------------------------------------- |
|
2901 // |
|
2902 void TestCaClient::TestChangeEntryWithParentIdNotifier() |
|
2903 { |
|
2904 #ifdef Q_OS_SYMBIAN |
|
2905 #ifdef UT_MEMORY_CHECK |
|
2906 // __UHEAP_MARK; |
|
2907 #endif//UT_MEMORY_CHECK |
|
2908 #endif//Q_OS_SYMBIAN |
|
2909 CaNotifierFilter *filter = new CaNotifierFilter(); |
|
2910 filter->setParentId(1); // AllCollections |
|
2911 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*mService, filter); |
|
2912 |
|
2913 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
2914 |
|
2915 connect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2916 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2917 connect(notifier, SIGNAL(groupContentChanged(int)), |
|
2918 clientNotifier, SLOT(groupContentChanged(int))); |
|
2919 QTest::qWait(waitTime500ms); |
|
2920 |
|
2921 CaEntry entryToAdd(ItemEntryRole); |
|
2922 entryToAdd.setText("Text"); |
|
2923 entryToAdd.setEntryTypeName("TypeName"); |
|
2924 QSharedPointer<CaEntry> entry = mService->createEntry(entryToAdd); |
|
2925 QTest::qWait(waitTime1sec); |
|
2926 int entryId = entry->id(); |
|
2927 |
|
2928 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
2929 QCOMPARE(clientNotifier->mEntryId, 0); |
|
2930 QCOMPARE(clientNotifier->mCount, 0); |
|
2931 |
|
2932 bool appended = mService->appendEntryToGroup(3, entryId); // office |
|
2933 QTest::qWait(waitTime1sec); |
|
2934 |
|
2935 |
|
2936 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
2937 QVERIFY(clientNotifier->mGroupId > 0); |
|
2938 QCOMPARE(clientNotifier->mCount, 1); |
|
2939 |
|
2940 mService->removeEntry(entryId); |
|
2941 |
|
2942 QTest::qWait(waitTime1sec); |
|
2943 |
|
2944 QCOMPARE(clientNotifier->mChangeType, RemoveChangeType); |
|
2945 QVERIFY(clientNotifier->mGroupId > 0); |
|
2946 QCOMPARE(clientNotifier->mCount, 2); |
|
2947 |
|
2948 disconnect(notifier, SIGNAL(entryChanged(int, ChangeType)), |
|
2949 clientNotifier, SLOT(entryChanged(int, ChangeType))); |
|
2950 disconnect(notifier, SIGNAL(groupContentChanged(int)), |
|
2951 clientNotifier, SLOT(groupContentChanged(int))); |
|
2952 |
|
2953 QTest::qWait(waitTime500ms); |
|
2954 |
|
2955 delete clientNotifier; |
|
2956 delete filter; |
|
2957 |
|
2958 |
|
2959 #ifdef Q_OS_SYMBIAN |
|
2960 #ifdef UT_MEMORY_CHECK |
|
2961 // __UHEAP_MARKEND; |
|
2962 #endif//UT_MEMORY_CHECK |
|
2963 #endif//Q_OS_SYMBIAN |
|
2964 } |
|
2965 |
|
2966 //QTEST_MAIN(homescreen::test::TestCaClient) |