|
1 // Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 /** |
|
17 @file |
|
18 @publishedAll |
|
19 @released |
|
20 */ |
|
21 #include "RequestMixStep.h" |
|
22 #include "PerformanceFunctionalityDefs.h" |
|
23 |
|
24 _LIT(KRun1,"SingleSession"); |
|
25 _LIT(KRun2,"MultipleSession"); |
|
26 _LIT(KRun3,"MultipleDestroy"); |
|
27 _LIT(KRun4,"SingleTransaction"); |
|
28 _LIT(KRun5,"MultipleTransaction"); |
|
29 _LIT(KRun6,"IndefiniteLock"); |
|
30 _LIT(KRun7,"OddSession"); |
|
31 |
|
32 _LIT(KTest1, "KSingle session tests"); |
|
33 _LIT(KTest2, "Multiple session tests"); |
|
34 _LIT(KTest3, "multiple destroy tests"); |
|
35 _LIT(KTest4, "KSingle session Transaction tests"); |
|
36 _LIT(KTest5, "Multiple session Transaction tests"); |
|
37 _LIT(KTest6, "Indefinite Locking test"); |
|
38 _LIT(KTest7, "Transaction Odd Session Commit test"); |
|
39 |
|
40 #define KNumberOfContacts 10 |
|
41 |
|
42 CRequestMixStep::~CRequestMixStep() |
|
43 { |
|
44 } |
|
45 |
|
46 CRequestMixStep::CRequestMixStep() : CPerformanceFunctionalityBase(KNumberOfContacts) |
|
47 { |
|
48 SetTestStepName(KRequestMixStep); |
|
49 } |
|
50 |
|
51 |
|
52 TVerdict CRequestMixStep::doTestStepL() |
|
53 { |
|
54 __UHEAP_MARK; |
|
55 InitializeL(); |
|
56 _LIT(KStartTest,"CRequestMixStep::doTestStepL()"); |
|
57 INFO_PRINTF1(KStartTest); //Block start |
|
58 CContactDatabase *contactsDatabase2 = CContactDatabase::OpenL();//open another seesion to cntsrv |
|
59 //used by tests that require 2 sessions |
|
60 CleanupStack::PushL( contactsDatabase2 ); |
|
61 iIterate->Reset(); |
|
62 |
|
63 const TDesC &KRun = ConfigSection(); |
|
64 |
|
65 if( KRun == KRun1 ) |
|
66 { |
|
67 INFO_PRINTF1(KTest1); |
|
68 SingularTestsL(); |
|
69 } |
|
70 else if( KRun == KRun2 ) |
|
71 { |
|
72 INFO_PRINTF1(KTest2); |
|
73 SingularTestsL(contactsDatabase2); |
|
74 } |
|
75 else if( KRun == KRun3 ) |
|
76 { |
|
77 INFO_PRINTF1(KTest3); |
|
78 MultipleDestroyTestL(); |
|
79 } |
|
80 else if( KRun == KRun4 ) |
|
81 { |
|
82 INFO_PRINTF1(KTest4); |
|
83 TransactionTestsL(); |
|
84 } |
|
85 else if( KRun == KRun5 ) |
|
86 { |
|
87 INFO_PRINTF1(KTest5); |
|
88 TransactionTestsL(contactsDatabase2); |
|
89 } |
|
90 else if( KRun == KRun6 ) |
|
91 { |
|
92 INFO_PRINTF1(KTest6); |
|
93 EndlessLockTestL(); |
|
94 } |
|
95 else if( KRun == KRun7 ) |
|
96 { |
|
97 INFO_PRINTF1(KTest7); |
|
98 TransactionOddSessionCommitTestL(contactsDatabase2); |
|
99 } |
|
100 else |
|
101 { |
|
102 MissingTestPanic(); |
|
103 } |
|
104 |
|
105 CleanupStack::PopAndDestroy(contactsDatabase2); |
|
106 Cleanup(); |
|
107 __UHEAP_MARKEND; |
|
108 |
|
109 return TestStepResult(); |
|
110 } |
|
111 |
|
112 void CRequestMixStep::SingularTestsL(CContactDatabase *aDb2) |
|
113 { |
|
114 UpdateTestL(aDb2); |
|
115 CloseTestL(aDb2); |
|
116 OpenCloseTestL(aDb2); |
|
117 ReadOpenCloseTestL(aDb2); |
|
118 MultipleOpenTestL(aDb2); |
|
119 } |
|
120 |
|
121 void CRequestMixStep::TransactionTestsL(CContactDatabase *aDb2) |
|
122 { |
|
123 TransactionCommitTestL(aDb2); |
|
124 TransactionCloseTestL(aDb2); |
|
125 TransactionReadCloseTestL(aDb2); |
|
126 TransactionDeleteTestL(aDb2); |
|
127 } |
|
128 |
|
129 void CRequestMixStep::UpdateTestL(CContactDatabase *aDb2) |
|
130 { |
|
131 if(!aDb2) |
|
132 { |
|
133 aDb2 = iContactsDatabase; |
|
134 } |
|
135 TInt err = KErrNone; |
|
136 CContactItem *contactItem1 = NULL; |
|
137 CContactItem *contactItem2 = NULL; |
|
138 CContactItem *contactItem3 = NULL; |
|
139 |
|
140 iIterate->Reset(); |
|
141 TContactItemId con1 = iIterate->NextL(); |
|
142 TContactItemId con2 = iIterate->NextL(); |
|
143 //Lock contact A using session 1 |
|
144 contactItem1 = iContactsDatabase->OpenContactLX(con1); |
|
145 CleanupStack::PushL(contactItem1); |
|
146 |
|
147 //Attemp to open contact a with session 1/2 |
|
148 TRAP(err, contactItem2 = aDb2->OpenContactL(con1) ); |
|
149 |
|
150 TESTPRINT( err == KErrInUse ); |
|
151 CLEAR( contactItem2 ); |
|
152 |
|
153 err = KErrNone; |
|
154 //Attemp to read contact a with session 1/2 |
|
155 TRAP(err, contactItem2 = aDb2->ReadContactL(con1) ); |
|
156 |
|
157 TESTPRINT(KErrNone == err) ; |
|
158 CLEAR( contactItem2 ); |
|
159 |
|
160 |
|
161 err = KErrNone; |
|
162 //read contact b with session 1/2 |
|
163 contactItem2 = aDb2->ReadContactLC(con2); |
|
164 //attempt to update contact 1 with contact 2 using session 1/2 |
|
165 TRAP(err, contactItem3 = aDb2->UpdateContactLC(con1, contactItem2); |
|
166 CleanupStack::PopAndDestroy(contactItem3); |
|
167 ); |
|
168 TESTPRINT(KErrInUse == err) ; |
|
169 contactItem3 = NULL; |
|
170 CleanupStack::PopAndDestroy(contactItem2); |
|
171 contactItem2 = NULL; |
|
172 |
|
173 |
|
174 err = KErrNone; |
|
175 //attempt to delete contact 1 with session 1/2 |
|
176 TRAP(err, aDb2->DeleteContactL(con1) ); |
|
177 TESTPRINT(KErrInUse == err) ; |
|
178 |
|
179 CleanupStack::PopAndDestroy(contactItem1); |
|
180 CleanupStack::PopAndDestroy();//unlock contact 1 |
|
181 contactItem1 = NULL; |
|
182 } |
|
183 |
|
184 void CRequestMixStep::CloseTestL(CContactDatabase *aDb2) |
|
185 { |
|
186 if(!aDb2) |
|
187 { |
|
188 aDb2 = iContactsDatabase; |
|
189 } |
|
190 |
|
191 TInt err = KErrNone; |
|
192 CContactItem *contactItem1 = NULL; |
|
193 |
|
194 iIterate->Reset(); |
|
195 TContactItemId con1 = iIterate->NextL(); |
|
196 contactItem1 = iContactsDatabase->ReadContactL(con1); |
|
197 |
|
198 TRAP(err, aDb2->CommitContactL(*contactItem1) ); |
|
199 CLEAR( contactItem1 ); |
|
200 TESTPRINT(KErrAccessDenied == err); |
|
201 |
|
202 contactItem1 = iContactsDatabase->ReadContactL(con1); |
|
203 |
|
204 err = KErrNone; |
|
205 TRAP(err, aDb2->CloseContactL(con1) ); |
|
206 CLEAR( contactItem1 ); |
|
207 TESTPRINT(KErrNone == err); |
|
208 } |
|
209 |
|
210 void CRequestMixStep::OpenCloseTestL(CContactDatabase *aDb2) |
|
211 { |
|
212 const TBool KSingle = !aDb2; |
|
213 if(KSingle) |
|
214 { |
|
215 aDb2 = iContactsDatabase; |
|
216 } |
|
217 |
|
218 TInt err = KErrNone; |
|
219 CContactItem *contactItem1 = NULL; |
|
220 |
|
221 iIterate->Reset(); |
|
222 TContactItemId con1 = iIterate->NextL(); |
|
223 contactItem1 = iContactsDatabase->OpenContactLX(con1); |
|
224 CleanupStack::PushL(contactItem1); |
|
225 |
|
226 TRAP(err, aDb2->CommitContactL(*contactItem1) ); |
|
227 if(KSingle) |
|
228 { |
|
229 TESTPRINT(KErrNone == err); |
|
230 } |
|
231 else |
|
232 { |
|
233 TESTPRINT(KErrInUse == err); |
|
234 } |
|
235 |
|
236 err = KErrNone; |
|
237 TRAP(err, iContactsDatabase->CommitContactL(*contactItem1) ); |
|
238 CleanupStack::PopAndDestroy( contactItem1 ); |
|
239 CleanupStack::PopAndDestroy(); |
|
240 contactItem1 = NULL; |
|
241 if(KSingle) |
|
242 { |
|
243 TESTPRINT(KErrAccessDenied == err); |
|
244 } |
|
245 else |
|
246 { |
|
247 TESTPRINT(KErrNone == err); |
|
248 } |
|
249 |
|
250 contactItem1 = iContactsDatabase->OpenContactLX(con1); |
|
251 CleanupStack::PushL(contactItem1); |
|
252 |
|
253 TRAP(err, aDb2->CloseContactL(con1) ); |
|
254 TESTPRINT(KErrNone == err); |
|
255 |
|
256 err = KErrNone; |
|
257 TRAP(err, aDb2->CloseContactL(con1) ); |
|
258 CleanupStack::PopAndDestroy( contactItem1 ); |
|
259 CleanupStack::PopAndDestroy(); |
|
260 contactItem1 = NULL; |
|
261 TESTPRINT(KErrNone == err); |
|
262 } |
|
263 |
|
264 void CRequestMixStep::ReadOpenCloseTestL(CContactDatabase *aDb2) |
|
265 { |
|
266 const TBool KSingle = !aDb2; |
|
267 if(!aDb2) |
|
268 { |
|
269 aDb2 = iContactsDatabase; |
|
270 } |
|
271 |
|
272 TInt err = KErrNone; |
|
273 CContactItem *contactItem1 = NULL; |
|
274 CContactItem *contactItem2 = NULL; |
|
275 |
|
276 iIterate->Reset(); |
|
277 TContactItemId con1 = iIterate->NextL(); |
|
278 TContactItemId con2 = iIterate->NextL(); |
|
279 |
|
280 contactItem1 = iContactsDatabase->OpenContactLX(con1); |
|
281 CleanupStack::PushL(contactItem1); |
|
282 contactItem2 = aDb2->ReadContactL(con1); |
|
283 |
|
284 TRAP(err, aDb2->CommitContactL(*contactItem2) ); |
|
285 if(KSingle) |
|
286 { |
|
287 TESTPRINT(KErrNone == err); |
|
288 } |
|
289 else |
|
290 { |
|
291 TESTPRINT(KErrInUse == err); |
|
292 } |
|
293 |
|
294 CleanupStack::PopAndDestroy( contactItem1 ); |
|
295 CleanupStack::PopAndDestroy();//destroy lock (unlock) |
|
296 contactItem1 = NULL; |
|
297 CLEAR(contactItem2); |
|
298 |
|
299 contactItem1 = iContactsDatabase->OpenContactLX(con1); |
|
300 CleanupStack::PushL(contactItem1); |
|
301 contactItem2 = aDb2->ReadContactL(con1); |
|
302 |
|
303 TRAP(err, aDb2->CloseContactL(con1) ); |
|
304 TESTPRINT(KErrNone == err); |
|
305 |
|
306 CleanupStack::PopAndDestroy( contactItem1 ); |
|
307 CleanupStack::PopAndDestroy();//destroy lock (unlock) |
|
308 contactItem1 = NULL; |
|
309 CLEAR(contactItem2); |
|
310 |
|
311 contactItem1 = iContactsDatabase->OpenContactLX(con1); |
|
312 CleanupStack::PushL(contactItem1); |
|
313 contactItem2 = aDb2->ReadContactL(con2); |
|
314 |
|
315 TRAP(err, aDb2->CommitContactL(*contactItem2) ); |
|
316 TESTPRINT(KErrAccessDenied == err); |
|
317 |
|
318 CleanupStack::PopAndDestroy( contactItem1 ); |
|
319 CleanupStack::PopAndDestroy();//destroy lock (unlock) |
|
320 contactItem1 = NULL; |
|
321 CLEAR(contactItem2); |
|
322 } |
|
323 /** |
|
324 for single session: |
|
325 open x many contact then commit them all |
|
326 open x many contacts, close them, then destroy the locks |
|
327 for multiple sessions: |
|
328 open x many contacts then commit them using different session |
|
329 open x many contacts, check that they are still locked, then close them |
|
330 */ |
|
331 void CRequestMixStep::MultipleOpenTestL(CContactDatabase *aDb2) |
|
332 { |
|
333 const TBool KSingle = !aDb2; |
|
334 if(KSingle) |
|
335 { |
|
336 aDb2 = iContactsDatabase; |
|
337 } |
|
338 |
|
339 const TInt KMany = 5; |
|
340 TInt i = 0; |
|
341 TInt err = KErrNone; |
|
342 CContactItem *contactItems[KMany]; |
|
343 TContactItemId con1 = 0; |
|
344 |
|
345 iIterate->Reset(); |
|
346 |
|
347 for(i = 0; i < KMany; ++i) |
|
348 { |
|
349 contactItems[i] = iContactsDatabase->OpenContactLX( iIterate->NextL() ); |
|
350 CleanupStack::PushL( contactItems[i] ); |
|
351 } |
|
352 |
|
353 for(i = 0; i < KMany; ++i) |
|
354 { |
|
355 TRAP(err, aDb2->CommitContactL( *contactItems[i] )); |
|
356 if(KSingle) |
|
357 { |
|
358 TESTPRINTI(KErrNone == err, i); |
|
359 } |
|
360 else |
|
361 { |
|
362 TESTPRINTI(KErrInUse == err, i); |
|
363 } |
|
364 } |
|
365 |
|
366 for(i = KMany - 1; i >= 0; --i) |
|
367 { |
|
368 CleanupStack::PopAndDestroy( contactItems[i] ); |
|
369 CleanupStack::Pop();//pop lock |
|
370 contactItems[i] = NULL; |
|
371 } |
|
372 |
|
373 iIterate->Reset(); |
|
374 err = KErrNone; |
|
375 if(KSingle) |
|
376 { |
|
377 for(i = 0; i < KMany; ++i) |
|
378 { |
|
379 contactItems[i] = iContactsDatabase->OpenContactLX( iIterate->NextL() ); |
|
380 CleanupStack::PushL( contactItems[i] ); |
|
381 } |
|
382 |
|
383 for(i = 0; i < KMany; ++i) |
|
384 { |
|
385 TRAP(err, iContactsDatabase->CloseContactL( contactItems[i]->Id() )); |
|
386 TESTPRINTI(KErrNone == err, i); |
|
387 } |
|
388 |
|
389 for(i = KMany - 1; i >= 0; --i) |
|
390 { |
|
391 CleanupStack::PopAndDestroy( contactItems[i] ); |
|
392 CleanupStack::PopAndDestroy(); |
|
393 contactItems[i] = NULL; |
|
394 } |
|
395 } |
|
396 else |
|
397 { |
|
398 for(i = 0; i < KMany; ++i) |
|
399 { |
|
400 con1 = iIterate->NextL(); |
|
401 TRAP(err, contactItems[0] = iContactsDatabase->OpenContactL( con1 ) ); |
|
402 TESTPRINTI(KErrInUse == err, i); |
|
403 iContactsDatabase->CloseContactL( con1 ); |
|
404 CLEAR(contactItems[0]); |
|
405 } |
|
406 } |
|
407 } |
|
408 /** |
|
409 open x many contacts and push lock on stack |
|
410 destroy all contacts and locks |
|
411 check all contacts are now unlocked |
|
412 */ |
|
413 void CRequestMixStep::MultipleDestroyTestL() |
|
414 { |
|
415 const TInt KMany = 5; |
|
416 TInt i = 0; |
|
417 TInt err = KErrNone; |
|
418 CContactItem *contactItems[KMany]; |
|
419 |
|
420 iIterate->Reset(); |
|
421 |
|
422 for(i = 0; i < KMany; ++i) |
|
423 { |
|
424 contactItems[i] = iContactsDatabase->OpenContactLX( iIterate->NextL() ); |
|
425 CleanupStack::PushL( contactItems[i] ); |
|
426 } |
|
427 |
|
428 for(i = KMany - 1; i >= 0; --i) |
|
429 { |
|
430 CleanupStack::PopAndDestroy( contactItems[i] ); |
|
431 CleanupStack::PopAndDestroy(); |
|
432 contactItems[i] = NULL; |
|
433 } |
|
434 |
|
435 iIterate->Reset(); |
|
436 for(i = 0; i < KMany; ++i) |
|
437 { |
|
438 TRAP(err, contactItems[0] = iContactsDatabase->OpenContactL( iIterate->NextL() ) ); |
|
439 TESTPRINTI(KErrNone == err, i);//checks the contact is no longer locked |
|
440 CLEAR( contactItems[0] ); |
|
441 } |
|
442 |
|
443 iIterate->Reset(); |
|
444 for(i = 0; i < KMany; ++i) |
|
445 { |
|
446 iContactsDatabase->CloseContactL( iIterate->NextL() ); |
|
447 } |
|
448 } |
|
449 |
|
450 void CRequestMixStep::TransactionCommitTestL( CContactDatabase *aDb2 ) |
|
451 { |
|
452 if(!aDb2) |
|
453 { |
|
454 aDb2 = iContactsDatabase; |
|
455 } |
|
456 |
|
457 TInt err = KErrNone; |
|
458 CContactItem *contactItem1 = NULL; |
|
459 CContactItem *contactItem2 = NULL; |
|
460 |
|
461 iIterate->Reset(); |
|
462 TContactItemId con1 = iIterate->NextL(); |
|
463 |
|
464 contactItem1 = aDb2->OpenContactLX(con1); |
|
465 CleanupStack::PushL(contactItem1); |
|
466 |
|
467 iContactsDatabase->DatabaseBeginLC(EFalse); |
|
468 |
|
469 TRAP(err, contactItem2 = iContactsDatabase->OpenContactL( con1 ) ); |
|
470 TESTPRINT( KErrInUse == err ); |
|
471 CLEAR( contactItem2 ); |
|
472 TRAP(err, iContactsDatabase->doCommitContactL(*contactItem1,ETrue,ETrue) ); |
|
473 TESTPRINT( KErrNone == err ); |
|
474 |
|
475 iContactsDatabase->DatabaseCommitLP(EFalse); |
|
476 |
|
477 CleanupStack::PopAndDestroy( contactItem1 ); |
|
478 CleanupStack::PopAndDestroy(); |
|
479 contactItem1 = NULL; |
|
480 CLEAR(contactItem2); |
|
481 } |
|
482 |
|
483 void CRequestMixStep::TransactionCloseTestL( CContactDatabase *aDb2 ) |
|
484 { |
|
485 if(!aDb2) |
|
486 { |
|
487 aDb2 = iContactsDatabase; |
|
488 } |
|
489 |
|
490 TInt err = KErrNone; |
|
491 CContactItem *contactItem1 = NULL; |
|
492 CContactItem *contactItem2 = NULL; |
|
493 |
|
494 iIterate->Reset(); |
|
495 TContactItemId con1 = iIterate->NextL(); |
|
496 |
|
497 contactItem1 = aDb2->OpenContactLX(con1); |
|
498 CleanupStack::PushL(contactItem1); |
|
499 |
|
500 iContactsDatabase->DatabaseBeginLC(EFalse); |
|
501 |
|
502 TRAP(err, iContactsDatabase->CloseContactL( con1 ) ); |
|
503 TESTPRINT( KErrNone == err ); |
|
504 |
|
505 iContactsDatabase->DatabaseCommitLP(EFalse); |
|
506 |
|
507 CleanupStack::PopAndDestroy( contactItem1 ); |
|
508 CleanupStack::PopAndDestroy(); |
|
509 contactItem1 = NULL; |
|
510 CLEAR(contactItem2); |
|
511 } |
|
512 |
|
513 void CRequestMixStep::TransactionReadCloseTestL( CContactDatabase *aDb2 ) |
|
514 { |
|
515 if(!aDb2) |
|
516 { |
|
517 aDb2 = iContactsDatabase; |
|
518 } |
|
519 |
|
520 TInt err = KErrNone; |
|
521 CContactItem *contactItem1 = NULL; |
|
522 CContactItem *contactItem2 = NULL; |
|
523 |
|
524 iIterate->Reset(); |
|
525 TContactItemId con1 = iIterate->NextL(); |
|
526 TContactItemId con2 = iIterate->NextL(); |
|
527 |
|
528 contactItem1 = aDb2->ReadContactLC(con1); |
|
529 contactItem2 = aDb2->ReadContactLC(con2); |
|
530 |
|
531 iContactsDatabase->DatabaseBeginLC(EFalse); |
|
532 |
|
533 TRAP(err, iContactsDatabase->doCommitContactL( *contactItem1,ETrue,ETrue ) ); |
|
534 TESTPRINT( KErrAccessDenied == err ); |
|
535 |
|
536 TRAP(err, iContactsDatabase->CloseContactL( con2 ) ); |
|
537 TESTPRINT( KErrNone == err ); |
|
538 |
|
539 iContactsDatabase->DatabaseCommitLP(EFalse); |
|
540 |
|
541 CleanupStack::PopAndDestroy( contactItem2 ); |
|
542 CleanupStack::PopAndDestroy( contactItem1 ); |
|
543 contactItem1 = NULL; |
|
544 contactItem2 = NULL; |
|
545 } |
|
546 |
|
547 void CRequestMixStep::TransactionDeleteTestL( CContactDatabase *aDb2 ) |
|
548 { |
|
549 |
|
550 TInt err = KErrNone; |
|
551 |
|
552 if( NULL == aDb2 ) |
|
553 { |
|
554 TESTPRINT(NULL == aDb2); |
|
555 return; |
|
556 } |
|
557 |
|
558 iIterate->Reset(); |
|
559 TContactItemId con1 = iIterate->NextL(); |
|
560 CContactItem *contactItem1 = NULL; |
|
561 |
|
562 iContactsDatabase->DatabaseBeginLC(EFalse); |
|
563 |
|
564 TRAP(err, aDb2->doDeleteContactL( con1, ETrue, ETrue ) ); |
|
565 TESTPRINT( KErrLocked == err ); |
|
566 |
|
567 iContactsDatabase->DatabaseRollback(); |
|
568 CleanupStack::Pop(); |
|
569 if( iContactsDatabase->IsDamaged() ) |
|
570 { |
|
571 iContactsDatabase->RecoverL(); |
|
572 } |
|
573 |
|
574 TRAP(err, contactItem1 = iContactsDatabase->ReadContactL( con1 ) ); |
|
575 CLEAR( contactItem1 ); |
|
576 TESTPRINT( KErrNone == err ); |
|
577 |
|
578 if( err == KErrNotFound ) |
|
579 { |
|
580 iIterate->RemoveL( con1 ); |
|
581 AddEmptyContactsL(1, EFalse); |
|
582 } |
|
583 } |
|
584 |
|
585 void CRequestMixStep::TransactionOddSessionCommitTestL( CContactDatabase *aDb2 ) |
|
586 { |
|
587 TInt err = KErrNone; |
|
588 |
|
589 if( NULL == aDb2 ) |
|
590 { |
|
591 TESTPRINT( NULL == aDb2 ); |
|
592 return; |
|
593 } |
|
594 iIterate->Reset(); |
|
595 TContactItemId con1 = iIterate->NextL(); |
|
596 CContactItem *contactItem1 = NULL; |
|
597 |
|
598 iContactsDatabase->DatabaseBeginLC(EFalse); |
|
599 |
|
600 TRAP(err, iContactsDatabase->doDeleteContactL( con1, ETrue, ETrue ) ); |
|
601 TESTPRINT( KErrNone == err ); |
|
602 |
|
603 TRAP( err, aDb2->DatabaseCommitLP(EFalse) ); |
|
604 TESTPRINT( KErrLocked == err ); |
|
605 if( err ) |
|
606 { |
|
607 CleanupStack::Pop(); |
|
608 } |
|
609 TRAP(err, contactItem1 = iContactsDatabase->ReadContactL( con1 ) ); |
|
610 CLEAR( contactItem1 ); |
|
611 TESTPRINT( KErrNotFound == err ); |
|
612 |
|
613 if( err == KErrNotFound ) |
|
614 { |
|
615 iIterate->RemoveL( con1 ); |
|
616 AddEmptyContactsL(1, EFalse); |
|
617 } |
|
618 } |
|
619 |
|
620 /**open contact, kill database session, |
|
621 reopen database, check that contact is not still locked*/ |
|
622 void CRequestMixStep::EndlessLockTestL( ) |
|
623 { |
|
624 CContactItem *contactItem2 = NULL; |
|
625 TContactItemId con1 = iIterate->NextL(); |
|
626 |
|
627 TInt err = KErrNone; |
|
628 iIterate->Reset(); |
|
629 OpenL( con1 ); |
|
630 |
|
631 CLEAR(iContactsDatabase); |
|
632 iContactsDatabase = CContactDatabase::OpenL(); |
|
633 TRAP(err, contactItem2 = iContactsDatabase->OpenContactL( con1 ) ); |
|
634 TESTPRINT( err == KErrNone ); |
|
635 CLEAR(contactItem2); |
|
636 CloseL( ETrue ); |
|
637 } |