|
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: Extra tests notifications. |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include "t_caclient.h" |
|
20 #include "caservice.h" |
|
21 #include "canotifier.h" |
|
22 #include "canotifierfilter.h" |
|
23 #include "t_caclientnotifier.h" |
|
24 |
|
25 const int entryIdFake(-1); |
|
26 const int waitTimeMin(100); |
|
27 const int waitTime500ms(500); |
|
28 const int waitTime1sec(1000); |
|
29 |
|
30 const int noOfClients(3); |
|
31 const int noOfManyClients(20); |
|
32 |
|
33 class Thread: public QThread |
|
34 { |
|
35 public: |
|
36 enum OpType {None, AddItem, RemoveEntry, RemoveEntryId, TooMuchClients}; |
|
37 void run(); |
|
38 Thread(): mOpType(None), mRemoved(false), mEntry(), mId(0), mClientNotifier(NULL), mNotifier(NULL) { } |
|
39 ~Thread(); |
|
40 |
|
41 OpType mOpType; |
|
42 bool mRemoved; |
|
43 QSharedPointer<CaEntry> mEntry; |
|
44 int mId; |
|
45 TestCaClientNotifier *mClientNotifier; |
|
46 CaNotifier *mNotifier; |
|
47 }; |
|
48 |
|
49 Thread::~Thread() |
|
50 { |
|
51 QSharedPointer<CaService> service = CaService::instance(); |
|
52 service->removeEntry(mId); |
|
53 disconnect(mNotifier, SIGNAL(entryChanged(int,ChangeType)), |
|
54 mClientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
55 QTest::qWait(waitTime500ms); |
|
56 delete mClientNotifier; |
|
57 } |
|
58 |
|
59 void Thread::run() |
|
60 { |
|
61 QTest::qWait(waitTimeMin); |
|
62 QSharedPointer<CaService> service = CaService::instance(); |
|
63 CaNotifierFilter *filter = new CaNotifierFilter(); |
|
64 filter->setEntryRole(ItemEntryRole); |
|
65 filter->setTypeNames(QStringList() << "TypeName"); |
|
66 mClientNotifier = new TestCaClientNotifier(*service, filter); |
|
67 mNotifier = mClientNotifier->getNotifier(); |
|
68 CaEntry item; |
|
69 item.setText("Text"); |
|
70 item.setEntryTypeName("TypeName"); |
|
71 switch (mOpType) { |
|
72 case AddItem: { |
|
73 connect(mNotifier, SIGNAL(entryChanged(int,ChangeType)), |
|
74 mClientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
75 QTest::qWait(waitTime1sec); |
|
76 QSharedPointer<CaEntry> entry = service->createEntry(item); |
|
77 mId = entry->id(); |
|
78 } |
|
79 break; |
|
80 case RemoveEntry: { |
|
81 connect(mNotifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
82 mClientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
83 QTest::qWait(waitTime1sec); |
|
84 mRemoved = service->removeEntry(*mEntry); |
|
85 } |
|
86 break; |
|
87 case RemoveEntryId: { |
|
88 connect(mNotifier, SIGNAL(entryChanged(int,ChangeType)), |
|
89 mClientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
90 QTest::qWait(waitTime1sec); |
|
91 mRemoved = service->removeEntry(mId); |
|
92 } |
|
93 break; |
|
94 case TooMuchClients: { |
|
95 connect(mNotifier, SIGNAL(entryChanged(int,ChangeType)), |
|
96 mClientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
97 } |
|
98 break; |
|
99 default: |
|
100 qWarning("Thread::run: unknown operation (mOpType)"); |
|
101 break; |
|
102 } |
|
103 |
|
104 exec(); |
|
105 } |
|
106 |
|
107 /* |
|
108 class ThreadRemoveEntry: public QThread |
|
109 { |
|
110 public: |
|
111 void run(); |
|
112 ~ThreadRemoveEntry(); |
|
113 |
|
114 bool mRemoved; |
|
115 CaEntry *mEntry; |
|
116 int mId; |
|
117 TestCaClientNotifier *mClientNotifier; |
|
118 CaNotifier *mNotifier; |
|
119 }; |
|
120 |
|
121 ThreadRemoveEntry::~ThreadRemoveEntry() |
|
122 { |
|
123 disconnect(mNotifier, SIGNAL(entryChanged(int,ChangeType)), |
|
124 mClientNotifier, SLOT(entryChanged(int,ChangeType)) ); |
|
125 QTest::qWait(waitTime500ms); |
|
126 delete mClientNotifier; |
|
127 } |
|
128 |
|
129 void ThreadRemoveEntry::run() |
|
130 { |
|
131 QSharedPointer<CaService> service = CaService::instance(); |
|
132 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*service); |
|
133 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
134 connect( notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType )), |
|
135 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType )) ); |
|
136 |
|
137 CaEntry item; |
|
138 item.setText("Text"); |
|
139 item.setEntryTypeName("TypeName"); |
|
140 |
|
141 mRemoved = service->removeEntry(*mEntry); |
|
142 |
|
143 exec(); |
|
144 } |
|
145 */ |
|
146 |
|
147 // --------------------------------------------------------------------------- |
|
148 // --------------------------------------------------------------------------- |
|
149 // |
|
150 void TestCaClient::TestAddItemChangeTypeNotifierNClients() |
|
151 { |
|
152 #ifdef Q_OS_SYMBIAN |
|
153 #ifdef UT_MEMORY_CHECK |
|
154 __UHEAP_MARK; |
|
155 #endif//UT_MEMORY_CHECK |
|
156 #endif//Q_OS_SYMBIAN |
|
157 { |
|
158 QSharedPointer<CaService> service = CaService::instance(); |
|
159 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*service); |
|
160 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
161 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
162 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
163 |
|
164 QTest::qWait(waitTime1sec); |
|
165 CaEntry item; |
|
166 item.setText("Text"); |
|
167 item.setEntryTypeName("TypeName"); |
|
168 QSharedPointer<CaEntry> entries[noOfClients]; |
|
169 for (int i=0; i<noOfClients; i++) { |
|
170 item.setText("Text"); |
|
171 item.setEntryTypeName("TypeName"); |
|
172 entries[i] = service->createEntry(item); |
|
173 QTest::qWait(waitTime1sec); |
|
174 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
175 QCOMPARE(clientNotifier->mEntryId, entries[i]->id()); |
|
176 QCOMPARE(clientNotifier->mCount, i+1); |
|
177 } |
|
178 |
|
179 for (int i=0; i<noOfClients; i++) { |
|
180 for (int j=i+1; j<noOfClients; j++) { |
|
181 QVERIFY(entries[i]->id() != entries[j]->id()); |
|
182 } |
|
183 } |
|
184 |
|
185 // cleanup |
|
186 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
187 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
188 QTest::qWait(waitTime500ms); |
|
189 delete clientNotifier; |
|
190 for (int i=0; i<noOfClients; i++) { |
|
191 service->removeEntry(entries[i]->id()); |
|
192 } |
|
193 } |
|
194 |
|
195 |
|
196 #ifdef Q_OS_SYMBIAN |
|
197 #ifdef UT_MEMORY_CHECK |
|
198 __UHEAP_MARKEND; |
|
199 #endif//UT_MEMORY_CHECK |
|
200 #endif//Q_OS_SYMBIAN |
|
201 } |
|
202 |
|
203 // --------------------------------------------------------------------------- |
|
204 // --------------------------------------------------------------------------- |
|
205 // |
|
206 void TestCaClient::TestAddItemChangeTypeNotifierNClientsFast() |
|
207 { |
|
208 #ifdef Q_OS_SYMBIAN |
|
209 #ifdef UT_MEMORY_CHECK |
|
210 __UHEAP_MARK; |
|
211 #endif//UT_MEMORY_CHECK |
|
212 #endif//Q_OS_SYMBIAN |
|
213 { |
|
214 QSharedPointer<CaService> service = CaService::instance(); |
|
215 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*service); |
|
216 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
217 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
218 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
219 |
|
220 QTest::qWait(waitTime1sec); |
|
221 CaEntry item; |
|
222 item.setText("Text"); |
|
223 item.setEntryTypeName("TypeName"); |
|
224 QSharedPointer<CaEntry> entries[noOfClients]; |
|
225 item.setText("Text"); |
|
226 item.setEntryTypeName("TypeName"); |
|
227 for (int i=0; i<noOfClients; i++) { |
|
228 entries[i] = service->createEntry(item); |
|
229 } |
|
230 QTest::qWait(waitTime1sec); |
|
231 QCOMPARE(clientNotifier->mCount, 3); |
|
232 for (int i=0; i<noOfClients; i++) { |
|
233 QVERIFY(clientNotifier->mEntryIds->contains(entries[i]->id())); |
|
234 for (int j=i+1; j<noOfClients; j++) { |
|
235 QVERIFY(entries[i]->id() != entries[j]->id()); |
|
236 } |
|
237 } |
|
238 |
|
239 // cleanup |
|
240 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
241 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
242 QTest::qWait(waitTime500ms); |
|
243 delete clientNotifier; |
|
244 for (int i=0; i<noOfClients; i++) { |
|
245 service->removeEntry(entries[i]->id()); |
|
246 } |
|
247 } |
|
248 |
|
249 |
|
250 #ifdef Q_OS_SYMBIAN |
|
251 #ifdef UT_MEMORY_CHECK |
|
252 __UHEAP_MARKEND; |
|
253 #endif//UT_MEMORY_CHECK |
|
254 #endif//Q_OS_SYMBIAN |
|
255 } |
|
256 |
|
257 // --------------------------------------------------------------------------- |
|
258 // --------------------------------------------------------------------------- |
|
259 // |
|
260 void TestCaClient::TestAddItemChangeTypeNotifierNClientsThreads() |
|
261 { |
|
262 #ifdef Q_OS_SYMBIAN |
|
263 #ifdef UT_MEMORY_CHECK |
|
264 __UHEAP_MARK; |
|
265 #endif//UT_MEMORY_CHECK |
|
266 #endif//Q_OS_SYMBIAN |
|
267 { |
|
268 Thread threads[noOfClients]; |
|
269 for (int i=0; i<noOfClients; i++) { |
|
270 threads[i].mOpType = Thread::AddItem; |
|
271 threads[i].start(); |
|
272 } |
|
273 QTest::qWait(6*noOfClients*waitTime1sec); |
|
274 |
|
275 for (int i=0; i<noOfClients; i++) { |
|
276 QCOMPARE(threads[i].mClientNotifier->mCount, noOfClients); |
|
277 for (int j=0; j<noOfClients; j++) { |
|
278 for (int k=j+1; k<noOfClients; k++) { |
|
279 QVERIFY(threads[i].mClientNotifier->mEntryIds->at(j) |
|
280 != threads[i].mClientNotifier->mEntryIds->at(k)); |
|
281 } |
|
282 } |
|
283 } |
|
284 for (int i=0; i<noOfClients; i++) { |
|
285 for (int j=0; j<noOfClients; j++) { |
|
286 QVERIFY(threads[j].mClientNotifier->mEntryIds->contains(threads[i].mId)); |
|
287 } |
|
288 } |
|
289 |
|
290 for (int i=0; i<noOfClients; i++) { |
|
291 threads[i].exit(0); |
|
292 } |
|
293 QTest::qWait(waitTime500ms); |
|
294 |
|
295 } |
|
296 |
|
297 #ifdef Q_OS_SYMBIAN |
|
298 #ifdef UT_MEMORY_CHECK |
|
299 __UHEAP_MARKEND; |
|
300 #endif//UT_MEMORY_CHECK |
|
301 #endif//Q_OS_SYMBIAN |
|
302 } |
|
303 |
|
304 // --------------------------------------------------------------------------- |
|
305 // --------------------------------------------------------------------------- |
|
306 // |
|
307 void TestCaClient::TestRemoveEntryChangeTypeNotifierNClients() |
|
308 { |
|
309 #ifdef Q_OS_SYMBIAN |
|
310 #ifdef UT_MEMORY_CHECK |
|
311 __UHEAP_MARK; |
|
312 #endif//UT_MEMORY_CHECK |
|
313 #endif//Q_OS_SYMBIAN |
|
314 { |
|
315 QSharedPointer<CaService> service = CaService::instance(); |
|
316 TestCaClientNotifier *clientNotifier = new TestCaClientNotifier(*service); |
|
317 CaNotifier *notifier = clientNotifier->getNotifier(); |
|
318 connect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
319 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
320 QTest::qWait(waitTime500ms); |
|
321 connect(notifier, SIGNAL(entryChanged(const CaEntry &,ChangeType)), |
|
322 clientNotifier, SLOT(entryChanged(const CaEntry &,ChangeType))); |
|
323 |
|
324 QTest::qWait(waitTime1sec); |
|
325 CaEntry item; |
|
326 item.setText("Text"); |
|
327 item.setEntryTypeName("TypeName"); |
|
328 QSharedPointer<CaEntry> entries[noOfClients]; |
|
329 for (int i=0; i<noOfClients; i++) { |
|
330 entries[i] = service->createEntry(item); |
|
331 QTest::qWait(waitTime1sec); |
|
332 QCOMPARE(clientNotifier->mChangeType, AddChangeType); |
|
333 QCOMPARE(clientNotifier->mEntryId, entries[i]->id()); |
|
334 QCOMPARE(clientNotifier->mCount, 2*(i+1)); |
|
335 } |
|
336 for (int i=0; i<noOfClients; i++) { |
|
337 bool removed = service->removeEntry(*entries[i]); |
|
338 QVERIFY(removed); |
|
339 QTest::qWait(waitTime1sec); |
|
340 QCOMPARE(clientNotifier->mChangeType, RemoveChangeType); |
|
341 QCOMPARE(clientNotifier->mEntryId, entries[i]->id()); |
|
342 } |
|
343 |
|
344 // cleanup |
|
345 disconnect(notifier, SIGNAL(entryChanged(int,ChangeType)), |
|
346 clientNotifier, SLOT(entryChanged(int,ChangeType))); |
|
347 QTest::qWait(waitTime500ms); |
|
348 delete clientNotifier; |
|
349 } |
|
350 |
|
351 #ifdef Q_OS_SYMBIAN |
|
352 #ifdef UT_MEMORY_CHECK |
|
353 __UHEAP_MARKEND; |
|
354 #endif//UT_MEMORY_CHECK |
|
355 #endif//Q_OS_SYMBIAN |
|
356 } |
|
357 |
|
358 // --------------------------------------------------------------------------- |
|
359 // --------------------------------------------------------------------------- |
|
360 // |
|
361 void TestCaClient::TestRemoveEntryChangeTypeNotifierNClientsThreads() |
|
362 { |
|
363 #ifdef Q_OS_SYMBIAN |
|
364 #ifdef UT_MEMORY_CHECK |
|
365 __UHEAP_MARK; |
|
366 #endif//UT_MEMORY_CHECK |
|
367 #endif//Q_OS_SYMBIAN |
|
368 { |
|
369 QSharedPointer<CaService> service = CaService::instance(); |
|
370 QTest::qWait(waitTime1sec); |
|
371 CaEntry item; |
|
372 item.setText("Text"); |
|
373 item.setEntryTypeName("TypeName"); |
|
374 QSharedPointer<CaEntry> entries[noOfClients]; |
|
375 for (int i=0; i<noOfClients; i++) { |
|
376 entries[i] = service->createEntry(item); |
|
377 } |
|
378 |
|
379 QTest::qWait(waitTime1sec); |
|
380 Thread threads[noOfClients]; |
|
381 for (int i=0; i<noOfClients; i++) { |
|
382 threads[i].mOpType = Thread::RemoveEntry; |
|
383 threads[i].mEntry = entries[i]; |
|
384 threads[i].start(); |
|
385 } |
|
386 QTest::qWait(6*noOfClients*waitTime1sec); |
|
387 for (int i=0; i<noOfClients; i++) { |
|
388 QVERIFY(threads[i].mRemoved); |
|
389 QCOMPARE(threads[i].mClientNotifier->mChangeType, RemoveChangeType); |
|
390 QCOMPARE(threads[i].mClientNotifier->mCount, noOfClients); |
|
391 QVERIFY(threads[i].mClientNotifier->mEntryIds->contains(entries[i]->id())); |
|
392 } |
|
393 |
|
394 for (int i=0; i<noOfClients; i++) { |
|
395 threads[i].exit(0); |
|
396 } |
|
397 QTest::qWait(waitTime500ms); |
|
398 |
|
399 // cleanup |
|
400 for (int i=0; i<noOfClients; i++) { |
|
401 bool removed = service->removeEntry(*entries[i]); |
|
402 QTest::qWait(waitTime1sec); |
|
403 } |
|
404 |
|
405 } |
|
406 |
|
407 #ifdef Q_OS_SYMBIAN |
|
408 #ifdef UT_MEMORY_CHECK |
|
409 __UHEAP_MARKEND; |
|
410 #endif//UT_MEMORY_CHECK |
|
411 #endif//Q_OS_SYMBIAN |
|
412 } |
|
413 |
|
414 // --------------------------------------------------------------------------- |
|
415 // --------------------------------------------------------------------------- |
|
416 // |
|
417 void TestCaClient::TestRemoveEntryIdChangeTypeNotifierNClientsThreads() |
|
418 { |
|
419 #ifdef Q_OS_SYMBIAN |
|
420 #ifdef UT_MEMORY_CHECK |
|
421 __UHEAP_MARK; |
|
422 #endif//UT_MEMORY_CHECK |
|
423 #endif//Q_OS_SYMBIAN |
|
424 { |
|
425 QSharedPointer<CaService> service = CaService::instance(); |
|
426 QTest::qWait(waitTime1sec); |
|
427 CaEntry item; |
|
428 item.setText("Text"); |
|
429 item.setEntryTypeName("TypeName"); |
|
430 int ids[noOfClients]; |
|
431 for (int i=0; i<noOfClients; i++) { |
|
432 ids[i] = service->createEntry(item)->id(); |
|
433 } |
|
434 |
|
435 QTest::qWait(waitTime1sec); |
|
436 Thread threads[noOfClients]; |
|
437 for (int i=0; i<noOfClients; i++) { |
|
438 threads[i].mOpType = Thread::RemoveEntryId; |
|
439 threads[i].mId = ids[i]; |
|
440 threads[i].start(); |
|
441 } |
|
442 QTest::qWait(6*noOfClients*waitTime1sec); |
|
443 for (int i=0; i<noOfClients; i++) { |
|
444 QVERIFY(threads[i].mRemoved); |
|
445 QCOMPARE(threads[i].mClientNotifier->mChangeType, RemoveChangeType); |
|
446 QCOMPARE(threads[i].mClientNotifier->mCount, noOfClients); |
|
447 QVERIFY(threads[i].mClientNotifier->mEntryIds->contains(ids[i])); |
|
448 } |
|
449 |
|
450 for (int i=0; i<noOfClients; i++) { |
|
451 threads[i].exit(0); |
|
452 } |
|
453 QTest::qWait(waitTime500ms); |
|
454 |
|
455 // cleanup |
|
456 for (int i=0; i<noOfClients; i++) { |
|
457 bool removed = service->removeEntry(ids[i]); |
|
458 QTest::qWait(waitTime1sec); |
|
459 } |
|
460 |
|
461 } |
|
462 |
|
463 #ifdef Q_OS_SYMBIAN |
|
464 #ifdef UT_MEMORY_CHECK |
|
465 __UHEAP_MARKEND; |
|
466 #endif//UT_MEMORY_CHECK |
|
467 #endif//Q_OS_SYMBIAN |
|
468 } |
|
469 |
|
470 // --------------------------------------------------------------------------- |
|
471 // --------------------------------------------------------------------------- |
|
472 // |
|
473 void TestCaClient::TestAddItemChangeTypeNotifierManyClientsThreads() |
|
474 { |
|
475 #ifdef Q_OS_SYMBIAN |
|
476 #ifdef UT_MEMORY_CHECK |
|
477 __UHEAP_MARK; |
|
478 #endif//UT_MEMORY_CHECK |
|
479 #endif//Q_OS_SYMBIAN |
|
480 { |
|
481 QSharedPointer<CaService> service = CaService::instance(); |
|
482 |
|
483 Thread threads[noOfManyClients]; |
|
484 for (int i=0; i<noOfManyClients; i++) { |
|
485 threads[i].mOpType = Thread::TooMuchClients; |
|
486 threads[i].start(); |
|
487 } |
|
488 QTest::qWait(10*waitTime1sec); |
|
489 CaEntry item; |
|
490 item.setText("Text"); |
|
491 item.setEntryTypeName("TypeName"); |
|
492 int ids[noOfClients]; |
|
493 for (int i=0; i<noOfClients; i++) { |
|
494 ids[i] = service->createEntry(item)->id(); |
|
495 } |
|
496 QTest::qWait(6*noOfManyClients*waitTime1sec); |
|
497 |
|
498 for (int i=0; i<noOfManyClients; i++) { |
|
499 QCOMPARE(threads[i].mClientNotifier->mCount, noOfClients); |
|
500 for (int j=0; j<noOfClients; j++) { |
|
501 for (int k=j+1; k<noOfClients; k++) { |
|
502 QVERIFY(threads[i].mClientNotifier->mEntryIds->at(j) |
|
503 != threads[i].mClientNotifier->mEntryIds->at(k)); |
|
504 } |
|
505 } |
|
506 } |
|
507 for (int i=0; i<noOfClients; i++) { |
|
508 for (int j=0; j<noOfManyClients; j++) { |
|
509 QVERIFY(threads[j].mClientNotifier->mEntryIds->contains(ids[i])); |
|
510 } |
|
511 } |
|
512 |
|
513 for (int i=0; i<noOfManyClients; i++) { |
|
514 threads[i].exit(0); |
|
515 } |
|
516 QTest::qWait(waitTime500ms); |
|
517 |
|
518 // cleanup |
|
519 for (int i=0; i<noOfClients; i++) { |
|
520 bool removed = service->removeEntry(ids[i]); |
|
521 QVERIFY(removed); |
|
522 QTest::qWait(waitTime1sec); |
|
523 } |
|
524 |
|
525 } |
|
526 |
|
527 #ifdef Q_OS_SYMBIAN |
|
528 #ifdef UT_MEMORY_CHECK |
|
529 __UHEAP_MARKEND; |
|
530 #endif//UT_MEMORY_CHECK |
|
531 #endif//Q_OS_SYMBIAN |
|
532 } |