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