63 TBool finished = EFalse; |
63 TBool finished = EFalse; |
64 TInt error; |
64 TInt error; |
65 |
65 |
66 while(!finished) |
66 while(!finished) |
67 { |
67 { |
68 __FILE_FAILNEXT(++failCount); |
68 TheTest.Printf(_L("%d \r"), failCount); |
|
69 __FILE_FAILNEXT(KErrNoMemory, failCount++); |
69 |
70 |
70 TBool result = EFalse; |
71 TBool result = EFalse; |
71 TRAP(error, result = view->SetFilterL(*filter, active->iStatus)); |
72 TRAP(error, result = view->SetFilterL(*filter, active->iStatus)); |
72 |
73 |
73 if (error == KErrNone) |
74 if (error == KErrNone) |
84 TEST(view->CountL() >= 1); |
85 TEST(view->CountL() >= 1); |
85 TEST(TestUtils::EventsEqual(*event, view->Event())); |
86 TEST(TestUtils::EventsEqual(*event, view->Event())); |
86 } |
87 } |
87 else |
88 else |
88 { |
89 { |
89 if(active->iStatus.Int() != KErrGeneral) |
90 if(active->iStatus.Int() != KErrNoMemory) |
90 { |
91 { |
91 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
92 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
92 } |
93 } |
93 TEST2(active->iStatus.Int(), KErrGeneral); |
94 TEST2(active->iStatus.Int(), KErrNoMemory); |
94 } |
95 } |
95 } |
96 } |
96 else |
97 else |
97 { |
98 { |
98 if(error != KErrGeneral) |
99 if(error != KErrNoMemory) |
99 { |
100 { |
100 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error); |
101 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error); |
101 } |
102 } |
102 TEST2(error, KErrGeneral); |
103 TEST2(error, KErrNoMemory); |
103 } |
104 } |
104 |
105 |
105 __FILE_RESET; |
106 __FILE_RESET; |
106 } |
107 } |
107 TheTest.Printf(_L("Test-1 has succeeded at iteration %d\n"), failCount); |
108 TheTest.Printf(_L("\r\nTest-1 has succeeded at iteration %d\n"), failCount); |
108 |
109 |
109 list->AppendL(filter); |
110 list->AppendL(filter); |
110 CleanupStack::Pop(); // filter |
111 CleanupStack::Pop(); // filter |
111 |
112 |
112 filter = CLogFilter::NewL(); |
113 filter = CLogFilter::NewL(); |
118 failCount = 0; |
119 failCount = 0; |
119 finished = EFalse; |
120 finished = EFalse; |
120 |
121 |
121 while(!finished) |
122 while(!finished) |
122 { |
123 { |
123 __FILE_FAILNEXT(++failCount); |
124 TheTest.Printf(_L("%d \r"), failCount); |
|
125 __FILE_FAILNEXT(KErrNoMemory, failCount++); |
124 |
126 |
125 TBool result = EFalse; |
127 TBool result = EFalse; |
126 TRAP(error, result = view->SetFilterL(*list, active->iStatus)); |
128 TRAP(error, result = view->SetFilterL(*list, active->iStatus)); |
127 |
129 |
128 if (error == KErrNone) |
130 if (error == KErrNone) |
139 TEST(view->CountL() >= 1); |
141 TEST(view->CountL() >= 1); |
140 TEST(TestUtils::EventsEqual(*event, view->Event())); |
142 TEST(TestUtils::EventsEqual(*event, view->Event())); |
141 } |
143 } |
142 else |
144 else |
143 { |
145 { |
144 if(active->iStatus.Int() != KErrGeneral) |
146 if(active->iStatus.Int() != KErrNoMemory) |
145 { |
147 { |
146 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
148 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
147 } |
149 } |
148 TEST2(active->iStatus.Int(), KErrGeneral); |
150 TEST2(active->iStatus.Int(), KErrNoMemory); |
149 } |
151 } |
150 } |
152 } |
151 else |
153 else |
152 { |
154 { |
153 if(error != KErrGeneral) |
155 if(error != KErrNoMemory) |
154 { |
156 { |
155 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error); |
157 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error); |
156 } |
158 } |
157 TEST2(error, KErrGeneral); |
159 TEST2(error, KErrNoMemory); |
158 } |
160 } |
159 |
161 |
160 __FILE_RESET; |
162 __FILE_RESET; |
161 } |
163 } |
162 |
164 |
163 list->ResetAndDestroy(); |
165 list->ResetAndDestroy(); |
164 CleanupStack::PopAndDestroy(4); // list, view, event, active |
166 CleanupStack::PopAndDestroy(4); // list, view, event, active |
165 |
167 |
166 TheTest.Printf(_L("Test-2 has succeeded at iteration %d\n"), failCount); |
168 TheTest.Printf(_L("\r\nTest-2 has succeeded at iteration %d\n"), failCount); |
167 } |
169 } |
168 |
170 |
169 /** |
171 /** |
170 @SYMTestCaseID SYSLIB-LOGENG-CT-0972 |
172 @SYMTestCaseID SYSLIB-LOGENG-CT-0972 |
171 @SYMTestCaseDesc Tests CLogViewRecent::SetRecentListL() function |
173 @SYMTestCaseDesc Tests CLogViewRecent::SetRecentListL() function |
204 TBool finished = EFalse; |
206 TBool finished = EFalse; |
205 TInt error; |
207 TInt error; |
206 |
208 |
207 while(!finished) |
209 while(!finished) |
208 { |
210 { |
209 __FILE_FAILNEXT(++failCount); |
211 TheTest.Printf(_L("%d \r"), failCount); |
|
212 __FILE_FAILNEXT(KErrNoMemory, failCount++); |
210 |
213 |
211 TBool result = EFalse; |
214 TBool result = EFalse; |
212 TRAP(error, result = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
215 TRAP(error, result = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
213 |
216 |
214 if (error == KErrNone) |
217 if (error == KErrNone) |
223 finished = ETrue; |
226 finished = ETrue; |
224 TEST(view->CountL() >= 1); |
227 TEST(view->CountL() >= 1); |
225 } |
228 } |
226 else |
229 else |
227 { |
230 { |
228 if(active->iStatus.Int() != KErrGeneral) |
231 if(active->iStatus.Int() != KErrNoMemory) |
229 { |
232 { |
230 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
233 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
231 } |
234 } |
232 TEST2(active->iStatus.Int(), KErrGeneral); |
235 TEST2(active->iStatus.Int(), KErrNoMemory); |
233 } |
236 } |
234 } |
237 } |
235 else |
238 else |
236 { |
239 { |
237 if(error != KErrGeneral) |
240 if(error != KErrNoMemory) |
238 { |
241 { |
239 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error); |
242 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error); |
240 } |
243 } |
241 TEST2(error, KErrGeneral); |
244 TEST2(error, KErrNoMemory); |
242 } |
245 } |
243 |
246 |
244 __FILE_RESET; |
247 __FILE_RESET; |
245 } |
248 } |
246 TheTest.Printf(_L("Test-1 has succeeded at iteration %d\n"), failCount); |
249 TheTest.Printf(_L("\r\nTest-1 has succeeded at iteration %d\n"), failCount); |
247 |
250 |
248 CLogFilterList* list = new(ELeave)CLogFilterList; |
251 CLogFilterList* list = new(ELeave)CLogFilterList; |
249 CleanupStack::PushL(list); |
252 CleanupStack::PushL(list); |
250 |
253 |
251 CLogFilter* filter = CLogFilter::NewL(); |
254 CLogFilter* filter = CLogFilter::NewL(); |
255 failCount = 0; |
258 failCount = 0; |
256 finished = EFalse; |
259 finished = EFalse; |
257 |
260 |
258 while(!finished) |
261 while(!finished) |
259 { |
262 { |
260 __FILE_FAILNEXT(++failCount); |
263 TheTest.Printf(_L("%d \r"), failCount); |
|
264 __FILE_FAILNEXT(KErrNoMemory, failCount++); |
261 |
265 |
262 TBool result = EFalse; |
266 TBool result = EFalse; |
263 TRAP(error, result = view->SetRecentListL(KLogRecentIncomingCalls, *filter, active->iStatus)); |
267 TRAP(error, result = view->SetRecentListL(KLogRecentIncomingCalls, *filter, active->iStatus)); |
264 |
268 |
265 if (error == KErrNone) |
269 if (error == KErrNone) |
274 finished = ETrue; |
278 finished = ETrue; |
275 TEST(view->CountL() >= 1); |
279 TEST(view->CountL() >= 1); |
276 } |
280 } |
277 else |
281 else |
278 { |
282 { |
279 if(active->iStatus.Int() != KErrGeneral) |
283 if(active->iStatus.Int() != KErrNoMemory) |
280 { |
284 { |
281 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
285 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
282 } |
286 } |
283 TEST2(active->iStatus.Int(), KErrGeneral); |
287 TEST2(active->iStatus.Int(), KErrNoMemory); |
284 } |
288 } |
285 } |
289 } |
286 else |
290 else |
287 { |
291 { |
288 if(error != KErrGeneral) |
292 if(error != KErrNoMemory) |
289 { |
293 { |
290 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error); |
294 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error); |
291 } |
295 } |
292 TEST2(error, KErrGeneral); |
296 TEST2(error, KErrNoMemory); |
293 } |
297 } |
294 |
298 |
295 __FILE_RESET; |
299 __FILE_RESET; |
296 } |
300 } |
297 TheTest.Printf(_L("Test-2 has succeeded at iteration %d\n"), failCount); |
301 TheTest.Printf(_L("\r\nTest-2 has succeeded at iteration %d\n"), failCount); |
298 |
302 |
299 list->AppendL(filter); |
303 list->AppendL(filter); |
300 CleanupStack::Pop(); // filter |
304 CleanupStack::Pop(); // filter |
301 |
305 |
302 filter = CLogFilter::NewL(); |
306 filter = CLogFilter::NewL(); |
308 failCount = 0; |
312 failCount = 0; |
309 finished = EFalse; |
313 finished = EFalse; |
310 |
314 |
311 while(!finished) |
315 while(!finished) |
312 { |
316 { |
313 __FILE_FAILNEXT(++failCount); |
317 TheTest.Printf(_L("%d \r"), failCount); |
|
318 __FILE_FAILNEXT(KErrNoMemory, failCount++); |
314 |
319 |
315 TBool result = EFalse; |
320 TBool result = EFalse; |
316 TRAP(error, result = view->SetRecentListL(KLogRecentIncomingCalls, *list, active->iStatus)); |
321 TRAP(error, result = view->SetRecentListL(KLogRecentIncomingCalls, *list, active->iStatus)); |
317 |
322 |
318 if (error == KErrNone) |
323 if (error == KErrNone) |
327 finished = ETrue; |
332 finished = ETrue; |
328 TEST(view->CountL() >= 1); |
333 TEST(view->CountL() >= 1); |
329 } |
334 } |
330 else |
335 else |
331 { |
336 { |
332 if(active->iStatus.Int() != KErrGeneral) |
337 if(active->iStatus.Int() != KErrNoMemory) |
333 { |
338 { |
334 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
339 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
335 } |
340 } |
336 TEST2(active->iStatus.Int(), KErrGeneral); |
341 TEST2(active->iStatus.Int(), KErrNoMemory); |
337 } |
342 } |
338 } |
343 } |
339 else |
344 else |
340 { |
345 { |
341 if(error != KErrGeneral) |
346 if(error != KErrNoMemory) |
342 { |
347 { |
343 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error); |
348 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error); |
344 } |
349 } |
345 TEST2(error, KErrGeneral); |
350 TEST2(error, KErrNoMemory); |
346 } |
351 } |
347 |
352 |
348 __FILE_RESET; |
353 __FILE_RESET; |
349 } |
354 } |
350 |
355 |
351 list->ResetAndDestroy(); |
356 list->ResetAndDestroy(); |
352 CleanupStack::PopAndDestroy(4); // list, view, event, active |
357 CleanupStack::PopAndDestroy(4); // list, view, event, active |
353 |
358 |
354 TheTest.Printf(_L("Test-3 has succeeded at iteration %d\n"), failCount); |
359 TheTest.Printf(_L("\r\nTest-3 has succeeded at iteration %d\n"), failCount); |
355 } |
360 } |
356 |
361 |
357 /** |
362 /** |
358 @SYMTestCaseID SYSLIB-LOGENG-CT-0973 |
363 @SYMTestCaseID SYSLIB-LOGENG-CT-0973 |
359 @SYMTestCaseDesc Tests for CLogViewRecent::DuplicatesL() function |
364 @SYMTestCaseDesc Tests for CLogViewRecent::DuplicatesL() function |
407 TBool finished = EFalse; |
412 TBool finished = EFalse; |
408 TInt error; |
413 TInt error; |
409 |
414 |
410 while(!finished) |
415 while(!finished) |
411 { |
416 { |
412 __FILE_FAILNEXT(++failCount); |
417 TheTest.Printf(_L("%d \r"), failCount); |
|
418 __FILE_FAILNEXT(KErrNoMemory, failCount++); |
413 |
419 |
414 TBool result = EFalse; |
420 TBool result = EFalse; |
415 TRAP(error, result = view->DuplicatesL(*duplicate, active->iStatus)); |
421 TRAP(error, result = view->DuplicatesL(*duplicate, active->iStatus)); |
416 |
422 |
417 if (error == KErrNone) |
423 if (error == KErrNone) |
426 finished = ETrue; |
432 finished = ETrue; |
427 TEST(duplicate->CountL() >= 1); |
433 TEST(duplicate->CountL() >= 1); |
428 } |
434 } |
429 else |
435 else |
430 { |
436 { |
431 if(active->iStatus.Int() != KErrGeneral) |
437 if(active->iStatus.Int() != KErrNoMemory) |
432 { |
438 { |
433 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
439 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
434 } |
440 } |
435 TEST2(active->iStatus.Int(), KErrGeneral); |
441 TEST2(active->iStatus.Int(), KErrNoMemory); |
436 } |
442 } |
437 } |
443 } |
438 else |
444 else |
439 { |
445 { |
440 if(error != KErrGeneral) |
446 if(error != KErrNoMemory) |
441 { |
447 { |
442 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error); |
448 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error); |
443 } |
449 } |
444 TEST2(error, KErrGeneral); |
450 TEST2(error, KErrNoMemory); |
445 } |
451 } |
446 |
452 |
447 __FILE_RESET; |
453 __FILE_RESET; |
448 } |
454 } |
449 TheTest.Printf(_L("Test-1 has succeeded at iteration %d\n"), failCount); |
455 TheTest.Printf(_L("\r\nTest-1 has succeeded at iteration %d\n"), failCount); |
450 |
456 |
451 CLogFilterList* list = new(ELeave)CLogFilterList; |
457 CLogFilterList* list = new(ELeave)CLogFilterList; |
452 CleanupStack::PushL(list); |
458 CleanupStack::PushL(list); |
453 |
459 |
454 CLogFilter* filter = CLogFilter::NewL(); |
460 CLogFilter* filter = CLogFilter::NewL(); |
458 failCount = 0; |
464 failCount = 0; |
459 finished = EFalse; |
465 finished = EFalse; |
460 |
466 |
461 while(!finished) |
467 while(!finished) |
462 { |
468 { |
463 __FILE_FAILNEXT(++failCount); |
469 TheTest.Printf(_L("%d \r"), failCount); |
|
470 __FILE_FAILNEXT(KErrNoMemory, failCount++); |
464 |
471 |
465 TBool result = EFalse; |
472 TBool result = EFalse; |
466 TRAP(error, result = view->DuplicatesL(*duplicate, *filter, active->iStatus)); |
473 TRAP(error, result = view->DuplicatesL(*duplicate, *filter, active->iStatus)); |
467 |
474 |
468 if (error == KErrNone) |
475 if (error == KErrNone) |
477 finished = ETrue; |
484 finished = ETrue; |
478 TEST(duplicate->CountL() >= 1); |
485 TEST(duplicate->CountL() >= 1); |
479 } |
486 } |
480 else |
487 else |
481 { |
488 { |
482 if(active->iStatus.Int() != KErrGeneral) |
489 if(active->iStatus.Int() != KErrNoMemory) |
483 { |
490 { |
484 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
491 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
485 } |
492 } |
486 TEST2(active->iStatus.Int(), KErrGeneral); |
493 TEST2(active->iStatus.Int(), KErrNoMemory); |
487 } |
494 } |
488 } |
495 } |
489 else |
496 else |
490 { |
497 { |
491 if(error != KErrGeneral) |
498 if(error != KErrNoMemory) |
492 { |
499 { |
493 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error); |
500 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error); |
494 } |
501 } |
495 TEST2(error, KErrGeneral); |
502 TEST2(error, KErrNoMemory); |
496 } |
503 } |
497 |
504 |
498 __FILE_RESET; |
505 __FILE_RESET; |
499 } |
506 } |
500 TheTest.Printf(_L("Test-2 has succeeded at iteration %d\n"), failCount); |
507 TheTest.Printf(_L("\r\nTest-2 has succeeded at iteration %d\n"), failCount); |
501 |
508 |
502 list->AppendL(filter); |
509 list->AppendL(filter); |
503 CleanupStack::Pop(); // filter |
510 CleanupStack::Pop(); // filter |
504 |
511 |
505 filter = CLogFilter::NewL(); |
512 filter = CLogFilter::NewL(); |
511 failCount = 0; |
518 failCount = 0; |
512 finished = EFalse; |
519 finished = EFalse; |
513 |
520 |
514 while(!finished) |
521 while(!finished) |
515 { |
522 { |
516 __FILE_FAILNEXT(++failCount); |
523 TheTest.Printf(_L("%d \r"), failCount); |
|
524 __FILE_FAILNEXT(KErrNoMemory, failCount++); |
517 |
525 |
518 TBool result = EFalse; |
526 TBool result = EFalse; |
519 TRAP(error, result = view->DuplicatesL(*duplicate, *list, active->iStatus)); |
527 TRAP(error, result = view->DuplicatesL(*duplicate, *list, active->iStatus)); |
520 |
528 |
521 if (error == KErrNone) |
529 if (error == KErrNone) |
530 finished = ETrue; |
538 finished = ETrue; |
531 TEST(duplicate->CountL() >= 1); |
539 TEST(duplicate->CountL() >= 1); |
532 } |
540 } |
533 else |
541 else |
534 { |
542 { |
535 if(active->iStatus.Int() != KErrGeneral) |
543 if(active->iStatus.Int() != KErrNoMemory) |
536 { |
544 { |
537 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
545 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
538 } |
546 } |
539 TEST2(active->iStatus.Int(), KErrGeneral); |
547 TEST2(active->iStatus.Int(), KErrNoMemory); |
540 } |
548 } |
541 } |
549 } |
542 else |
550 else |
543 { |
551 { |
544 if(error != KErrGeneral) |
552 if(error != KErrNoMemory) |
545 { |
553 { |
546 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error); |
554 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error); |
547 } |
555 } |
548 TEST2(error, KErrGeneral); |
556 TEST2(error, KErrNoMemory); |
549 } |
557 } |
550 |
558 |
551 __FILE_RESET; |
559 __FILE_RESET; |
552 } |
560 } |
553 |
561 |
554 list->ResetAndDestroy(); |
562 list->ResetAndDestroy(); |
555 CleanupStack::PopAndDestroy(5); // list, duplicate, view, event, active |
563 CleanupStack::PopAndDestroy(5); // list, duplicate, view, event, active |
556 |
564 |
557 TheTest.Printf(_L("Test-3 has succeeded at iteration %d\n"), failCount); |
565 TheTest.Printf(_L("\r\nTest-3 has succeeded at iteration %d\n"), failCount); |
558 } |
566 } |
559 |
567 |
560 /** |
568 /** |
561 @SYMTestCaseID SYSLIB-LOGENG-CT-0974 |
569 @SYMTestCaseID SYSLIB-LOGENG-CT-0974 |
562 @SYMTestCaseDesc Tests for CLogViewEvent::NextL(),CLogViewEvent::LastL(),CLogViewEvent::PreviousL(), |
570 @SYMTestCaseDesc Tests for CLogViewEvent::NextL(),CLogViewEvent::LastL(),CLogViewEvent::PreviousL(), |
599 CActiveScheduler::Start(); |
607 CActiveScheduler::Start(); |
600 TEST2(active->iStatus.Int(), KErrNone); |
608 TEST2(active->iStatus.Int(), KErrNone); |
601 TEST(view->CountL() > 1); |
609 TEST(view->CountL() > 1); |
602 event->CopyL(view->Event()); |
610 event->CopyL(view->Event()); |
603 |
611 |
604 __FILE_FAILNEXT(++failCount); |
612 TheTest.Printf(_L("%d \r"), failCount); |
|
613 __FILE_FAILNEXT(KErrNoMemory, failCount++); |
605 |
614 |
606 TBool result = EFalse; |
615 TBool result = EFalse; |
607 TRAP(error, result = view->NextL(active->iStatus)); |
616 TRAP(error, result = view->NextL(active->iStatus)); |
608 |
617 |
609 if (error == KErrNone) |
618 if (error == KErrNone) |
618 finished = ETrue; |
627 finished = ETrue; |
619 TEST(!TestUtils::EventsEqual(*event, view->Event())); |
628 TEST(!TestUtils::EventsEqual(*event, view->Event())); |
620 } |
629 } |
621 else |
630 else |
622 { |
631 { |
623 if(active->iStatus.Int() != KErrGeneral) |
632 if(active->iStatus.Int() != KErrNoMemory) |
624 { |
633 { |
625 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
634 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
626 } |
635 } |
627 TEST2(active->iStatus.Int(), KErrGeneral); |
636 TEST2(active->iStatus.Int(), KErrNoMemory); |
628 } |
637 } |
629 } |
638 } |
630 else |
639 else |
631 { |
640 { |
632 if(error != KErrGeneral) |
641 if(error != KErrNoMemory) |
633 { |
642 { |
634 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error); |
643 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error); |
635 } |
644 } |
636 TEST2(error, KErrGeneral); |
645 TEST2(error, KErrNoMemory); |
637 } |
646 } |
638 |
647 |
639 __FILE_RESET; |
648 __FILE_RESET; |
640 } |
649 } |
641 TheTest.Printf(_L("Test-1 (\"View Next\") has succeeded at iteration %d\n"), failCount); |
650 TheTest.Printf(_L("\r\nTest-1 (\"View Next\") has succeeded at iteration %d\n"), failCount); |
642 |
651 |
643 failCount = 0; |
652 failCount = 0; |
644 finished = EFalse; |
653 finished = EFalse; |
645 |
654 |
646 while(!finished) |
655 while(!finished) |
656 CActiveScheduler::Start(); |
665 CActiveScheduler::Start(); |
657 TEST2(active->iStatus.Int(), KErrNone); |
666 TEST2(active->iStatus.Int(), KErrNone); |
658 |
667 |
659 event->CopyL(view->Event()); |
668 event->CopyL(view->Event()); |
660 |
669 |
661 __FILE_FAILNEXT(++failCount); |
670 TheTest.Printf(_L("%d \r"), failCount); |
|
671 __FILE_FAILNEXT(KErrNoMemory, failCount++); |
662 |
672 |
663 TBool result = EFalse; |
673 TBool result = EFalse; |
664 TRAP(error, result = view->PreviousL(active->iStatus)); |
674 TRAP(error, result = view->PreviousL(active->iStatus)); |
665 |
675 |
666 if (error == KErrNone) |
676 if (error == KErrNone) |
675 finished = ETrue; |
685 finished = ETrue; |
676 TEST(!TestUtils::EventsEqual(*event, view->Event())); |
686 TEST(!TestUtils::EventsEqual(*event, view->Event())); |
677 } |
687 } |
678 else |
688 else |
679 { |
689 { |
680 if(active->iStatus.Int() != KErrGeneral) |
690 if(active->iStatus.Int() != KErrNoMemory) |
681 { |
691 { |
682 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
692 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
683 } |
693 } |
684 TEST2(active->iStatus.Int(), KErrGeneral); |
694 TEST2(active->iStatus.Int(), KErrNoMemory); |
685 } |
695 } |
686 } |
696 } |
687 else |
697 else |
688 { |
698 { |
689 if(error != KErrGeneral) |
699 if(error != KErrNoMemory) |
690 { |
700 { |
691 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error); |
701 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error); |
692 } |
702 } |
693 TEST2(error, KErrGeneral); |
703 TEST2(error, KErrNoMemory); |
694 } |
704 } |
695 |
705 |
696 __FILE_RESET; |
706 __FILE_RESET; |
697 } |
707 } |
698 TheTest.Printf(_L("Test-2 (\"View Previous\") has succeeded at iteration %d\n"), failCount); |
708 TheTest.Printf(_L("\r\nTest-2 (\"View Previous\") has succeeded at iteration %d\n"), failCount); |
699 |
709 |
700 failCount = 0; |
710 failCount = 0; |
701 finished = EFalse; |
711 finished = EFalse; |
702 |
712 |
703 while(!finished) |
713 while(!finished) |
713 CActiveScheduler::Start(); |
723 CActiveScheduler::Start(); |
714 TEST2(active->iStatus.Int(), KErrNone); |
724 TEST2(active->iStatus.Int(), KErrNone); |
715 |
725 |
716 event->CopyL(view->Event()); |
726 event->CopyL(view->Event()); |
717 |
727 |
718 __FILE_FAILNEXT(++failCount); |
728 TheTest.Printf(_L("%d \r"), failCount); |
|
729 __FILE_FAILNEXT(KErrNoMemory, failCount++); |
719 |
730 |
720 TBool result = EFalse; |
731 TBool result = EFalse; |
721 TRAP(error, result = view->FirstL(active->iStatus)); |
732 TRAP(error, result = view->FirstL(active->iStatus)); |
722 |
733 |
723 if (error == KErrNone) |
734 if (error == KErrNone) |
732 finished = ETrue; |
743 finished = ETrue; |
733 TEST(!TestUtils::EventsEqual(*event, view->Event())); |
744 TEST(!TestUtils::EventsEqual(*event, view->Event())); |
734 } |
745 } |
735 else |
746 else |
736 { |
747 { |
737 if(active->iStatus.Int() != KErrGeneral) |
748 if(active->iStatus.Int() != KErrNoMemory) |
738 { |
749 { |
739 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
750 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
740 } |
751 } |
741 TEST2(active->iStatus.Int(), KErrGeneral); |
752 TEST2(active->iStatus.Int(), KErrNoMemory); |
742 } |
753 } |
743 } |
754 } |
744 else |
755 else |
745 { |
756 { |
746 if(error != KErrGeneral) |
757 if(error != KErrNoMemory) |
747 { |
758 { |
748 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error); |
759 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error); |
749 } |
760 } |
750 TEST2(error, KErrGeneral); |
761 TEST2(error, KErrNoMemory); |
751 } |
762 } |
752 |
763 |
753 __FILE_RESET; |
764 __FILE_RESET; |
754 } |
765 } |
755 TheTest.Printf(_L("Test-3 (\"View First\") has succeeded at iteration %d\n"), failCount); |
766 TheTest.Printf(_L("\r\nTest-3 (\"View First\") has succeeded at iteration %d\n"), failCount); |
756 |
767 |
757 failCount = 0; |
768 failCount = 0; |
758 finished = EFalse; |
769 finished = EFalse; |
759 |
770 |
760 while(!finished) |
771 while(!finished) |
770 CActiveScheduler::Start(); |
781 CActiveScheduler::Start(); |
771 TEST2(active->iStatus.Int(), KErrNone); |
782 TEST2(active->iStatus.Int(), KErrNone); |
772 |
783 |
773 event->CopyL(view->Event()); |
784 event->CopyL(view->Event()); |
774 |
785 |
775 __FILE_FAILNEXT(++failCount); |
786 TheTest.Printf(_L("%d \r"), failCount); |
|
787 __FILE_FAILNEXT(KErrNoMemory, failCount++); |
776 |
788 |
777 TBool result = EFalse; |
789 TBool result = EFalse; |
778 TRAP(error, result = view->LastL(active->iStatus)); |
790 TRAP(error, result = view->LastL(active->iStatus)); |
779 |
791 |
780 if (error == KErrNone) |
792 if (error == KErrNone) |
789 finished = ETrue; |
801 finished = ETrue; |
790 TEST(!TestUtils::EventsEqual(*event, view->Event())); |
802 TEST(!TestUtils::EventsEqual(*event, view->Event())); |
791 } |
803 } |
792 else |
804 else |
793 { |
805 { |
794 if(active->iStatus.Int() != KErrGeneral) |
806 if(active->iStatus.Int() != KErrNoMemory) |
795 { |
807 { |
796 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
808 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
797 } |
809 } |
798 TEST2(active->iStatus.Int(), KErrGeneral); |
810 TEST2(active->iStatus.Int(), KErrNoMemory); |
799 } |
811 } |
800 } |
812 } |
801 else |
813 else |
802 { |
814 { |
803 if(error != KErrGeneral) |
815 if(error != KErrNoMemory) |
804 { |
816 { |
805 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error); |
817 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error); |
806 } |
818 } |
807 TEST2(error, KErrGeneral); |
819 TEST2(error, KErrNoMemory); |
808 } |
820 } |
809 |
821 |
810 __FILE_RESET; |
822 __FILE_RESET; |
811 } |
823 } |
812 |
824 |
813 CleanupStack::PopAndDestroy(4); // filter, view, event, active |
825 CleanupStack::PopAndDestroy(4); // filter, view, event, active |
814 |
826 |
815 TheTest.Printf(_L("Test-4 (\"View Last\") has succeeded at iteration %d\n"), failCount); |
827 TheTest.Printf(_L("\r\nTest-4 (\"View Last\") has succeeded at iteration %d\n"), failCount); |
816 } |
828 } |
817 |
829 |
818 /** |
830 /** |
819 @SYMTestCaseID SYSLIB-LOGENG-CT-0975 |
831 @SYMTestCaseID SYSLIB-LOGENG-CT-0975 |
820 @SYMTestCaseDesc Tests for CLogViewEvent::CountL() functions |
832 @SYMTestCaseDesc Tests for CLogViewEvent::CountL() functions |
866 finished = ETrue; |
879 finished = ETrue; |
867 TEST(result > 0); |
880 TEST(result > 0); |
868 } |
881 } |
869 else |
882 else |
870 { |
883 { |
871 if(error != KErrGeneral) |
884 if(error != KErrNoMemory) |
872 { |
885 { |
873 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error); |
886 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error); |
874 } |
887 } |
875 TEST2(error, KErrGeneral); |
888 TEST2(error, KErrNoMemory); |
876 } |
889 } |
877 |
890 |
878 __FILE_RESET; |
891 __FILE_RESET; |
879 } |
892 } |
880 |
893 |
881 CleanupStack::PopAndDestroy(4); // filter, view, event, active |
894 CleanupStack::PopAndDestroy(4); // filter, view, event, active |
882 |
895 |
883 TheTest.Printf(_L("The test (\"View Count\") has succeeded at iteration %d\n"), failCount); |
896 TheTest.Printf(_L("\r\nThe test (\"View Count\") has succeeded at iteration %d\n"), failCount); |
884 } |
897 } |
885 |
898 |
886 /** |
899 /** |
887 @SYMTestCaseID SYSLIB-LOGENG-CT-0976 |
900 @SYMTestCaseID SYSLIB-LOGENG-CT-0976 |
888 @SYMTestCaseDesc Tests for CLogViewRecent::RemoveL() function |
901 @SYMTestCaseDesc Tests for CLogViewRecent::RemoveL() function |
941 TBool finished = EFalse; |
954 TBool finished = EFalse; |
942 TInt error; |
955 TInt error; |
943 |
956 |
944 while(!finished) |
957 while(!finished) |
945 { |
958 { |
|
959 TheTest.Printf(_L("%d \r"), failCount); |
|
960 __FILE_FAILNEXT(KErrNoMemory, failCount++); |
|
961 |
|
962 TRAP(error, view->RemoveL(view->Event().Id())); |
|
963 |
|
964 __FILE_RESET; |
|
965 |
|
966 if (error == KErrNone) |
|
967 { |
|
968 finished = ETrue; |
|
969 |
|
970 TEST(view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
|
971 active->StartL(); |
|
972 CActiveScheduler::Start(); |
|
973 if(active->iStatus.Int() != KErrNone) |
|
974 { |
|
975 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
|
976 } |
|
977 TEST2(active->iStatus.Int(), KErrNone); |
|
978 |
|
979 TEST(count == view->CountL() + 1); |
|
980 } |
|
981 else |
|
982 { |
|
983 if(error != KErrNoMemory) |
|
984 { |
|
985 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error); |
|
986 } |
|
987 TEST2(error, KErrNoMemory); |
|
988 } |
946 // This failCount value causes DBMS to return KErrCorrupt. Apparently this |
989 // This failCount value causes DBMS to return KErrCorrupt. Apparently this |
947 // can't actually occur in real life, so we skip this value. |
990 // can't actually occur in real life, so we skip this value. |
948 if (failCount == 9) |
991 if (failCount > 9) |
949 { |
|
950 failCount++; |
|
951 } |
|
952 __FILE_FAILNEXT(++failCount); |
|
953 |
|
954 TRAP(error, view->RemoveL(view->Event().Id())); |
|
955 |
|
956 __FILE_RESET; |
|
957 |
|
958 if (error == KErrNone) |
|
959 { |
992 { |
960 finished = ETrue; |
993 finished = ETrue; |
961 |
994 TRAP(error, view->RemoveL(view->Event().Id())); |
962 TEST(view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
995 TEST2(error, KErrNone); |
963 active->StartL(); |
|
964 CActiveScheduler::Start(); |
|
965 if(active->iStatus.Int() != KErrNone) |
|
966 { |
|
967 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
|
968 } |
|
969 TEST2(active->iStatus.Int(), KErrNone); |
|
970 |
|
971 TEST(count == view->CountL() + 1); |
|
972 } |
|
973 else |
|
974 { |
|
975 if(error != KErrGeneral) |
|
976 { |
|
977 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error); |
|
978 } |
|
979 TEST2(error, KErrGeneral); |
|
980 } |
996 } |
981 } |
997 } |
982 CleanupStack::PopAndDestroy(3); // view, event, active |
998 CleanupStack::PopAndDestroy(3); // view, event, active |
983 |
999 |
984 TheTest.Printf(_L("The test (\"View Remove\") has succeeded at iteration %d\n"), failCount); |
1000 TheTest.Printf(_L("\r\nThe test (\"View Remove\") has succeeded at iteration %d\n"), failCount); |
985 } |
1001 } |
986 |
1002 |
987 /** |
1003 /** |
988 @SYMTestCaseID SYSLIB-LOGENG-CT-0977 |
1004 @SYMTestCaseID SYSLIB-LOGENG-CT-0977 |
989 @SYMTestCaseDesc Tests for CLogViewDuplicate::RemoveL() function |
1005 @SYMTestCaseDesc Tests for CLogViewDuplicate::RemoveL() function |
1074 TEST(view->DuplicatesL(*duplicate, active->iStatus)); |
1091 TEST(view->DuplicatesL(*duplicate, active->iStatus)); |
1075 active->StartL(); |
1092 active->StartL(); |
1076 CActiveScheduler::Start(); |
1093 CActiveScheduler::Start(); |
1077 if(active->iStatus.Int() != KErrNone) |
1094 if(active->iStatus.Int() != KErrNone) |
1078 { |
1095 { |
1079 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
1096 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, active->iStatus.Int()); |
1080 } |
1097 } |
1081 TEST2(active->iStatus.Int(), KErrNone); |
1098 TEST2(active->iStatus.Int(), KErrNone); |
1082 |
1099 |
1083 TEST(count == duplicate->CountL() + 1); |
1100 TEST(count == duplicate->CountL() + 1); |
1084 } |
1101 } |
1085 else |
1102 else |
1086 { |
1103 { |
1087 if(error != KErrGeneral) |
1104 if(error != KErrNoMemory) |
1088 { |
1105 { |
1089 TheTest.Printf(_L("Iter.step: %d, error %d\n"), failCount, error); |
1106 TheTest.Printf(_L("\r\nIter.step: %d, error %d\n"), failCount, error); |
1090 } |
1107 } |
1091 TEST2(error, KErrGeneral); |
1108 TEST2(error, KErrNoMemory); |
1092 } |
1109 } |
1093 } |
1110 } |
1094 CleanupStack::PopAndDestroy(4); // duplicate, view, event, active |
1111 CleanupStack::PopAndDestroy(4); // duplicate, view, event, active |
1095 |
1112 |
1096 TheTest.Printf(_L("The test (\"View Remove Duplicates\") has succeeded at iteration %d\n"), failCount); |
1113 TheTest.Printf(_L("\r\nThe test (\"View Remove Duplicates\") has succeeded at iteration %d\n"), failCount); |
1097 } |
1114 } |
1098 |
1115 |
1099 void doTestsL() |
1116 void doTestsL() |
1100 { |
1117 { |
1101 TestUtils::Initialize(_L("t_logviewfail2")); |
1118 TestUtils::Initialize(_L("t_logviewfail2")); |