| branch | RCL_3 |
| changeset 9 | 667e88a979d7 |
| parent 6 | 5ffdb8f2067f |
| 8:fa9941cf3867 | 9:667e88a979d7 |
|---|---|
1 // Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies). |
1 // Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies). |
2 // All rights reserved. |
2 // All rights reserved. |
3 // This component and the accompanying materials are made available |
3 // This component and the accompanying materials are made available |
4 // under the terms of "Eclipse Public License v1.0" |
4 // under the terms of "Eclipse Public License v1.0" |
5 // which accompanies this distribution, and is available |
5 // which accompanies this distribution, and is available |
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
20 // |
20 // |
21 |
21 |
22 #include <s32file.h> |
22 #include <s32file.h> |
23 #include <s32mem.h> |
23 #include <s32mem.h> |
24 #include <e32math.h> |
24 #include <e32math.h> |
25 |
25 #include "t_logutil2.h" |
26 #include "TEST.H" |
|
27 #include <logview.h> |
26 #include <logview.h> |
28 |
27 |
29 #undef test //there is a "test" macro which hides "RTest test" declaration. |
|
30 |
|
31 #define UNUSED_VAR(a) a = a |
28 #define UNUSED_VAR(a) a = a |
32 |
29 |
33 RTest test(_L("Log View Test Harness Number 1")); |
30 RTest TheTest(_L("t_logview1")); |
34 |
31 |
35 const TInt KTestLogNumberCharsToMatch = 9; // should be the same as KLogNumberCharsToMatch defined in LogServ\src\LOGFILTQ.CPP |
32 const TInt KTestLogNumberCharsToMatch = 9; // should be the same as KLogNumberCharsToMatch defined in LogServ\src\LOGFILTQ.CPP |
36 const TInt KTestEventNum = 10; |
33 const TInt KTestEventNum = 10; |
37 const TUid KTestEventUid = {0x10005393}; |
34 const TUid KTestEventUid = {0x10005393}; |
38 const TLogDurationType KTestDurationType = 0x12; |
35 const TLogDurationType KTestDurationType = 0x12; |
105 @SYMTestExpectedResults Test must not fail |
102 @SYMTestExpectedResults Test must not fail |
106 @SYMREQ REQ0000 |
103 @SYMREQ REQ0000 |
107 */ |
104 */ |
108 LOCAL_C void TestEventViewL(CLogClient& aClient) |
105 LOCAL_C void TestEventViewL(CLogClient& aClient) |
109 { |
106 { |
110 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0851 ")); |
107 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0851 ")); |
111 CLogEvent* event = CLogEvent::NewL(); |
108 CLogEvent* event = CLogEvent::NewL(); |
112 CleanupStack::PushL(event); |
109 CleanupStack::PushL(event); |
113 event->SetEventType(KLogCallEventTypeUid); |
110 event->SetEventType(KLogCallEventTypeUid); |
114 |
111 |
115 CTestActive* active = new(ELeave)CTestActive(); |
112 CTestActive* active = new(ELeave)CTestActive(); |
163 |
160 |
164 TEST2(view->CountL(), KTestEventNum); |
161 TEST2(view->CountL(), KTestEventNum); |
165 TLogId id = ++count; |
162 TLogId id = ++count; |
166 TEST2(view->Event().Id(), id); |
163 TEST2(view->Event().Id(), id); |
167 } |
164 } |
168 TEST(count == KTestEventNum - 1); |
165 TEST2(count, KTestEventNum - 1); |
169 |
166 |
170 active->StartL(); |
167 active->StartL(); |
171 res = view->FirstL(active->iStatus); |
168 res = view->FirstL(active->iStatus); |
172 TEST(res); |
169 TEST(res); |
173 CActiveScheduler::Start(); |
170 CActiveScheduler::Start(); |
222 @SYMTestExpectedResults Test must not fail |
219 @SYMTestExpectedResults Test must not fail |
223 @SYMREQ REQ0000 |
220 @SYMREQ REQ0000 |
224 */ |
221 */ |
225 LOCAL_C void TestViewFilterL(CLogClient& aClient, CLogFilter& aFilter) |
222 LOCAL_C void TestViewFilterL(CLogClient& aClient, CLogFilter& aFilter) |
226 { |
223 { |
227 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0852 ")); |
224 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0852 ")); |
228 CLogViewEvent* view = CLogViewEvent::NewL(aClient); |
225 CLogViewEvent* view = CLogViewEvent::NewL(aClient); |
229 CleanupStack::PushL(view); |
226 CleanupStack::PushL(view); |
230 |
227 |
231 CLogEvent* event = CLogEvent::NewL(); |
228 CLogEvent* event = CLogEvent::NewL(); |
232 CleanupStack::PushL(event); |
229 CleanupStack::PushL(event); |
260 TEST(res); |
257 TEST(res); |
261 active->StartL(); |
258 active->StartL(); |
262 CActiveScheduler::Start(); |
259 CActiveScheduler::Start(); |
263 TEST2(active->iStatus.Int(), KErrNone); |
260 TEST2(active->iStatus.Int(), KErrNone); |
264 |
261 |
265 TEST(view->CountL() == total + 1); |
262 TEST2(view->CountL(), total + 1); |
266 |
263 |
267 TEST(event->EventType() == KTestEventUid); |
264 TEST2(event->EventType().iUid, KTestEventUid.iUid); |
268 TEST(event->RemoteParty() == aFilter.RemoteParty()); |
265 TEST(event->RemoteParty() == aFilter.RemoteParty()); |
269 TEST(event->Direction() == aFilter.Direction()); |
266 TEST(event->Direction() == aFilter.Direction()); |
270 TEST(event->DurationType() == aFilter.DurationType()); |
267 TEST2(event->DurationType(), aFilter.DurationType()); |
271 TEST(event->Status() == aFilter.Status()); |
268 TEST(event->Status() == aFilter.Status()); |
272 TEST(event->Contact() == aFilter.Contact()); |
269 TEST2(event->Contact(), aFilter.Contact()); |
273 TEST(event->Number() == aFilter.Number()); |
270 TEST(event->Number() == aFilter.Number()); |
274 |
271 |
275 TTime now; |
272 TTime now; |
276 now.UniversalTime(); |
273 now.UniversalTime(); |
277 |
274 |
287 TEST2(active->iStatus.Int(), KErrNone); |
284 TEST2(active->iStatus.Int(), KErrNone); |
288 |
285 |
289 TEST(now >= event->Time()); |
286 TEST(now >= event->Time()); |
290 |
287 |
291 if (aFilter.EventType() != KNullUid) |
288 if (aFilter.EventType() != KNullUid) |
292 TEST(event->EventType() == aFilter.EventType()); |
289 TEST2(event->EventType().iUid, aFilter.EventType().iUid); |
293 |
290 |
294 if (aFilter.RemoteParty().Length() > 0) |
291 if (aFilter.RemoteParty().Length() > 0) |
295 TEST(event->RemoteParty() == aFilter.RemoteParty()); |
292 TEST(event->RemoteParty() == aFilter.RemoteParty()); |
296 |
293 |
297 if (aFilter.Direction().Length() > 0) |
294 if (aFilter.Direction().Length() > 0) |
298 TEST(event->Direction() == aFilter.Direction()); |
295 TEST(event->Direction() == aFilter.Direction()); |
299 |
296 |
300 if (aFilter.DurationType() != KLogNullDurationType) |
297 if (aFilter.DurationType() != KLogNullDurationType) |
301 TEST(event->DurationType() == aFilter.DurationType()); |
298 TEST2(event->DurationType(), aFilter.DurationType()); |
302 |
299 |
303 if (aFilter.Status().Length() > 0) |
300 if (aFilter.Status().Length() > 0) |
304 TEST(event->Status() == aFilter.Status()); |
301 TEST(event->Status() == aFilter.Status()); |
305 |
302 |
306 if (aFilter.Contact() > KLogNullContactId) |
303 if (aFilter.Contact() > KLogNullContactId) |
307 TEST(event->Contact() == aFilter.Contact()); |
304 TEST2(event->Contact(), aFilter.Contact()); |
308 |
305 |
309 if (aFilter.Number().Length() > 0) |
306 if (aFilter.Number().Length() > 0) |
310 TEST(event->Number() == aFilter.Number()); |
307 TEST(event->Number() == aFilter.Number()); |
311 } |
308 } |
312 |
309 |
313 TEST(count == total + 1); |
310 TEST2(count, total + 1); |
314 |
311 |
315 CleanupStack::PopAndDestroy(3); // active, event, view; |
312 CleanupStack::PopAndDestroy(3); // active, event, view; |
316 } |
313 } |
317 |
314 |
318 /** |
315 /** |
323 @SYMTestExpectedResults Test must not fail |
320 @SYMTestExpectedResults Test must not fail |
324 @SYMREQ REQ0000 |
321 @SYMREQ REQ0000 |
325 */ |
322 */ |
326 LOCAL_C void TestEventViewFilter1L(CLogClient& aClient) |
323 LOCAL_C void TestEventViewFilter1L(CLogClient& aClient) |
327 { |
324 { |
328 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0853 ")); |
325 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0853 ")); |
329 CTestActive* active = new(ELeave)CTestActive(); |
326 CTestActive* active = new(ELeave)CTestActive(); |
330 CleanupStack::PushL(active); |
327 CleanupStack::PushL(active); |
331 |
328 |
332 // Create a test event type |
329 // Create a test event type |
333 CLogEventType* type = CLogEventType::NewL(); |
330 CLogEventType* type = CLogEventType::NewL(); |
531 @SYMTestExpectedResults Test must not fail |
528 @SYMTestExpectedResults Test must not fail |
532 @SYMREQ REQ0000 |
529 @SYMREQ REQ0000 |
533 */ |
530 */ |
534 LOCAL_C void TestEventViewFilter2L(CLogClient& aClient) |
531 LOCAL_C void TestEventViewFilter2L(CLogClient& aClient) |
535 { |
532 { |
536 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0854 ")); |
533 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0854 ")); |
537 CTestActive* active = new(ELeave)CTestActive(); |
534 CTestActive* active = new(ELeave)CTestActive(); |
538 CleanupStack::PushL(active); |
535 CleanupStack::PushL(active); |
539 |
536 |
540 CLogViewEvent* view = CLogViewEvent::NewL(aClient); |
537 CLogViewEvent* view = CLogViewEvent::NewL(aClient); |
541 CleanupStack::PushL(view); |
538 CleanupStack::PushL(view); |
678 TEST(res); |
675 TEST(res); |
679 CActiveScheduler::Start(); |
676 CActiveScheduler::Start(); |
680 TEST2(active->iStatus.Int(), KErrNone); |
677 TEST2(active->iStatus.Int(), KErrNone); |
681 |
678 |
682 // Check the count is correct |
679 // Check the count is correct |
683 TEST(view->CountL() == total + 4); |
680 TEST2(view->CountL(), total + 4); |
684 |
681 |
685 filter->SetEventType(KLogCallEventTypeUid); |
682 filter->SetEventType(KLogCallEventTypeUid); |
686 |
683 |
687 // Get view of call events |
684 // Get view of call events |
688 active->StartL(); |
685 active->StartL(); |
689 res = view->SetFilterL(*filter, active->iStatus); |
686 res = view->SetFilterL(*filter, active->iStatus); |
690 TEST(res); |
687 TEST(res); |
691 CActiveScheduler::Start(); |
688 CActiveScheduler::Start(); |
692 TEST2(active->iStatus.Int(), KErrNone); |
689 TEST2(active->iStatus.Int(), KErrNone); |
693 |
690 |
694 TEST(view->CountL() == calls + 2); |
691 TEST2(view->CountL(), calls + 2); |
695 |
692 |
696 filter->SetEventType(KLogDataEventTypeUid); |
693 filter->SetEventType(KLogDataEventTypeUid); |
697 |
694 |
698 // Get view of data events |
695 // Get view of data events |
699 active->StartL(); |
696 active->StartL(); |
700 res = view->SetFilterL(*filter, active->iStatus); |
697 res = view->SetFilterL(*filter, active->iStatus); |
701 TEST(res); |
698 TEST(res); |
702 CActiveScheduler::Start(); |
699 CActiveScheduler::Start(); |
703 TEST2(active->iStatus.Int(), KErrNone); |
700 TEST2(active->iStatus.Int(), KErrNone); |
704 |
701 |
705 TEST(view->CountL() == data + 2); |
702 TEST2(view->CountL(), data + 2); |
706 |
703 |
707 filter->SetEventType(KLogFaxEventTypeUid); |
704 filter->SetEventType(KLogFaxEventTypeUid); |
708 |
705 |
709 // Get view of fax events |
706 // Get view of fax events |
710 if (view->SetFilterL(*filter, active->iStatus)) |
707 if (view->SetFilterL(*filter, active->iStatus)) |
787 @SYMTestExpectedResults Test must not fail |
784 @SYMTestExpectedResults Test must not fail |
788 @SYMREQ REQ0000 |
785 @SYMREQ REQ0000 |
789 */ |
786 */ |
790 LOCAL_C void TestRecentView1L(CLogClient& aClient) |
787 LOCAL_C void TestRecentView1L(CLogClient& aClient) |
791 { |
788 { |
792 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0855 ")); |
789 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0855 ")); |
793 CLogEvent* event = CLogEvent::NewL(); |
790 CLogEvent* event = CLogEvent::NewL(); |
794 CleanupStack::PushL(event); |
791 CleanupStack::PushL(event); |
795 |
792 |
796 CTestActive* active = new(ELeave)CTestActive(); |
793 CTestActive* active = new(ELeave)CTestActive(); |
797 CleanupStack::PushL(active); |
794 CleanupStack::PushL(active); |
845 |
842 |
846 TEST2(view->CountL(), KTestEventNum); |
843 TEST2(view->CountL(), KTestEventNum); |
847 TEST2(view->RecentList(), KLogRecentIncomingCalls); |
844 TEST2(view->RecentList(), KLogRecentIncomingCalls); |
848 count++; |
845 count++; |
849 } |
846 } |
850 TEST(count == KTestEventNum - 1); |
847 TEST2(count, KTestEventNum - 1); |
851 |
848 |
852 active->StartL(); |
849 active->StartL(); |
853 res = view->FirstL(active->iStatus); |
850 res = view->FirstL(active->iStatus); |
854 TEST(res); |
851 TEST(res); |
855 CActiveScheduler::Start(); |
852 CActiveScheduler::Start(); |
923 |
920 |
924 TEST2(view->CountL(), KTestEventNum); |
921 TEST2(view->CountL(), KTestEventNum); |
925 TEST2(view->RecentList(), KLogRecentOutgoingCalls); |
922 TEST2(view->RecentList(), KLogRecentOutgoingCalls); |
926 count++; |
923 count++; |
927 } |
924 } |
928 TEST(count == KTestEventNum - 1); |
925 TEST2(count, KTestEventNum - 1); |
929 |
926 |
930 active->StartL(); |
927 active->StartL(); |
931 res = view->FirstL(active->iStatus); |
928 res = view->FirstL(active->iStatus); |
932 TEST(res); |
929 TEST(res); |
933 CActiveScheduler::Start(); |
930 CActiveScheduler::Start(); |
988 |
985 |
989 TEST2(view->CountL(), KTestEventNum); |
986 TEST2(view->CountL(), KTestEventNum); |
990 TEST2(view->RecentList(), KLogRecentMissedCalls); |
987 TEST2(view->RecentList(), KLogRecentMissedCalls); |
991 count++; |
988 count++; |
992 } |
989 } |
993 TEST(count == KTestEventNum - 1); |
990 TEST2(count, KTestEventNum - 1); |
994 |
991 |
995 active->StartL(); |
992 active->StartL(); |
996 res = view->FirstL(active->iStatus); |
993 res = view->FirstL(active->iStatus); |
997 TEST(res); |
994 TEST(res); |
998 CActiveScheduler::Start(); |
995 CActiveScheduler::Start(); |
1015 do { |
1012 do { |
1016 active->StartL(); |
1013 active->StartL(); |
1017 CActiveScheduler::Start(); |
1014 CActiveScheduler::Start(); |
1018 TEST2(active->iStatus.Int(), KErrNone); |
1015 TEST2(active->iStatus.Int(), KErrNone); |
1019 |
1016 |
1020 TEST(view->CountL() == KTestEventNum * 3); |
1017 TEST2(view->CountL(), KTestEventNum * 3); |
1021 count--; |
1018 count--; |
1022 } |
1019 } |
1023 while(view->NextL(active->iStatus)); |
1020 while(view->NextL(active->iStatus)); |
1024 TEST2(count, 0); |
1021 TEST2(count, 0); |
1025 |
1022 |
1028 { |
1025 { |
1029 active->StartL(); |
1026 active->StartL(); |
1030 CActiveScheduler::Start(); |
1027 CActiveScheduler::Start(); |
1031 TEST2(active->iStatus.Int(), KErrNone); |
1028 TEST2(active->iStatus.Int(), KErrNone); |
1032 |
1029 |
1033 TEST(view->CountL() == KTestEventNum * 3); |
1030 TEST2(view->CountL(), KTestEventNum * 3); |
1034 count++; |
1031 count++; |
1035 } |
1032 } |
1036 TEST(count == KTestEventNum * 3 - 1); |
1033 TEST2(count, KTestEventNum * 3 - 1); |
1037 |
1034 |
1038 active->StartL(); |
1035 active->StartL(); |
1039 res = view->FirstL(active->iStatus); |
1036 res = view->FirstL(active->iStatus); |
1040 TEST(res); |
1037 TEST(res); |
1041 CActiveScheduler::Start(); |
1038 CActiveScheduler::Start(); |
1059 @SYMTestExpectedResults Test must not fail |
1056 @SYMTestExpectedResults Test must not fail |
1060 @SYMREQ REQ0000 |
1057 @SYMREQ REQ0000 |
1061 */ |
1058 */ |
1062 LOCAL_C void TestRecentView2L(CLogClient& aClient) |
1059 LOCAL_C void TestRecentView2L(CLogClient& aClient) |
1063 { |
1060 { |
1064 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0856 ")); |
1061 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0856 ")); |
1065 TInt count; |
1062 TInt count; |
1066 |
1063 |
1067 CLogEvent* event = CLogEvent::NewL(); |
1064 CLogEvent* event = CLogEvent::NewL(); |
1068 CleanupStack::PushL(event); |
1065 CleanupStack::PushL(event); |
1069 |
1066 |
1127 res = view->DuplicatesL(*dView, active->iStatus); |
1124 res = view->DuplicatesL(*dView, active->iStatus); |
1128 TEST(res); |
1125 TEST(res); |
1129 active->StartL(); |
1126 active->StartL(); |
1130 CActiveScheduler::Start(); |
1127 CActiveScheduler::Start(); |
1131 TEST2(active->iStatus.Int(), KErrNone); |
1128 TEST2(active->iStatus.Int(), KErrNone); |
1132 TEST(dView->CountL() == KTestEventNum - 1); |
1129 TEST2(dView->CountL(), KTestEventNum - 1); |
1133 |
1130 |
1134 CleanupStack::PopAndDestroy(4); // view, active, event, dView |
1131 CleanupStack::PopAndDestroy(4); // view, active, event, dView |
1135 } |
1132 } |
1136 |
1133 |
1137 /** |
1134 /** |
1142 @SYMTestExpectedResults Test must not fail |
1139 @SYMTestExpectedResults Test must not fail |
1143 @SYMREQ REQ0000 |
1140 @SYMREQ REQ0000 |
1144 */ |
1141 */ |
1145 LOCAL_C void TestRecentRemove1L(CLogClient& aClient) |
1142 LOCAL_C void TestRecentRemove1L(CLogClient& aClient) |
1146 { |
1143 { |
1147 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0857 ")); |
1144 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0857 ")); |
1148 CTestActive* active = new(ELeave)CTestActive(); |
1145 CTestActive* active = new(ELeave)CTestActive(); |
1149 CleanupStack::PushL(active); |
1146 CleanupStack::PushL(active); |
1150 |
1147 |
1151 CLogViewRecent* view = CLogViewRecent::NewL(aClient); |
1148 CLogViewRecent* view = CLogViewRecent::NewL(aClient); |
1152 CleanupStack::PushL(view); |
1149 CleanupStack::PushL(view); |
1159 |
1156 |
1160 TInt count = view->CountL(); |
1157 TInt count = view->CountL(); |
1161 |
1158 |
1162 while(view->RemoveL(active->iStatus)) |
1159 while(view->RemoveL(active->iStatus)) |
1163 { |
1160 { |
1164 TEST(view->CountL() == count - 1); |
1161 TEST2(view->CountL(), count - 1); |
1165 count = view->CountL(); |
1162 count = view->CountL(); |
1166 |
1163 |
1167 active->StartL(); |
1164 active->StartL(); |
1168 CActiveScheduler::Start(); |
1165 CActiveScheduler::Start(); |
1169 TEST2(active->iStatus.Int(), KErrNone); |
1166 TEST2(active->iStatus.Int(), KErrNone); |
1213 @SYMTestExpectedResults Test must not fail |
1210 @SYMTestExpectedResults Test must not fail |
1214 @SYMREQ REQ0000 |
1211 @SYMREQ REQ0000 |
1215 */ |
1212 */ |
1216 LOCAL_C void TestRecentRemove2L(CLogClient& aClient) |
1213 LOCAL_C void TestRecentRemove2L(CLogClient& aClient) |
1217 { |
1214 { |
1218 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0858 ")); |
1215 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0858 ")); |
1219 CLogEvent* event = CLogEvent::NewL(); |
1216 CLogEvent* event = CLogEvent::NewL(); |
1220 CleanupStack::PushL(event); |
1217 CleanupStack::PushL(event); |
1221 |
1218 |
1222 CTestActive* active = new(ELeave)CTestActive(); |
1219 CTestActive* active = new(ELeave)CTestActive(); |
1223 CleanupStack::PushL(active); |
1220 CleanupStack::PushL(active); |
1278 @SYMTestExpectedResults Test must not fail |
1275 @SYMTestExpectedResults Test must not fail |
1279 @SYMREQ REQ0000 |
1276 @SYMREQ REQ0000 |
1280 */ |
1277 */ |
1281 LOCAL_C void TestDuplicateViewL(CLogClient& aClient) |
1278 LOCAL_C void TestDuplicateViewL(CLogClient& aClient) |
1282 { |
1279 { |
1283 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0859 ")); |
1280 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0859 ")); |
1284 CTestActive* active = new(ELeave)CTestActive(); |
1281 CTestActive* active = new(ELeave)CTestActive(); |
1285 CleanupStack::PushL(active); |
1282 CleanupStack::PushL(active); |
1286 |
1283 |
1287 CLogViewRecent* view = CLogViewRecent::NewL(aClient); |
1284 CLogViewRecent* view = CLogViewRecent::NewL(aClient); |
1288 CleanupStack::PushL(view); |
1285 CleanupStack::PushL(view); |
1451 @SYMTestExpectedResults Test must not fail |
1448 @SYMTestExpectedResults Test must not fail |
1452 @SYMREQ REQ0000 |
1449 @SYMREQ REQ0000 |
1453 */ |
1450 */ |
1454 LOCAL_C void TestDuplicateRemoveL(CLogClient& aClient) |
1451 LOCAL_C void TestDuplicateRemoveL(CLogClient& aClient) |
1455 { |
1452 { |
1456 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0860 ")); |
1453 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0860 ")); |
1457 CTestActive* active = new(ELeave)CTestActive(); |
1454 CTestActive* active = new(ELeave)CTestActive(); |
1458 CleanupStack::PushL(active); |
1455 CleanupStack::PushL(active); |
1459 |
1456 |
1460 CLogViewRecent* view = CLogViewRecent::NewL(aClient); |
1457 CLogViewRecent* view = CLogViewRecent::NewL(aClient); |
1461 CleanupStack::PushL(view); |
1458 CleanupStack::PushL(view); |
1505 @SYMTestExpectedResults Test must not fail |
1502 @SYMTestExpectedResults Test must not fail |
1506 @SYMREQ REQ0000 |
1503 @SYMREQ REQ0000 |
1507 */ |
1504 */ |
1508 LOCAL_C void TestPurgeOnSetup1L(CLogClient& aClient) |
1505 LOCAL_C void TestPurgeOnSetup1L(CLogClient& aClient) |
1509 { |
1506 { |
1510 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0861 ")); |
1507 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0861 ")); |
1511 CTestActive* active = new(ELeave)CTestActive(); |
1508 CTestActive* active = new(ELeave)CTestActive(); |
1512 CleanupStack::PushL(active); |
1509 CleanupStack::PushL(active); |
1513 |
1510 |
1514 User::After(0x100000); |
1511 User::After(0x100000); |
1515 |
1512 |
1607 @SYMTestExpectedResults Test must not fail |
1604 @SYMTestExpectedResults Test must not fail |
1608 @SYMREQ REQ0000 |
1605 @SYMREQ REQ0000 |
1609 */ |
1606 */ |
1610 LOCAL_C void TestPurgeOnSetup2L(CLogClient& aClient) |
1607 LOCAL_C void TestPurgeOnSetup2L(CLogClient& aClient) |
1611 { |
1608 { |
1612 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0862 ")); |
1609 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0862 ")); |
1613 CTestActive* active1 = new(ELeave)CTestActive(); |
1610 CTestActive* active1 = new(ELeave)CTestActive(); |
1614 CleanupStack::PushL(active1); |
1611 CleanupStack::PushL(active1); |
1615 |
1612 |
1616 CTestActive* active2 = new(ELeave)CTestActive(); |
1613 CTestActive* active2 = new(ELeave)CTestActive(); |
1617 CleanupStack::PushL(active2); |
1614 CleanupStack::PushL(active2); |
1717 @SYMTestExpectedResults Test must not fail |
1714 @SYMTestExpectedResults Test must not fail |
1718 @SYMREQ REQ0000 |
1715 @SYMREQ REQ0000 |
1719 */ |
1716 */ |
1720 LOCAL_C void TestViewPurgeL(CLogClient& aClient) |
1717 LOCAL_C void TestViewPurgeL(CLogClient& aClient) |
1721 { |
1718 { |
1722 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0863 ")); |
1719 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0863 ")); |
1723 CTestActive* active = new(ELeave)CTestActive(); |
1720 CTestActive* active = new(ELeave)CTestActive(); |
1724 CleanupStack::PushL(active); |
1721 CleanupStack::PushL(active); |
1725 |
1722 |
1726 TLogConfig config; |
1723 TLogConfig config; |
1727 |
1724 |
1728 aClient.GetConfig(config, active->iStatus); |
1725 aClient.GetConfig(config, active->iStatus); |
1729 active->StartL(); |
1726 active->StartL(); |
1730 CActiveScheduler::Start(); |
1727 CActiveScheduler::Start(); |
1731 TEST2(active->iStatus.Int(), KErrNone); |
1728 TEST2(active->iStatus.Int(), KErrNone); |
1732 |
|
1733 TEST2(config.iMaxLogSize, 1000); |
1729 TEST2(config.iMaxLogSize, 1000); |
1734 TEST(config.iMaxRecentLogSize = 10); |
|
1735 |
1730 |
1736 config.iMaxLogSize = 2000; |
1731 config.iMaxLogSize = 2000; |
1737 config.iMaxRecentLogSize = 20; |
1732 config.iMaxRecentLogSize = 20; |
1738 |
1733 |
1739 aClient.ChangeConfig(config, active->iStatus); |
1734 aClient.ChangeConfig(config, active->iStatus); |
1782 @SYMTestExpectedResults Test must not fail |
1777 @SYMTestExpectedResults Test must not fail |
1783 @SYMREQ REQ0000 |
1778 @SYMREQ REQ0000 |
1784 */ |
1779 */ |
1785 LOCAL_C void TestClearDuplicatesL(CLogClient& aClient) |
1780 LOCAL_C void TestClearDuplicatesL(CLogClient& aClient) |
1786 { |
1781 { |
1787 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0864 ")); |
1782 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0864 ")); |
1788 CTestActive* active = new(ELeave)CTestActive(); |
1783 CTestActive* active = new(ELeave)CTestActive(); |
1789 CleanupStack::PushL(active); |
1784 CleanupStack::PushL(active); |
1790 |
1785 |
1791 aClient.ClearLog(KLogNullRecentList, active->iStatus); |
1786 aClient.ClearLog(KLogNullRecentList, active->iStatus); |
1792 active->StartL(); |
1787 active->StartL(); |
2112 @SYMTestExpectedResults Test must not fail |
2107 @SYMTestExpectedResults Test must not fail |
2113 @SYMREQ REQ0000 |
2108 @SYMREQ REQ0000 |
2114 */ |
2109 */ |
2115 LOCAL_C void TestPhoneNumberMatchingL(CLogClient& aClient) |
2110 LOCAL_C void TestPhoneNumberMatchingL(CLogClient& aClient) |
2116 { |
2111 { |
2117 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0865 ")); |
2112 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0865 ")); |
2118 TestUtils::DeleteDatabaseL(); |
2113 TestUtils::DeleteDatabaseL(); |
2119 |
2114 |
2120 CTestActive* active = new(ELeave)CTestActive(); |
2115 CTestActive* active = new(ELeave)CTestActive(); |
2121 CleanupStack::PushL(active); |
2116 CleanupStack::PushL(active); |
2122 |
2117 |
2226 @SYMTestExpectedResults Number with the same last 9 digits should get matched as duplicates |
2221 @SYMTestExpectedResults Number with the same last 9 digits should get matched as duplicates |
2227 @SYMDEF INC105010 |
2222 @SYMDEF INC105010 |
2228 */ |
2223 */ |
2229 LOCAL_C void INC105010L(CLogClient& aClient) |
2224 LOCAL_C void INC105010L(CLogClient& aClient) |
2230 { |
2225 { |
2231 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-3472 ")); |
2226 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-3472 ")); |
2232 TestUtils::DeleteDatabaseL(); |
2227 TestUtils::DeleteDatabaseL(); |
2233 |
2228 |
2234 CTestActive* active = new(ELeave)CTestActive(); |
2229 CTestActive* active = new(ELeave)CTestActive(); |
2235 CleanupStack::PushL(active); |
2230 CleanupStack::PushL(active); |
2236 |
2231 |
2334 @SYMTestExpectedResults Test must not fail |
2329 @SYMTestExpectedResults Test must not fail |
2335 @SYMREQ REQ0000 |
2330 @SYMREQ REQ0000 |
2336 */ |
2331 */ |
2337 LOCAL_C void TestRecentFlagsL(CLogClient& aClient) |
2332 LOCAL_C void TestRecentFlagsL(CLogClient& aClient) |
2338 { |
2333 { |
2339 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0866 ")); |
2334 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0866 ")); |
2340 TestUtils::DeleteDatabaseL(); |
2335 TestUtils::DeleteDatabaseL(); |
2341 |
2336 |
2342 CLogEvent* event = CLogEvent::NewL(); |
2337 CLogEvent* event = CLogEvent::NewL(); |
2343 CleanupStack::PushL(event); |
2338 CleanupStack::PushL(event); |
2344 |
2339 |
2467 @SYMTestExpectedResults Test must not fail |
2462 @SYMTestExpectedResults Test must not fail |
2468 @SYMREQ REQ0000 |
2463 @SYMREQ REQ0000 |
2469 */ |
2464 */ |
2470 LOCAL_C void TestViewFlagsL(CLogClient& aClient) |
2465 LOCAL_C void TestViewFlagsL(CLogClient& aClient) |
2471 { |
2466 { |
2472 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0867 ")); |
2467 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0867 ")); |
2473 TestUtils::DeleteDatabaseL(); |
2468 TestUtils::DeleteDatabaseL(); |
2474 |
2469 |
2475 CLogEvent* event = CLogEvent::NewL(); |
2470 CLogEvent* event = CLogEvent::NewL(); |
2476 CleanupStack::PushL(event); |
2471 CleanupStack::PushL(event); |
2477 |
2472 |
2656 @SYMTestExpectedResults Test must not fail |
2651 @SYMTestExpectedResults Test must not fail |
2657 @SYMREQ REQ0000 |
2652 @SYMREQ REQ0000 |
2658 */ |
2653 */ |
2659 LOCAL_C void TestViewChangeEvents1L(CLogClient& aClient) |
2654 LOCAL_C void TestViewChangeEvents1L(CLogClient& aClient) |
2660 { |
2655 { |
2661 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0868 ")); |
2656 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0868 ")); |
2662 TestUtils::DeleteDatabaseL(); |
2657 TestUtils::DeleteDatabaseL(); |
2663 |
2658 |
2664 CLogEvent* event = CLogEvent::NewL(); |
2659 CLogEvent* event = CLogEvent::NewL(); |
2665 CleanupStack::PushL(event); |
2660 CleanupStack::PushL(event); |
2666 |
2661 |
2739 |
2734 |
2740 changeCount = changes->Count(); |
2735 changeCount = changes->Count(); |
2741 for(i=0; i<changeCount; i++) |
2736 for(i=0; i<changeCount; i++) |
2742 { |
2737 { |
2743 type = changes->At(i, logId, viewIndex); |
2738 type = changes->At(i, logId, viewIndex); |
2744 RDebug::Print(_L("Change Type: %d, logId: %d, viewIndex: %d\n"), type, logId, viewIndex); |
2739 TheTest.Printf(_L("Change Type: %d, logId: %d, viewIndex: %d\n"), type, logId, viewIndex); |
2745 } |
2740 } |
2746 |
2741 |
2747 // Check the change was as expected |
2742 // Check the change was as expected |
2748 TEST2(changes->Count(), 1); |
2743 TEST2(changes->Count(), 1); |
2749 type = changes->At(0, logId, viewIndex); |
2744 type = changes->At(0, logId, viewIndex); |
2762 do |
2757 do |
2763 { |
2758 { |
2764 active->StartL(); |
2759 active->StartL(); |
2765 CActiveScheduler::Start(); |
2760 CActiveScheduler::Start(); |
2766 TEST2(active->iStatus.Int(), KErrNone); |
2761 TEST2(active->iStatus.Int(), KErrNone); |
2767 RDebug::Print(_L("View Entry[%d]: Id: %d\n"), i++, view->Event().Id()); |
2762 TheTest.Printf(_L("View Entry[%d]: Id: %d\r\n"), i++, view->Event().Id()); |
2768 } |
2763 } |
2769 while(view->NextL(active->iStatus)); |
2764 while(view->NextL(active->iStatus)); |
2770 RDebug::Print(_L("==\n")); |
2765 TheTest.Printf(_L("==\n")); |
2771 TEST2(i, count); |
2766 TEST2(i, count); |
2772 res = view->FirstL(active->iStatus); |
2767 res = view->FirstL(active->iStatus); |
2773 TEST(res); |
2768 TEST(res); |
2774 active->StartL(); |
2769 active->StartL(); |
2775 CActiveScheduler::Start(); |
2770 CActiveScheduler::Start(); |
2789 // Check changes |
2784 // Check changes |
2790 changeCount = changeObs->Changes().Count(); |
2785 changeCount = changeObs->Changes().Count(); |
2791 TEST2(changeCount, 5); // 1,3,5,7,9 |
2786 TEST2(changeCount, 5); // 1,3,5,7,9 |
2792 for(i=0; i<changeCount; i++) |
2787 for(i=0; i<changeCount; i++) |
2793 { |
2788 { |
2794 TEST(changeObs->Changes().At(i, logId, viewIndex) == ELogChangeTypeEventDeleted); |
2789 TEST2(changeObs->Changes().At(i, logId, viewIndex), ELogChangeTypeEventDeleted); |
2795 TEST(logId == TLogId(2*i + 1)); |
2790 TEST2(logId, TLogId(2*i + 1)); |
2796 TEST(viewIndex == 10 - ((2*i) + 1)); |
2791 TEST2(viewIndex, 10 - ((2*i) + 1)); |
2797 } |
2792 } |
2798 |
2793 |
2799 // Add a new event that shouldn't appear in the view |
2794 // Add a new event that shouldn't appear in the view |
2800 changeObs->StartCollectingChanges(); |
2795 changeObs->StartCollectingChanges(); |
2801 event->SetContact(TLogContactItemId(0)); |
2796 event->SetContact(TLogContactItemId(0)); |
2802 active->StartL(); |
2797 active->StartL(); |
2803 aClient.AddEvent(*event, active->iStatus); |
2798 aClient.AddEvent(*event, active->iStatus); |
2804 CActiveScheduler::Start(); |
2799 CActiveScheduler::Start(); |
2805 TEST2(active->iStatus.Int(), KErrNone); |
2800 TEST2(active->iStatus.Int(), KErrNone); |
2806 count = view->CountL(); |
2801 count = view->CountL(); |
2807 TEST(count == KTestEventNum + 1 - 5); |
2802 TEST2(count, KTestEventNum + 1 - 5); |
2808 TEST(event->Id() == KTestEventNum + 1); |
2803 TEST2(event->Id(), KTestEventNum + 1); |
2809 |
2804 |
2810 // Check changes |
2805 // Check changes |
2811 TEST(!changeObs->HaveChanges()); |
2806 TEST(!changeObs->HaveChanges()); |
2812 |
2807 |
2813 // Check view navigation |
2808 // Check view navigation |
2817 do |
2812 do |
2818 { |
2813 { |
2819 active->StartL(); |
2814 active->StartL(); |
2820 CActiveScheduler::Start(); |
2815 CActiveScheduler::Start(); |
2821 TEST2(active->iStatus.Int(), KErrNone); |
2816 TEST2(active->iStatus.Int(), KErrNone); |
2822 RDebug::Print(_L("View Entry[%d]: Id: %d\n"), i++, view->Event().Id()); |
2817 TheTest.Printf(_L("View Entry[%d]: Id: %d\r\n"), i++, view->Event().Id()); |
2823 } |
2818 } |
2824 while(view->NextL(active->iStatus)); |
2819 while(view->NextL(active->iStatus)); |
2825 RDebug::Print(_L("==\n")); |
2820 TheTest.Printf(_L("==\n")); |
2826 TEST2(i, count); |
2821 TEST2(i, count); |
2827 res = view->FirstL(active->iStatus); |
2822 res = view->FirstL(active->iStatus); |
2828 TEST(res); |
2823 TEST(res); |
2829 active->StartL(); |
2824 active->StartL(); |
2830 CActiveScheduler::Start(); |
2825 CActiveScheduler::Start(); |
2835 active->StartL(); |
2830 active->StartL(); |
2836 aClient.DeleteEvent(event->Id(), active->iStatus); |
2831 aClient.DeleteEvent(event->Id(), active->iStatus); |
2837 CActiveScheduler::Start(); |
2832 CActiveScheduler::Start(); |
2838 TEST2(active->iStatus.Int(), KErrNone); |
2833 TEST2(active->iStatus.Int(), KErrNone); |
2839 count = view->CountL(); |
2834 count = view->CountL(); |
2840 TEST(count == KTestEventNum + 1 - 5); |
2835 TEST2(count, KTestEventNum + 1 - 5); |
2841 |
2836 |
2842 // Check changes |
2837 // Check changes |
2843 TEST(!changeObs->HaveChanges()); |
2838 TEST(!changeObs->HaveChanges()); |
2844 |
2839 |
2845 // Check view navigation |
2840 // Check view navigation |
2849 do |
2844 do |
2850 { |
2845 { |
2851 active->StartL(); |
2846 active->StartL(); |
2852 CActiveScheduler::Start(); |
2847 CActiveScheduler::Start(); |
2853 TEST2(active->iStatus.Int(), KErrNone); |
2848 TEST2(active->iStatus.Int(), KErrNone); |
2854 RDebug::Print(_L("View Entry[%d]: Id: %d\n"), i++, view->Event().Id()); |
2849 TheTest.Printf(_L("View Entry[%d]: Id: %d\r\n"), i++, view->Event().Id()); |
2855 } |
2850 } |
2856 while(view->NextL(active->iStatus)); |
2851 while(view->NextL(active->iStatus)); |
2857 RDebug::Print(_L("==\n")); |
2852 TheTest.Printf(_L("==\n")); |
2858 TEST2(i, count); |
2853 TEST2(i, count); |
2859 res = view->FirstL(active->iStatus); |
2854 res = view->FirstL(active->iStatus); |
2860 TEST(res); |
2855 TEST(res); |
2861 active->StartL(); |
2856 active->StartL(); |
2862 CActiveScheduler::Start(); |
2857 CActiveScheduler::Start(); |
2868 active->StartL(); |
2863 active->StartL(); |
2869 aClient.AddEvent(*event, active->iStatus); |
2864 aClient.AddEvent(*event, active->iStatus); |
2870 CActiveScheduler::Start(); |
2865 CActiveScheduler::Start(); |
2871 TEST2(active->iStatus.Int(), KErrNone); |
2866 TEST2(active->iStatus.Int(), KErrNone); |
2872 count = view->CountL(); |
2867 count = view->CountL(); |
2873 TEST(count == KTestEventNum + 1 - 5); |
2868 TEST2(count, KTestEventNum + 1 - 5); |
2874 TEST(event->Id() == KTestEventNum + 2); |
2869 TEST2(event->Id(), KTestEventNum + 2); |
2875 |
2870 |
2876 // Check changes |
2871 // Check changes |
2877 TEST(!changeObs->HaveChanges()); |
2872 TEST(!changeObs->HaveChanges()); |
2878 |
2873 |
2879 // Check view navigation |
2874 // Check view navigation |
2883 do |
2878 do |
2884 { |
2879 { |
2885 active->StartL(); |
2880 active->StartL(); |
2886 CActiveScheduler::Start(); |
2881 CActiveScheduler::Start(); |
2887 TEST2(active->iStatus.Int(), KErrNone); |
2882 TEST2(active->iStatus.Int(), KErrNone); |
2888 RDebug::Print(_L("View Entry[%d]: Id: %d\n"), i++, view->Event().Id()); |
2883 TheTest.Printf(_L("View Entry[%d]: Id: %d\r\n"), i++, view->Event().Id()); |
2889 } |
2884 } |
2890 while(view->NextL(active->iStatus)); |
2885 while(view->NextL(active->iStatus)); |
2891 RDebug::Print(_L("==\n")); |
2886 TheTest.Printf(_L("==\n")); |
2892 TEST2(i, count); |
2887 TEST2(i, count); |
2893 res = view->FirstL(active->iStatus); |
2888 res = view->FirstL(active->iStatus); |
2894 TEST(res); |
2889 TEST(res); |
2895 active->StartL(); |
2890 active->StartL(); |
2896 CActiveScheduler::Start(); |
2891 CActiveScheduler::Start(); |
2902 active->StartL(); |
2897 active->StartL(); |
2903 aClient.ChangeEvent(*event, active->iStatus); |
2898 aClient.ChangeEvent(*event, active->iStatus); |
2904 CActiveScheduler::Start(); |
2899 CActiveScheduler::Start(); |
2905 TEST2(active->iStatus.Int(), KErrNone); |
2900 TEST2(active->iStatus.Int(), KErrNone); |
2906 count = view->CountL(); |
2901 count = view->CountL(); |
2907 TEST(count == KTestEventNum + 2 - 5); |
2902 TEST2(count, KTestEventNum + 2 - 5); |
2908 TEST(event->Id() == KTestEventNum + 2); // Shouldn't change |
2903 TEST2(event->Id(), KTestEventNum + 2); // Shouldn't change |
2909 |
2904 |
2910 // Check changes |
2905 // Check changes |
2911 changeCount = changeObs->Changes().Count(); |
2906 changeCount = changeObs->Changes().Count(); |
2912 TEST2(changeCount, 1); |
2907 TEST2(changeCount, 1); |
2913 type = changeObs->Changes().At(0, logId, viewIndex); |
2908 type = changeObs->Changes().At(0, logId, viewIndex); |
2914 TEST2(type, ELogChangeTypeEventAdded); |
2909 TEST2(type, ELogChangeTypeEventAdded); |
2915 TEST(logId == KTestEventNum + 2); |
2910 TEST2(logId, KTestEventNum + 2); |
2916 TEST2(viewIndex, 0); |
2911 TEST2(viewIndex, 0); |
2917 |
2912 |
2918 // Check view navigation |
2913 // Check view navigation |
2919 i=0; |
2914 i=0; |
2920 res = view->FirstL(active->iStatus); |
2915 res = view->FirstL(active->iStatus); |
2922 do |
2917 do |
2923 { |
2918 { |
2924 active->StartL(); |
2919 active->StartL(); |
2925 CActiveScheduler::Start(); |
2920 CActiveScheduler::Start(); |
2926 TEST2(active->iStatus.Int(), KErrNone); |
2921 TEST2(active->iStatus.Int(), KErrNone); |
2927 RDebug::Print(_L("View Entry[%d]: Id: %d\n"), i++, view->Event().Id()); |
2922 TheTest.Printf(_L("View Entry[%d]: Id: %d\r\n"), i++, view->Event().Id()); |
2928 } |
2923 } |
2929 while(view->NextL(active->iStatus)); |
2924 while(view->NextL(active->iStatus)); |
2930 RDebug::Print(_L("==\n")); |
2925 TheTest.Printf(_L("==\n")); |
2931 TEST2(i, count); |
2926 TEST2(i, count); |
2932 res = view->FirstL(active->iStatus); |
2927 res = view->FirstL(active->iStatus); |
2933 TEST(res); |
2928 TEST(res); |
2934 active->StartL(); |
2929 active->StartL(); |
2935 CActiveScheduler::Start(); |
2930 CActiveScheduler::Start(); |
2941 active->StartL(); |
2936 active->StartL(); |
2942 aClient.ChangeEvent(*event, active->iStatus); |
2937 aClient.ChangeEvent(*event, active->iStatus); |
2943 CActiveScheduler::Start(); |
2938 CActiveScheduler::Start(); |
2944 TEST2(active->iStatus.Int(), KErrNone); |
2939 TEST2(active->iStatus.Int(), KErrNone); |
2945 count = view->CountL(); |
2940 count = view->CountL(); |
2946 TEST(count == KTestEventNum + 2 - 5); // Shouldn't change |
2941 TEST2(count, KTestEventNum + 2 - 5); // Shouldn't change |
2947 TEST(event->Id() == KTestEventNum + 2); // Shouldn't change |
2942 TEST2(event->Id(), KTestEventNum + 2); // Shouldn't change |
2948 |
2943 |
2949 // Check changes |
2944 // Check changes |
2950 changeCount = changeObs->Changes().Count(); |
2945 changeCount = changeObs->Changes().Count(); |
2951 TEST2(changeCount, 1); |
2946 TEST2(changeCount, 1); |
2952 type = changeObs->Changes().At(0, logId, viewIndex); |
2947 type = changeObs->Changes().At(0, logId, viewIndex); |
2953 TEST2(type, ELogChangeTypeEventChanged); |
2948 TEST2(type, ELogChangeTypeEventChanged); |
2954 TEST(logId == KTestEventNum + 2); |
2949 TEST2(logId, KTestEventNum + 2); |
2955 TEST2(viewIndex, 0); |
2950 TEST2(viewIndex, 0); |
2956 |
2951 |
2957 // Change an event in the view so that it is deleted |
2952 // Change an event in the view so that it is deleted |
2958 changeObs->StartCollectingChanges(); |
2953 changeObs->StartCollectingChanges(); |
2959 event->SetContact(0); |
2954 event->SetContact(0); |
2960 active->StartL(); |
2955 active->StartL(); |
2961 aClient.ChangeEvent(*event, active->iStatus); |
2956 aClient.ChangeEvent(*event, active->iStatus); |
2962 CActiveScheduler::Start(); |
2957 CActiveScheduler::Start(); |
2963 TEST2(active->iStatus.Int(), KErrNone); |
2958 TEST2(active->iStatus.Int(), KErrNone); |
2964 count = view->CountL(); |
2959 count = view->CountL(); |
2965 TEST(count == KTestEventNum + 2 - 5 - 1); // one less now |
2960 TEST2(count, KTestEventNum + 2 - 5 - 1); // one less now |
2966 |
2961 |
2967 // Check changes |
2962 // Check changes |
2968 changeCount = changeObs->Changes().Count(); |
2963 changeCount = changeObs->Changes().Count(); |
2969 TEST2(changeCount, 1); |
2964 TEST2(changeCount, 1); |
2970 type = changeObs->Changes().At(0, logId, viewIndex); |
2965 type = changeObs->Changes().At(0, logId, viewIndex); |
2971 TEST2(type, ELogChangeTypeEventDeleted); |
2966 TEST2(type, ELogChangeTypeEventDeleted); |
2972 TEST(logId == KTestEventNum + 2); |
2967 TEST2(logId, KTestEventNum + 2); |
2973 TEST2(viewIndex, 0); |
2968 TEST2(viewIndex, 0); |
2974 |
2969 |
2975 // Navigate part way through the view so we have |
2970 // Navigate part way through the view so we have |
2976 // a cursor position part way through... |
2971 // a cursor position part way through... |
2977 i=0; |
2972 i=0; |
2981 do |
2976 do |
2982 { |
2977 { |
2983 active->StartL(); |
2978 active->StartL(); |
2984 CActiveScheduler::Start(); |
2979 CActiveScheduler::Start(); |
2985 TEST2(active->iStatus.Int(), KErrNone); |
2980 TEST2(active->iStatus.Int(), KErrNone); |
2986 RDebug::Print(_L("View Entry[%d]: Id: %d\n"), i++, view->Event().Id()); |
2981 TheTest.Printf(_L("View Entry[%d]: Id: %d\r\n"), i++, view->Event().Id()); |
2987 } |
2982 } |
2988 while(view->NextL(active->iStatus)); |
2983 while(view->NextL(active->iStatus)); |
2989 RDebug::Print(_L("==\n")); |
2984 TheTest.Printf(_L("==\n")); |
2990 TEST2(i, count); |
2985 TEST2(i, count); |
2991 TEST(view->Event().Id() == TLogId(0)); |
2986 TEST2(view->Event().Id(), TLogId(0)); |
2992 |
2987 |
2993 // Save id |
2988 // Save id |
2994 TLogId savedId = view->Event().Id(); |
2989 TLogId savedId = view->Event().Id(); |
2995 |
2990 |
2996 // Go one back |
2991 // Go one back |
3006 active->StartL(); |
3001 active->StartL(); |
3007 aClient.AddEvent(*event, active->iStatus); |
3002 aClient.AddEvent(*event, active->iStatus); |
3008 CActiveScheduler::Start(); |
3003 CActiveScheduler::Start(); |
3009 TEST2(active->iStatus.Int(), KErrNone); |
3004 TEST2(active->iStatus.Int(), KErrNone); |
3010 count = view->CountL(); |
3005 count = view->CountL(); |
3011 TEST(count == KTestEventNum + 2 - 5); // one more now |
3006 TEST2(count, KTestEventNum + 2 - 5); // one more now |
3012 TEST(event->Id() == KTestEventNum + 3); |
3007 TEST2(event->Id(), KTestEventNum + 3); |
3013 |
3008 |
3014 // Check changes |
3009 // Check changes |
3015 changeCount = changeObs->Changes().Count(); |
3010 changeCount = changeObs->Changes().Count(); |
3016 TEST2(changeCount, 1); |
3011 TEST2(changeCount, 1); |
3017 type = changeObs->Changes().At(0, logId, viewIndex); |
3012 type = changeObs->Changes().At(0, logId, viewIndex); |
3018 TEST(type == ELogChangeTypeEventAdded); |
3013 TEST2(type, ELogChangeTypeEventAdded); |
3019 TEST(logId == KTestEventNum + 3); |
3014 TEST2(logId, KTestEventNum + 3); |
3020 TEST2(viewIndex, 0); |
3015 TEST2(viewIndex, 0); |
3021 |
3016 |
3022 // Check we can still go forward to the last record |
3017 // Check we can still go forward to the last record |
3023 res = view->NextL(active->iStatus); |
3018 res = view->NextL(active->iStatus); |
3024 TEST(res); |
3019 TEST(res); |
3040 active->StartL(); |
3035 active->StartL(); |
3041 aClient.DeleteEvent(savedId, active->iStatus); |
3036 aClient.DeleteEvent(savedId, active->iStatus); |
3042 CActiveScheduler::Start(); |
3037 CActiveScheduler::Start(); |
3043 TEST2(active->iStatus.Int(), KErrNone); |
3038 TEST2(active->iStatus.Int(), KErrNone); |
3044 count = view->CountL(); |
3039 count = view->CountL(); |
3045 TEST(count == KTestEventNum + 2 - 5 - 1); // one less |
3040 TEST2(count, KTestEventNum + 2 - 5 - 1); // one less |
3046 |
3041 |
3047 // Check changes |
3042 // Check changes |
3048 changeCount = changeObs->Changes().Count(); |
3043 changeCount = changeObs->Changes().Count(); |
3049 TEST2(changeCount, 1); |
3044 TEST2(changeCount, 1); |
3050 type = changeObs->Changes().At(0, logId, viewIndex); |
3045 type = changeObs->Changes().At(0, logId, viewIndex); |
3051 TEST2(type, ELogChangeTypeEventDeleted); |
3046 TEST2(type, ELogChangeTypeEventDeleted); |
3052 TEST2(logId, savedId); |
3047 TEST2(logId, savedId); |
3053 TEST(viewIndex == KTestEventNum + 2 - 5 - 2); // last but one event |
3048 TEST2(viewIndex, KTestEventNum + 2 - 5 - 2); // last but one event |
3054 |
3049 |
3055 // Check we're now at the end of the view |
3050 // Check we're now at the end of the view |
3056 res = view->NextL(active->iStatus); |
3051 res = view->NextL(active->iStatus); |
3057 TEST(!res); |
3052 TEST(!res); |
3058 |
3053 |
3069 active->StartL(); |
3064 active->StartL(); |
3070 aClient.DeleteEvent(savedId, active->iStatus); |
3065 aClient.DeleteEvent(savedId, active->iStatus); |
3071 CActiveScheduler::Start(); |
3066 CActiveScheduler::Start(); |
3072 TEST2(active->iStatus.Int(), KErrNone); |
3067 TEST2(active->iStatus.Int(), KErrNone); |
3073 count = view->CountL(); |
3068 count = view->CountL(); |
3074 TEST(count == KTestEventNum - 5); |
3069 TEST2(count, KTestEventNum - 5); |
3075 |
3070 |
3076 // Check changes |
3071 // Check changes |
3077 changeCount = changeObs->Changes().Count(); |
3072 changeCount = changeObs->Changes().Count(); |
3078 TEST2(changeCount, 1); |
3073 TEST2(changeCount, 1); |
3079 type = changeObs->Changes().At(0, logId, viewIndex); |
3074 type = changeObs->Changes().At(0, logId, viewIndex); |
3090 CActiveScheduler::Start(); |
3085 CActiveScheduler::Start(); |
3091 TEST2(active->iStatus.Int(), KErrNone); |
3086 TEST2(active->iStatus.Int(), KErrNone); |
3092 ++count; |
3087 ++count; |
3093 } |
3088 } |
3094 while(view->NextL(active->iStatus)); |
3089 while(view->NextL(active->iStatus)); |
3095 TEST(count == KTestEventNum - 5 - 1); |
3090 TEST2(count, KTestEventNum - 5 - 1); |
3096 |
3091 |
3097 // Check last record |
3092 // Check last record |
3098 savedId = view->Event().Id(); |
3093 savedId = view->Event().Id(); |
3099 res = view->LastL(active->iStatus); |
3094 res = view->LastL(active->iStatus); |
3100 TEST(res); |
3095 TEST(res); |
3101 active->StartL(); |
3096 active->StartL(); |
3102 CActiveScheduler::Start(); |
3097 CActiveScheduler::Start(); |
3103 TEST2(active->iStatus.Int(), KErrNone); |
3098 TEST2(active->iStatus.Int(), KErrNone); |
3104 TEST(savedId == view->Event().Id()); |
3099 TEST2(savedId, view->Event().Id()); |
3105 |
3100 |
3106 // Delete the last record |
3101 // Delete the last record |
3107 savedId = view->Event().Id(); |
3102 savedId = view->Event().Id(); |
3108 changeObs->StartCollectingChanges(); |
3103 changeObs->StartCollectingChanges(); |
3109 active->StartL(); |
3104 active->StartL(); |
3110 aClient.DeleteEvent(savedId, active->iStatus); |
3105 aClient.DeleteEvent(savedId, active->iStatus); |
3111 CActiveScheduler::Start(); |
3106 CActiveScheduler::Start(); |
3112 TEST2(active->iStatus.Int(), KErrNone); |
3107 TEST2(active->iStatus.Int(), KErrNone); |
3113 count = view->CountL(); |
3108 count = view->CountL(); |
3114 TEST(count == KTestEventNum - 6); |
3109 TEST2(count, KTestEventNum - 6); |
3115 |
3110 |
3116 // Check changes |
3111 // Check changes |
3117 changeCount = changeObs->Changes().Count(); |
3112 changeCount = changeObs->Changes().Count(); |
3118 TEST2(changeCount, 1); |
3113 TEST2(changeCount, 1); |
3119 type = changeObs->Changes().At(0, logId, viewIndex); |
3114 type = changeObs->Changes().At(0, logId, viewIndex); |
3135 return TestUtils::IsDatabaseOpenL(); |
3130 return TestUtils::IsDatabaseOpenL(); |
3136 } |
3131 } |
3137 |
3132 |
3138 LOCAL_C void TestLogOpenL() |
3133 LOCAL_C void TestLogOpenL() |
3139 { |
3134 { |
3140 test(IsLogOpenL()); |
3135 TEST(IsLogOpenL()); |
3141 } |
3136 } |
3142 |
3137 |
3143 LOCAL_C void TestLogClosedL() |
3138 LOCAL_C void TestLogClosedL() |
3144 { |
3139 { |
3145 test(!IsLogOpenL()); |
3140 TEST(!IsLogOpenL()); |
3146 } |
3141 } |
3147 |
3142 |
3148 LOCAL_C void StartBackupL() |
3143 LOCAL_C void StartBackupL() |
3149 { |
3144 { |
3150 User::InfoPrint(_L("Backup")); |
3145 User::InfoPrint(_L("Backup")); |
3187 @SYMTestExpectedResults Test must not fail |
3182 @SYMTestExpectedResults Test must not fail |
3188 @SYMREQ REQ0000 |
3183 @SYMREQ REQ0000 |
3189 */ |
3184 */ |
3190 LOCAL_C void TestViewChangeEvents1aL(CLogClient& aClient) |
3185 LOCAL_C void TestViewChangeEvents1aL(CLogClient& aClient) |
3191 { |
3186 { |
3192 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0869 ")); |
3187 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0869 ")); |
3193 TestUtils::DeleteDatabaseL(); |
3188 TestUtils::DeleteDatabaseL(); |
3194 |
3189 |
3195 CLogEvent* event = CLogEvent::NewL(); |
3190 CLogEvent* event = CLogEvent::NewL(); |
3196 CleanupStack::PushL(event); |
3191 CleanupStack::PushL(event); |
3197 |
3192 |
3222 for(count = 0; count < KTestEventNum; count++) |
3217 for(count = 0; count < KTestEventNum; count++) |
3223 { |
3218 { |
3224 active->StartL(); |
3219 active->StartL(); |
3225 aClient.AddEvent(*event, active->iStatus); |
3220 aClient.AddEvent(*event, active->iStatus); |
3226 CActiveScheduler::Start(); |
3221 CActiveScheduler::Start(); |
3227 test(active->iStatus == KErrNone); |
3222 TEST2(active->iStatus.Int(), KErrNone); |
3228 User::After(1 * 1000000); |
3223 User::After(1 * 1000000); |
3229 } |
3224 } |
3230 // |
3225 // |
3231 test(view->CountL() == 0); |
3226 TEST2(view->CountL(), 0); |
3232 active->StartL(); |
3227 active->StartL(); |
3233 test(view->SetFilterL(*filter, active->iStatus)); |
3228 TEST(view->SetFilterL(*filter, active->iStatus)); |
3234 CActiveScheduler::Start(); |
3229 CActiveScheduler::Start(); |
3235 test(active->iStatus == KErrNone); |
3230 TEST2(active->iStatus.Int(), KErrNone); |
3236 test(view->CountL() == KTestEventNum); |
3231 TEST2(view->CountL(), KTestEventNum); |
3237 // |
3232 // |
3238 count = KTestEventNum; |
3233 count = KTestEventNum; |
3239 test(view->FirstL(active->iStatus)); |
3234 TEST(view->FirstL(active->iStatus)); |
3240 do { |
3235 do { |
3241 active->StartL(); |
3236 active->StartL(); |
3242 CActiveScheduler::Start(); |
3237 CActiveScheduler::Start(); |
3243 test(active->iStatus == KErrNone); |
3238 TEST2(active->iStatus.Int(), KErrNone); |
3244 // |
3239 // |
3245 test(view->CountL() == KTestEventNum); |
3240 TEST2(view->CountL(), KTestEventNum); |
3246 const TLogId eventId = view->Event().Id(); |
3241 const TLogId eventId = view->Event().Id(); |
3247 test(eventId == (TLogId)--count); |
3242 TEST2(eventId, (TLogId)--count); |
3248 } |
3243 } |
3249 while(view->NextL(active->iStatus)); |
3244 while(view->NextL(active->iStatus)); |
3250 |
3245 |
3251 // Transients |
3246 // Transients |
3252 TInt changeCount; |
3247 TInt changeCount; |
3259 active->StartL(); |
3254 active->StartL(); |
3260 aClient.AddEvent(*event, active->iStatus); |
3255 aClient.AddEvent(*event, active->iStatus); |
3261 changes = changeObs->WaitForChangesLC(); |
3256 changes = changeObs->WaitForChangesLC(); |
3262 if (active->IsActive()) |
3257 if (active->IsActive()) |
3263 CActiveScheduler::Start(); |
3258 CActiveScheduler::Start(); |
3264 test(active->iStatus == KErrNone); |
3259 TEST2(active->iStatus.Int(), KErrNone); |
3265 count = view->CountL(); |
3260 count = view->CountL(); |
3266 test(count == KTestEventNum+1); |
3261 TEST2(count, KTestEventNum+1); |
3267 |
3262 |
3268 changeCount = changes->Count(); |
3263 changeCount = changes->Count(); |
3269 for(i=0; i<changeCount; i++) |
3264 for(i=0; i<changeCount; i++) |
3270 { |
3265 { |
3271 type = changes->At(i, logId, viewIndex); |
3266 type = changes->At(i, logId, viewIndex); |
3272 RDebug::Print(_L("Change Type: %d, logId: %d, viewIndex: %d"), type, logId, viewIndex); |
3267 TheTest.Printf(_L("Change Type: %d, logId: %d, viewIndex: %d"), type, logId, viewIndex); |
3273 } |
3268 } |
3274 |
3269 |
3275 // Check the change was as expected |
3270 // Check the change was as expected |
3276 test(changes->Count() == 1); |
3271 TEST2(changes->Count(), 1); |
3277 type = changes->At(0, logId, viewIndex); |
3272 type = changes->At(0, logId, viewIndex); |
3278 test(type == ELogChangeTypeEventAdded); |
3273 TEST2(type, ELogChangeTypeEventAdded); |
3279 test(viewIndex == 0); // first (newest) event in the view |
3274 TEST2(viewIndex, 0); // first (newest) event in the view |
3280 { |
3275 { |
3281 const TLogId expectedLogId = ((TLogId) KTestEventNum); |
3276 const TLogId expectedLogId = ((TLogId) KTestEventNum); |
3282 test(logId == expectedLogId); |
3277 TEST2(logId, expectedLogId); |
3283 } |
3278 } |
3284 CleanupStack::PopAndDestroy(changes); |
3279 CleanupStack::PopAndDestroy(changes); |
3285 |
3280 |
3286 // Check view navigation |
3281 // Check view navigation |
3287 i=0; |
3282 i=0; |
3288 test(view->FirstL(active->iStatus)); |
3283 TEST(view->FirstL(active->iStatus)); |
3289 do |
3284 do |
3290 { |
3285 { |
3291 active->StartL(); |
3286 active->StartL(); |
3292 CActiveScheduler::Start(); |
3287 CActiveScheduler::Start(); |
3293 test(active->iStatus == KErrNone); |
3288 TEST2(active->iStatus.Int(), KErrNone); |
3294 RDebug::Print(_L("View Entry[%d]: Id: %d"), i++, view->Event().Id()); |
3289 TheTest.Printf(_L("View Entry[%d]: Id: %d\r\n"), i++, view->Event().Id()); |
3295 } |
3290 } |
3296 while(view->NextL(active->iStatus)); |
3291 while(view->NextL(active->iStatus)); |
3297 RDebug::Print(_L("==\n")); |
3292 TheTest.Printf(_L("==\n")); |
3298 test(i == count); |
3293 TEST2(i, count); |
3299 test(view->FirstL(active->iStatus)); |
3294 TEST(view->FirstL(active->iStatus)); |
3300 active->StartL(); |
3295 active->StartL(); |
3301 CActiveScheduler::Start(); |
3296 CActiveScheduler::Start(); |
3302 test(active->iStatus == KErrNone); |
3297 TEST2(active->iStatus.Int(), KErrNone); |
3303 |
3298 |
3304 // Check that changes work after a backup |
3299 // Check that changes work after a backup |
3305 DelayL(1000000); |
3300 DelayL(1000000); |
3306 StartBackupL(); |
3301 StartBackupL(); |
3307 DelayL(1000000); |
3302 DelayL(1000000); |
3308 TestLogClosedL(); |
3303 TestLogClosedL(); |
3309 EndBackupL(); |
3304 EndBackupL(); |
3310 TestLogOpenL(); |
3305 TestLogOpenL(); |
3311 |
3306 |
3312 // Delete some events |
3307 // Delete some events |
3313 test(KTestEventNum >= 10); |
3308 TEST(KTestEventNum >= 10); |
3314 changeObs->StartCollectingChanges(); |
3309 changeObs->StartCollectingChanges(); |
3315 for(i=1; i<KTestEventNum; i+=2) |
3310 for(i=1; i<KTestEventNum; i+=2) |
3316 { |
3311 { |
3317 active->StartL(); |
3312 active->StartL(); |
3318 aClient.DeleteEvent(TLogId(i), active->iStatus); |
3313 aClient.DeleteEvent(TLogId(i), active->iStatus); |
3319 CActiveScheduler::Start(); |
3314 CActiveScheduler::Start(); |
3320 test(active->iStatus == KErrNone); |
3315 TEST2(active->iStatus.Int(), KErrNone); |
3321 } |
3316 } |
3322 |
3317 |
3323 // Check changes |
3318 // Check changes |
3324 changeCount = changeObs->Changes().Count(); |
3319 changeCount = changeObs->Changes().Count(); |
3325 test(changeCount == 5); // 1,3,5,7,9 |
3320 TEST2(changeCount, 5); // 1,3,5,7,9 |
3326 for(i=0; i<changeCount; i++) |
3321 for(i=0; i<changeCount; i++) |
3327 { |
3322 { |
3328 test(changeObs->Changes().At(i, logId, viewIndex) == ELogChangeTypeEventDeleted); |
3323 TEST2(changeObs->Changes().At(i, logId, viewIndex), ELogChangeTypeEventDeleted); |
3329 test(logId == TLogId(2*i + 1)); |
3324 TEST2(logId, TLogId(2*i + 1)); |
3330 test(viewIndex == 10 - ((2*i) + 1)); |
3325 TEST2(viewIndex, 10 - ((2*i) + 1)); |
3331 } |
3326 } |
3332 |
3327 |
3333 // Check that changes work after a backup |
3328 // Check that changes work after a backup |
3334 StartBackupL(); |
3329 StartBackupL(); |
3335 DelayL(1000000); |
3330 DelayL(1000000); |
3341 changeObs->StartCollectingChanges(); |
3336 changeObs->StartCollectingChanges(); |
3342 event->SetContact(TLogContactItemId(0)); |
3337 event->SetContact(TLogContactItemId(0)); |
3343 active->StartL(); |
3338 active->StartL(); |
3344 aClient.AddEvent(*event, active->iStatus); |
3339 aClient.AddEvent(*event, active->iStatus); |
3345 CActiveScheduler::Start(); |
3340 CActiveScheduler::Start(); |
3346 test(active->iStatus == KErrNone); |
3341 TEST2(active->iStatus.Int(), KErrNone); |
3347 count = view->CountL(); |
3342 count = view->CountL(); |
3348 test(count == KTestEventNum + 1 - 5); |
3343 TEST2(count, KTestEventNum + 1 - 5); |
3349 test(event->Id() == KTestEventNum + 1); |
3344 TEST2(event->Id(), KTestEventNum + 1); |
3350 |
3345 |
3351 // Check changes |
3346 // Check changes |
3352 test(!changeObs->HaveChanges()); |
3347 TEST(!changeObs->HaveChanges()); |
3353 |
3348 |
3354 // Check view navigation |
3349 // Check view navigation |
3355 i=0; |
3350 i=0; |
3356 test(view->FirstL(active->iStatus)); |
3351 TEST(view->FirstL(active->iStatus)); |
3357 do |
3352 do |
3358 { |
3353 { |
3359 active->StartL(); |
3354 active->StartL(); |
3360 CActiveScheduler::Start(); |
3355 CActiveScheduler::Start(); |
3361 test(active->iStatus == KErrNone); |
3356 TEST2(active->iStatus.Int(), KErrNone); |
3362 RDebug::Print(_L("View Entry[%d]: Id: %d"), i++, view->Event().Id()); |
3357 TheTest.Printf(_L("View Entry[%d]: Id: %d\r\n"), i++, view->Event().Id()); |
3363 } |
3358 } |
3364 while(view->NextL(active->iStatus)); |
3359 while(view->NextL(active->iStatus)); |
3365 RDebug::Print(_L("==\n")); |
3360 TheTest.Printf(_L("==\n")); |
3366 test(i == count); |
3361 TEST2(i, count); |
3367 test(view->FirstL(active->iStatus)); |
3362 TEST(view->FirstL(active->iStatus)); |
3368 active->StartL(); |
3363 active->StartL(); |
3369 CActiveScheduler::Start(); |
3364 CActiveScheduler::Start(); |
3370 test(active->iStatus == KErrNone); |
3365 TEST2(active->iStatus.Int(), KErrNone); |
3371 |
3366 |
3372 // Check that changes work after a backup |
3367 // Check that changes work after a backup |
3373 StartBackupL(); |
3368 StartBackupL(); |
3374 DelayL(1000000); |
3369 DelayL(1000000); |
3375 TestLogClosedL(); |
3370 TestLogClosedL(); |
3379 // Delete event which isn't in view |
3374 // Delete event which isn't in view |
3380 changeObs->StartCollectingChanges(); |
3375 changeObs->StartCollectingChanges(); |
3381 active->StartL(); |
3376 active->StartL(); |
3382 aClient.DeleteEvent(event->Id(), active->iStatus); |
3377 aClient.DeleteEvent(event->Id(), active->iStatus); |
3383 CActiveScheduler::Start(); |
3378 CActiveScheduler::Start(); |
3384 test(active->iStatus == KErrNone); |
3379 TEST2(active->iStatus.Int(), KErrNone); |
3385 count = view->CountL(); |
3380 count = view->CountL(); |
3386 test(count == KTestEventNum + 1 - 5); |
3381 TEST2(count, KTestEventNum + 1 - 5); |
3387 |
3382 |
3388 // Check changes |
3383 // Check changes |
3389 test(!changeObs->HaveChanges()); |
3384 TEST(!changeObs->HaveChanges()); |
3390 |
3385 |
3391 // Check view navigation |
3386 // Check view navigation |
3392 i=0; |
3387 i=0; |
3393 test(view->FirstL(active->iStatus)); |
3388 TEST(view->FirstL(active->iStatus)); |
3394 do |
3389 do |
3395 { |
3390 { |
3396 active->StartL(); |
3391 active->StartL(); |
3397 CActiveScheduler::Start(); |
3392 CActiveScheduler::Start(); |
3398 test(active->iStatus == KErrNone); |
3393 TEST2(active->iStatus.Int(), KErrNone); |
3399 RDebug::Print(_L("View Entry[%d]: Id: %d"), i++, view->Event().Id()); |
3394 TheTest.Printf(_L("View Entry[%d]: Id: %d\r\n"), i++, view->Event().Id()); |
3400 } |
3395 } |
3401 while(view->NextL(active->iStatus)); |
3396 while(view->NextL(active->iStatus)); |
3402 RDebug::Print(_L("==\n")); |
3397 TheTest.Printf(_L("==\n")); |
3403 test(i == count); |
3398 TEST2(i, count); |
3404 test(view->FirstL(active->iStatus)); |
3399 TEST(view->FirstL(active->iStatus)); |
3405 active->StartL(); |
3400 active->StartL(); |
3406 CActiveScheduler::Start(); |
3401 CActiveScheduler::Start(); |
3407 test(active->iStatus == KErrNone); |
3402 TEST2(active->iStatus.Int(), KErrNone); |
3408 |
3403 |
3409 // Check that changes work after a backup |
3404 // Check that changes work after a backup |
3410 StartBackupL(); |
3405 StartBackupL(); |
3411 DelayL(1000000); |
3406 DelayL(1000000); |
3412 TestLogClosedL(); |
3407 TestLogClosedL(); |
3417 changeObs->StartCollectingChanges(); |
3412 changeObs->StartCollectingChanges(); |
3418 event->SetContact(TLogContactItemId(0)); |
3413 event->SetContact(TLogContactItemId(0)); |
3419 active->StartL(); |
3414 active->StartL(); |
3420 aClient.AddEvent(*event, active->iStatus); |
3415 aClient.AddEvent(*event, active->iStatus); |
3421 CActiveScheduler::Start(); |
3416 CActiveScheduler::Start(); |
3422 test(active->iStatus == KErrNone); |
3417 TEST2(active->iStatus.Int(), KErrNone); |
3423 count = view->CountL(); |
3418 count = view->CountL(); |
3424 test(count == KTestEventNum + 1 - 5); |
3419 TEST2(count, KTestEventNum + 1 - 5); |
3425 test(event->Id() == KTestEventNum + 2); |
3420 TEST2(event->Id(), KTestEventNum + 2); |
3426 |
3421 |
3427 // Check changes |
3422 // Check changes |
3428 test(!changeObs->HaveChanges()); |
3423 TEST(!changeObs->HaveChanges()); |
3429 |
3424 |
3430 // Check view navigation |
3425 // Check view navigation |
3431 i=0; |
3426 i=0; |
3432 test(view->FirstL(active->iStatus)); |
3427 TEST(view->FirstL(active->iStatus)); |
3433 do |
3428 do |
3434 { |
3429 { |
3435 active->StartL(); |
3430 active->StartL(); |
3436 CActiveScheduler::Start(); |
3431 CActiveScheduler::Start(); |
3437 test(active->iStatus == KErrNone); |
3432 TEST2(active->iStatus.Int(), KErrNone); |
3438 RDebug::Print(_L("View Entry[%d]: Id: %d"), i++, view->Event().Id()); |
3433 TheTest.Printf(_L("View Entry[%d]: Id: %d\r\n"), i++, view->Event().Id()); |
3439 } |
3434 } |
3440 while(view->NextL(active->iStatus)); |
3435 while(view->NextL(active->iStatus)); |
3441 RDebug::Print(_L("==\n")); |
3436 TheTest.Printf(_L("==\n")); |
3442 test(i == count); |
3437 TEST2(i, count); |
3443 test(view->FirstL(active->iStatus)); |
3438 TEST(view->FirstL(active->iStatus)); |
3444 active->StartL(); |
3439 active->StartL(); |
3445 CActiveScheduler::Start(); |
3440 CActiveScheduler::Start(); |
3446 test(active->iStatus == KErrNone); |
3441 TEST2(active->iStatus.Int(), KErrNone); |
3447 |
3442 |
3448 // Check that changes work after a backup |
3443 // Check that changes work after a backup |
3449 StartBackupL(); |
3444 StartBackupL(); |
3450 DelayL(1000000); |
3445 DelayL(1000000); |
3451 TestLogClosedL(); |
3446 TestLogClosedL(); |
3456 changeObs->StartCollectingChanges(); |
3451 changeObs->StartCollectingChanges(); |
3457 event->SetContact(KTestContact); |
3452 event->SetContact(KTestContact); |
3458 active->StartL(); |
3453 active->StartL(); |
3459 aClient.ChangeEvent(*event, active->iStatus); |
3454 aClient.ChangeEvent(*event, active->iStatus); |
3460 CActiveScheduler::Start(); |
3455 CActiveScheduler::Start(); |
3461 test(active->iStatus == KErrNone); |
3456 TEST2(active->iStatus.Int(), KErrNone); |
3462 count = view->CountL(); |
3457 count = view->CountL(); |
3463 test(count == KTestEventNum + 2 - 5); |
3458 TEST2(count, KTestEventNum + 2 - 5); |
3464 test(event->Id() == KTestEventNum + 2); // Shouldn't change |
3459 TEST2(event->Id(), KTestEventNum + 2); // Shouldn't change |
3465 |
3460 |
3466 // Check changes |
3461 // Check changes |
3467 changeCount = changeObs->Changes().Count(); |
3462 changeCount = changeObs->Changes().Count(); |
3468 test(changeCount == 1); |
3463 TEST2(changeCount, 1); |
3469 type = changeObs->Changes().At(0, logId, viewIndex); |
3464 type = changeObs->Changes().At(0, logId, viewIndex); |
3470 test(type == ELogChangeTypeEventAdded); |
3465 TEST2(type, ELogChangeTypeEventAdded); |
3471 test(logId == KTestEventNum + 2); |
3466 TEST2(logId, KTestEventNum + 2); |
3472 test(viewIndex == 0); |
3467 TEST2(viewIndex, 0); |
3473 |
3468 |
3474 // Check view navigation |
3469 // Check view navigation |
3475 i=0; |
3470 i=0; |
3476 test(view->FirstL(active->iStatus)); |
3471 TEST(view->FirstL(active->iStatus)); |
3477 do |
3472 do |
3478 { |
3473 { |
3479 active->StartL(); |
3474 active->StartL(); |
3480 CActiveScheduler::Start(); |
3475 CActiveScheduler::Start(); |
3481 test(active->iStatus == KErrNone); |
3476 TEST2(active->iStatus.Int(), KErrNone); |
3482 RDebug::Print(_L("View Entry[%d]: Id: %d"), i++, view->Event().Id()); |
3477 TheTest.Printf(_L("View Entry[%d]: Id: %d\r\n"), i++, view->Event().Id()); |
3483 } |
3478 } |
3484 while(view->NextL(active->iStatus)); |
3479 while(view->NextL(active->iStatus)); |
3485 RDebug::Print(_L("==\n")); |
3480 TheTest.Printf(_L("==\n")); |
3486 test(i == count); |
3481 TEST2(i, count); |
3487 test(view->FirstL(active->iStatus)); |
3482 TEST(view->FirstL(active->iStatus)); |
3488 active->StartL(); |
3483 active->StartL(); |
3489 CActiveScheduler::Start(); |
3484 CActiveScheduler::Start(); |
3490 test(active->iStatus == KErrNone); |
3485 TEST2(active->iStatus.Int(), KErrNone); |
3491 |
3486 |
3492 // Check that changes work after a backup |
3487 // Check that changes work after a backup |
3493 StartBackupL(); |
3488 StartBackupL(); |
3494 DelayL(1000000); |
3489 DelayL(1000000); |
3495 TestLogClosedL(); |
3490 TestLogClosedL(); |
3500 changeObs->StartCollectingChanges(); |
3495 changeObs->StartCollectingChanges(); |
3501 event->SetDescription(_L("Test")); |
3496 event->SetDescription(_L("Test")); |
3502 active->StartL(); |
3497 active->StartL(); |
3503 aClient.ChangeEvent(*event, active->iStatus); |
3498 aClient.ChangeEvent(*event, active->iStatus); |
3504 CActiveScheduler::Start(); |
3499 CActiveScheduler::Start(); |
3505 test(active->iStatus == KErrNone); |
3500 TEST2(active->iStatus.Int(), KErrNone); |
3506 count = view->CountL(); |
3501 count = view->CountL(); |
3507 test(count == KTestEventNum + 2 - 5); // Shouldn't change |
3502 TEST2(count, KTestEventNum + 2 - 5); // Shouldn't change |
3508 test(event->Id() == KTestEventNum + 2); // Shouldn't change |
3503 TEST2(event->Id(), KTestEventNum + 2); // Shouldn't change |
3509 |
3504 |
3510 // Check changes |
3505 // Check changes |
3511 changeCount = changeObs->Changes().Count(); |
3506 changeCount = changeObs->Changes().Count(); |
3512 test(changeCount == 1); |
3507 TEST2(changeCount, 1); |
3513 type = changeObs->Changes().At(0, logId, viewIndex); |
3508 type = changeObs->Changes().At(0, logId, viewIndex); |
3514 test(type == ELogChangeTypeEventChanged); |
3509 TEST2(type, ELogChangeTypeEventChanged); |
3515 test(logId == KTestEventNum + 2); |
3510 TEST2(logId, KTestEventNum + 2); |
3516 test(viewIndex == 0); |
3511 TEST2(viewIndex, 0); |
3517 |
3512 |
3518 // Check that changes work after a backup |
3513 // Check that changes work after a backup |
3519 StartBackupL(); |
3514 StartBackupL(); |
3520 DelayL(1000000); |
3515 DelayL(1000000); |
3521 TestLogClosedL(); |
3516 TestLogClosedL(); |
3526 changeObs->StartCollectingChanges(); |
3521 changeObs->StartCollectingChanges(); |
3527 event->SetContact(0); |
3522 event->SetContact(0); |
3528 active->StartL(); |
3523 active->StartL(); |
3529 aClient.ChangeEvent(*event, active->iStatus); |
3524 aClient.ChangeEvent(*event, active->iStatus); |
3530 CActiveScheduler::Start(); |
3525 CActiveScheduler::Start(); |
3531 test(active->iStatus == KErrNone); |
3526 TEST2(active->iStatus.Int(), KErrNone); |
3532 count = view->CountL(); |
3527 count = view->CountL(); |
3533 test(count == KTestEventNum + 2 - 5 - 1); // one less now |
3528 TEST2(count, KTestEventNum + 2 - 5 - 1); // one less now |
3534 |
3529 |
3535 // Check changes |
3530 // Check changes |
3536 changeCount = changeObs->Changes().Count(); |
3531 changeCount = changeObs->Changes().Count(); |
3537 test(changeCount == 1); |
3532 TEST2(changeCount, 1); |
3538 type = changeObs->Changes().At(0, logId, viewIndex); |
3533 type = changeObs->Changes().At(0, logId, viewIndex); |
3539 test(type == ELogChangeTypeEventDeleted); |
3534 TEST2(type, ELogChangeTypeEventDeleted); |
3540 test(logId == KTestEventNum + 2); |
3535 TEST2(logId, KTestEventNum + 2); |
3541 test(viewIndex == 0); |
3536 TEST2(viewIndex, 0); |
3542 |
3537 |
3543 // Navigate part way through the view so we have |
3538 // Navigate part way through the view so we have |
3544 // a cursor position part way through... |
3539 // a cursor position part way through... |
3545 i=0; |
3540 i=0; |
3546 count = view->CountL(); |
3541 count = view->CountL(); |
3547 test(view->FirstL(active->iStatus)); |
3542 TEST(view->FirstL(active->iStatus)); |
3548 do |
3543 do |
3549 { |
3544 { |
3550 active->StartL(); |
3545 active->StartL(); |
3551 CActiveScheduler::Start(); |
3546 CActiveScheduler::Start(); |
3552 test(active->iStatus == KErrNone); |
3547 TEST2(active->iStatus.Int(), KErrNone); |
3553 RDebug::Print(_L("View Entry[%d]: Id: %d"), i++, view->Event().Id()); |
3548 TheTest.Printf(_L("View Entry[%d]: Id: %d\r\n"), i++, view->Event().Id()); |
3554 } |
3549 } |
3555 while(view->NextL(active->iStatus)); |
3550 while(view->NextL(active->iStatus)); |
3556 RDebug::Print(_L("==\n")); |
3551 TheTest.Printf(_L("==\n")); |
3557 test(i == count); |
3552 TEST2(i, count); |
3558 test(view->Event().Id() == TLogId(0)); |
3553 TEST2(view->Event().Id(), TLogId(0)); |
3559 |
3554 |
3560 // Save id |
3555 // Save id |
3561 TLogId savedId = view->Event().Id(); |
3556 TLogId savedId = view->Event().Id(); |
3562 |
3557 |
3563 // Go one back |
3558 // Go one back |
3564 test(view->PreviousL(active->iStatus)); |
3559 TEST(view->PreviousL(active->iStatus)); |
3565 active->StartL(); |
3560 active->StartL(); |
3566 CActiveScheduler::Start(); |
3561 CActiveScheduler::Start(); |
3567 test(active->iStatus == KErrNone); |
3562 TEST2(active->iStatus.Int(), KErrNone); |
3568 |
3563 |
3569 // Check that changes work after a backup |
3564 // Check that changes work after a backup |
3570 StartBackupL(); |
3565 StartBackupL(); |
3571 DelayL(1000000); |
3566 DelayL(1000000); |
3572 TestLogClosedL(); |
3567 TestLogClosedL(); |
3577 changeObs->StartCollectingChanges(); |
3572 changeObs->StartCollectingChanges(); |
3578 event->SetContact(KTestContact); |
3573 event->SetContact(KTestContact); |
3579 active->StartL(); |
3574 active->StartL(); |
3580 aClient.AddEvent(*event, active->iStatus); |
3575 aClient.AddEvent(*event, active->iStatus); |
3581 CActiveScheduler::Start(); |
3576 CActiveScheduler::Start(); |
3582 test(active->iStatus == KErrNone); |
3577 TEST2(active->iStatus.Int(), KErrNone); |
3583 count = view->CountL(); |
3578 count = view->CountL(); |
3584 test(count == KTestEventNum + 2 - 5); // one more now |
3579 TEST2(count, KTestEventNum + 2 - 5); // one more now |
3585 test(event->Id() == KTestEventNum + 3); |
3580 TEST2(event->Id(), KTestEventNum + 3); |
3586 |
3581 |
3587 // Check changes |
3582 // Check changes |
3588 changeCount = changeObs->Changes().Count(); |
3583 changeCount = changeObs->Changes().Count(); |
3589 test(changeCount == 1); |
3584 TEST2(changeCount, 1); |
3590 type = changeObs->Changes().At(0, logId, viewIndex); |
3585 type = changeObs->Changes().At(0, logId, viewIndex); |
3591 test(type == ELogChangeTypeEventAdded); |
3586 TEST2(type, ELogChangeTypeEventAdded); |
3592 test(logId == KTestEventNum + 3); |
3587 TEST2(logId, KTestEventNum + 3); |
3593 test(viewIndex == 0); |
3588 TEST2(viewIndex, 0); |
3594 |
3589 |
3595 // Check we can still go forward to the last record |
3590 // Check we can still go forward to the last record |
3596 test(view->NextL(active->iStatus)); |
3591 TEST(view->NextL(active->iStatus)); |
3597 active->StartL(); |
3592 active->StartL(); |
3598 CActiveScheduler::Start(); |
3593 CActiveScheduler::Start(); |
3599 test(active->iStatus == KErrNone); |
3594 TEST2(active->iStatus.Int(), KErrNone); |
3600 test(view->Event().Id() == savedId); |
3595 TEST2(view->Event().Id(), savedId); |
3601 |
3596 |
3602 // Go one back |
3597 // Go one back |
3603 test(view->PreviousL(active->iStatus)); |
3598 TEST(view->PreviousL(active->iStatus)); |
3604 active->StartL(); |
3599 active->StartL(); |
3605 CActiveScheduler::Start(); |
3600 CActiveScheduler::Start(); |
3606 test(active->iStatus == KErrNone); |
3601 TEST2(active->iStatus.Int(), KErrNone); |
3607 |
3602 |
3608 // Check that changes work after a backup |
3603 // Check that changes work after a backup |
3609 StartBackupL(); |
3604 StartBackupL(); |
3610 DelayL(1000000); |
3605 DelayL(1000000); |
3611 TestLogClosedL(); |
3606 TestLogClosedL(); |
3616 savedId = view->Event().Id(); |
3611 savedId = view->Event().Id(); |
3617 changeObs->StartCollectingChanges(); |
3612 changeObs->StartCollectingChanges(); |
3618 active->StartL(); |
3613 active->StartL(); |
3619 aClient.DeleteEvent(savedId, active->iStatus); |
3614 aClient.DeleteEvent(savedId, active->iStatus); |
3620 CActiveScheduler::Start(); |
3615 CActiveScheduler::Start(); |
3621 test(active->iStatus == KErrNone); |
3616 TEST2(active->iStatus.Int(), KErrNone); |
3622 count = view->CountL(); |
3617 count = view->CountL(); |
3623 test(count == KTestEventNum + 2 - 5 - 1); // one less |
3618 TEST2(count, KTestEventNum + 2 - 5 - 1); // one less |
3624 |
3619 |
3625 // Check changes |
3620 // Check changes |
3626 changeCount = changeObs->Changes().Count(); |
3621 changeCount = changeObs->Changes().Count(); |
3627 test(changeCount == 1); |
3622 TEST2(changeCount, 1); |
3628 type = changeObs->Changes().At(0, logId, viewIndex); |
3623 type = changeObs->Changes().At(0, logId, viewIndex); |
3629 test(type == ELogChangeTypeEventDeleted); |
3624 TEST2(type, ELogChangeTypeEventDeleted); |
3630 test(logId == savedId); |
3625 TEST2(logId, savedId); |
3631 test(viewIndex == KTestEventNum + 2 - 5 - 2); // last but one event |
3626 TEST2(viewIndex, KTestEventNum + 2 - 5 - 2); // last but one event |
3632 |
3627 |
3633 // Check we're now at the end of the view |
3628 // Check we're now at the end of the view |
3634 test(!view->NextL(active->iStatus)); |
3629 TEST(!view->NextL(active->iStatus)); |
3635 |
3630 |
3636 // Go to the first record |
3631 // Go to the first record |
3637 test(view->FirstL(active->iStatus)); |
3632 TEST(view->FirstL(active->iStatus)); |
3638 active->StartL(); |
3633 active->StartL(); |
3639 CActiveScheduler::Start(); |
3634 CActiveScheduler::Start(); |
3640 test(active->iStatus == KErrNone); |
3635 TEST2(active->iStatus.Int(), KErrNone); |
3641 |
3636 |
3642 // Check that changes work after a backup |
3637 // Check that changes work after a backup |
3643 StartBackupL(); |
3638 StartBackupL(); |
3644 DelayL(1000000); |
3639 DelayL(1000000); |
3645 TestLogClosedL(); |
3640 TestLogClosedL(); |
3650 savedId = view->Event().Id(); |
3645 savedId = view->Event().Id(); |
3651 changeObs->StartCollectingChanges(); |
3646 changeObs->StartCollectingChanges(); |
3652 active->StartL(); |
3647 active->StartL(); |
3653 aClient.DeleteEvent(savedId, active->iStatus); |
3648 aClient.DeleteEvent(savedId, active->iStatus); |
3654 CActiveScheduler::Start(); |
3649 CActiveScheduler::Start(); |
3655 test(active->iStatus == KErrNone); |
3650 TEST2(active->iStatus.Int(), KErrNone); |
3656 count = view->CountL(); |
3651 count = view->CountL(); |
3657 test(count == KTestEventNum - 5); |
3652 TEST2(count, KTestEventNum - 5); |
3658 |
3653 |
3659 // Check changes |
3654 // Check changes |
3660 changeCount = changeObs->Changes().Count(); |
3655 changeCount = changeObs->Changes().Count(); |
3661 test(changeCount == 1); |
3656 TEST2(changeCount, 1); |
3662 type = changeObs->Changes().At(0, logId, viewIndex); |
3657 type = changeObs->Changes().At(0, logId, viewIndex); |
3663 test(type == ELogChangeTypeEventDeleted); |
3658 TEST2(type, ELogChangeTypeEventDeleted); |
3664 test(logId == savedId); |
3659 TEST2(logId, savedId); |
3665 test(viewIndex == 0); // first item |
3660 TEST2(viewIndex, 0); // first item |
3666 |
3661 |
3667 // Check 'next' navigation can be performed correctly |
3662 // Check 'next' navigation can be performed correctly |
3668 count = 0; |
3663 count = 0; |
3669 view->NextL(active->iStatus); |
3664 view->NextL(active->iStatus); |
3670 do |
3665 do |
3671 { |
3666 { |
3672 active->StartL(); |
3667 active->StartL(); |
3673 CActiveScheduler::Start(); |
3668 CActiveScheduler::Start(); |
3674 test(active->iStatus == KErrNone); |
3669 TEST2(active->iStatus.Int(), KErrNone); |
3675 ++count; |
3670 ++count; |
3676 } |
3671 } |
3677 while(view->NextL(active->iStatus)); |
3672 while(view->NextL(active->iStatus)); |
3678 test(count == KTestEventNum - 5 - 1); |
3673 TEST2(count, KTestEventNum - 5 - 1); |
3679 |
3674 |
3680 // Check last record |
3675 // Check last record |
3681 savedId = view->Event().Id(); |
3676 savedId = view->Event().Id(); |
3682 test(view->LastL(active->iStatus)); |
3677 TEST(view->LastL(active->iStatus)); |
3683 active->StartL(); |
3678 active->StartL(); |
3684 CActiveScheduler::Start(); |
3679 CActiveScheduler::Start(); |
3685 test(active->iStatus == KErrNone); |
3680 TEST2(active->iStatus.Int(), KErrNone); |
3686 test(savedId == view->Event().Id()); |
3681 TEST2(savedId, view->Event().Id()); |
3687 |
3682 |
3688 // Check that changes work after a backup |
3683 // Check that changes work after a backup |
3689 StartBackupL(); |
3684 StartBackupL(); |
3690 DelayL(1000000); |
3685 DelayL(1000000); |
3691 TestLogClosedL(); |
3686 TestLogClosedL(); |
3696 savedId = view->Event().Id(); |
3691 savedId = view->Event().Id(); |
3697 changeObs->StartCollectingChanges(); |
3692 changeObs->StartCollectingChanges(); |
3698 active->StartL(); |
3693 active->StartL(); |
3699 aClient.DeleteEvent(savedId, active->iStatus); |
3694 aClient.DeleteEvent(savedId, active->iStatus); |
3700 CActiveScheduler::Start(); |
3695 CActiveScheduler::Start(); |
3701 test(active->iStatus == KErrNone); |
3696 TEST2(active->iStatus.Int(), KErrNone); |
3702 count = view->CountL(); |
3697 count = view->CountL(); |
3703 test(count == KTestEventNum - 6); |
3698 TEST2(count, KTestEventNum - 6); |
3704 |
3699 |
3705 // Check changes |
3700 // Check changes |
3706 changeCount = changeObs->Changes().Count(); |
3701 changeCount = changeObs->Changes().Count(); |
3707 test(changeCount == 1); |
3702 TEST2(changeCount, 1); |
3708 type = changeObs->Changes().At(0, logId, viewIndex); |
3703 type = changeObs->Changes().At(0, logId, viewIndex); |
3709 test(type == ELogChangeTypeEventDeleted); |
3704 TEST2(type, ELogChangeTypeEventDeleted); |
3710 test(logId == savedId); |
3705 TEST2(logId, savedId); |
3711 test(viewIndex == count); // There's now one less item, and we deleted the last item of the previous view |
3706 TEST2(viewIndex, count); // There's now one less item, and we deleted the last item of the previous view |
3712 |
3707 |
3713 // Check we're still at the end of the view |
3708 // Check we're still at the end of the view |
3714 test(!view->NextL(active->iStatus)); |
3709 TEST(!view->NextL(active->iStatus)); |
3715 |
3710 |
3716 CleanupStack::PopAndDestroy(5, event); // view, changeObs, active, filter, event |
3711 CleanupStack::PopAndDestroy(5, event); // view, changeObs, active, filter, event |
3717 } |
3712 } |
3718 |
3713 |
3719 /** |
3714 /** |
3726 @SYMTestExpectedResults Test must not fail |
3721 @SYMTestExpectedResults Test must not fail |
3727 @SYMREQ REQ0000 |
3722 @SYMREQ REQ0000 |
3728 */ |
3723 */ |
3729 LOCAL_C void TestViewChangeEvents2L(CLogClient& aClient) |
3724 LOCAL_C void TestViewChangeEvents2L(CLogClient& aClient) |
3730 { |
3725 { |
3731 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0870 ")); |
3726 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0870 ")); |
3732 // Transients |
3727 // Transients |
3733 TInt i=0; |
3728 TInt i=0; |
3734 TInt count; |
3729 TInt count; |
3735 TBuf<1> description; description.SetLength(1); |
3730 TBuf<1> description; description.SetLength(1); |
3736 TInt changeCount; |
3731 TInt changeCount; |
3786 // |
3781 // |
3787 active->StartL(); |
3782 active->StartL(); |
3788 aClient.AddEvent(*event, active->iStatus); |
3783 aClient.AddEvent(*event, active->iStatus); |
3789 CActiveScheduler::Start(); |
3784 CActiveScheduler::Start(); |
3790 TEST2(active->iStatus.Int(), KErrNone); |
3785 TEST2(active->iStatus.Int(), KErrNone); |
3791 TEST(event->Id() == runningNewId++); |
3786 TEST2(event->Id(), runningNewId++); |
3792 User::After(1 * 1000000); |
3787 User::After(1 * 1000000); |
3793 } |
3788 } |
3794 // |
3789 // |
3795 TEST2(view->CountL(), 0); |
3790 TEST2(view->CountL(), 0); |
3796 active->StartL(); |
3791 active->StartL(); |
3806 do |
3801 do |
3807 { |
3802 { |
3808 active->StartL(); |
3803 active->StartL(); |
3809 CActiveScheduler::Start(); |
3804 CActiveScheduler::Start(); |
3810 TEST2(active->iStatus.Int(), KErrNone); |
3805 TEST2(active->iStatus.Int(), KErrNone); |
3811 RDebug::Print(_L("View Entry[%d]: Id: %d\n"), i++, view->Event().Id()); |
3806 TheTest.Printf(_L("View Entry[%d]: Id: %d\r\n"), i++, view->Event().Id()); |
3812 } |
3807 } |
3813 while(view->NextL(active->iStatus)); |
3808 while(view->NextL(active->iStatus)); |
3814 |
3809 |
3815 // Check addition change events |
3810 // Check addition change events |
3816 res = view->FirstL(active->iStatus); |
3811 res = view->FirstL(active->iStatus); |
3827 changeObs->StartCollectingChanges(); |
3822 changeObs->StartCollectingChanges(); |
3828 active->StartL(); |
3823 active->StartL(); |
3829 aClient.AddEvent(*event, active->iStatus); |
3824 aClient.AddEvent(*event, active->iStatus); |
3830 CActiveScheduler::Start(); |
3825 CActiveScheduler::Start(); |
3831 TEST2(active->iStatus.Int(), KErrNone); |
3826 TEST2(active->iStatus.Int(), KErrNone); |
3832 TEST(event->Id() == runningNewId++); |
3827 TEST2(event->Id(), runningNewId++); |
3833 |
3828 |
3834 // Check changes |
3829 // Check changes |
3835 changeCount = changeObs->Changes().Count(); |
3830 changeCount = changeObs->Changes().Count(); |
3836 TEST2(changeCount, 1); |
3831 TEST2(changeCount, 1); |
3837 type = changeObs->Changes().At(0, logId, viewIndex); |
3832 type = changeObs->Changes().At(0, logId, viewIndex); |
3838 TEST2(type, ELogChangeTypeEventAdded); |
3833 TEST2(type, ELogChangeTypeEventAdded); |
3839 TEST(logId == runningNewId-1); |
3834 TEST2(logId, runningNewId-1); |
3840 TEST2(viewIndex, 0); // 8, [7], 6, 5, 4, 2, 1, 0 |
3835 TEST2(viewIndex, 0); // 8, [7], 6, 5, 4, 2, 1, 0 |
3841 |
3836 |
3842 // Check we can go forward |
3837 // Check we can go forward |
3843 res = view->NextL(active->iStatus); |
3838 res = view->NextL(active->iStatus); |
3844 TEST(res); |
3839 TEST(res); |
3857 res = view->PreviousL(active->iStatus); |
3852 res = view->PreviousL(active->iStatus); |
3858 TEST(res); |
3853 TEST(res); |
3859 active->StartL(); |
3854 active->StartL(); |
3860 CActiveScheduler::Start(); |
3855 CActiveScheduler::Start(); |
3861 TEST2(active->iStatus.Int(), KErrNone); // [8], 7, 6, 5, 4, 2, 1, 0 |
3856 TEST2(active->iStatus.Int(), KErrNone); // [8], 7, 6, 5, 4, 2, 1, 0 |
3862 TEST(view->Event().Id() == TLogId(KChangeEventTest2NumberOfEventsInView+1)); |
3857 TEST2(view->Event().Id(), TLogId(KChangeEventTest2NumberOfEventsInView+1)); |
3863 |
3858 |
3864 // Delete added event |
3859 // Delete added event |
3865 changeObs->ResetChanges(); |
3860 changeObs->ResetChanges(); |
3866 changeCount = changeObs->Changes().Count(); |
3861 changeCount = changeObs->Changes().Count(); |
3867 TEST2(changeCount, 0); |
3862 TEST2(changeCount, 0); |
3873 // Check deletion changes |
3868 // Check deletion changes |
3874 changeCount = changeObs->Changes().Count(); |
3869 changeCount = changeObs->Changes().Count(); |
3875 TEST2(changeCount, 1); |
3870 TEST2(changeCount, 1); |
3876 type = changeObs->Changes().At(0, logId, viewIndex); |
3871 type = changeObs->Changes().At(0, logId, viewIndex); |
3877 TEST2(type, ELogChangeTypeEventDeleted); |
3872 TEST2(type, ELogChangeTypeEventDeleted); |
3878 TEST(logId == runningNewId-1); |
3873 TEST2(logId, runningNewId-1); |
3879 TEST2(viewIndex, 0); |
3874 TEST2(viewIndex, 0); |
3880 |
3875 |
3881 // Go to end of view |
3876 // Go to end of view |
3882 res = view->LastL(active->iStatus); |
3877 res = view->LastL(active->iStatus); |
3883 TEST(res); |
3878 TEST(res); |
3884 active->StartL(); |
3879 active->StartL(); |
3885 CActiveScheduler::Start(); |
3880 CActiveScheduler::Start(); |
3886 TEST2(active->iStatus.Int(), KErrNone); |
3881 TEST2(active->iStatus.Int(), KErrNone); |
3887 TEST(view->Event().Id() == TLogId(0)); // 7, 6, 5, 4, 2, 1, [0] |
3882 TEST2(view->Event().Id(), TLogId(0)); // 7, 6, 5, 4, 2, 1, [0] |
3888 |
3883 |
3889 // Add new event |
3884 // Add new event |
3890 description[0] = TUint16('X'); |
3885 description[0] = TUint16('X'); |
3891 event->SetDescription(description); |
3886 event->SetDescription(description); |
3892 // |
3887 // |
3893 changeObs->StartCollectingChanges(); |
3888 changeObs->StartCollectingChanges(); |
3894 active->StartL(); |
3889 active->StartL(); |
3895 aClient.AddEvent(*event, active->iStatus); |
3890 aClient.AddEvent(*event, active->iStatus); |
3896 CActiveScheduler::Start(); |
3891 CActiveScheduler::Start(); |
3897 TEST2(active->iStatus.Int(), KErrNone); |
3892 TEST2(active->iStatus.Int(), KErrNone); |
3898 TEST(event->Id() == runningNewId++); |
3893 TEST2(event->Id(), runningNewId++); |
3899 |
3894 |
3900 // Check changes |
3895 // Check changes |
3901 changeCount = changeObs->Changes().Count(); |
3896 changeCount = changeObs->Changes().Count(); |
3902 TEST2(changeCount, 1); |
3897 TEST2(changeCount, 1); |
3903 type = changeObs->Changes().At(0, logId, viewIndex); |
3898 type = changeObs->Changes().At(0, logId, viewIndex); |
3904 TEST2(type, ELogChangeTypeEventAdded); |
3899 TEST2(type, ELogChangeTypeEventAdded); |
3905 TEST(logId == runningNewId-1); |
3900 TEST2(logId, runningNewId-1); |
3906 TEST2(viewIndex, 0); // 9, 7, 6, 5, 4, 2, 1, [0] |
3901 TEST2(viewIndex, 0); // 9, 7, 6, 5, 4, 2, 1, [0] |
3907 |
3902 |
3908 // Check we can't go forward |
3903 // Check we can't go forward |
3909 res = view->NextL(active->iStatus); |
3904 res = view->NextL(active->iStatus); |
3910 TEST(!res); |
3905 TEST(!res); |
3913 res = view->FirstL(active->iStatus); |
3908 res = view->FirstL(active->iStatus); |
3914 TEST(res); |
3909 TEST(res); |
3915 active->StartL(); |
3910 active->StartL(); |
3916 CActiveScheduler::Start(); |
3911 CActiveScheduler::Start(); |
3917 TEST2(active->iStatus.Int(), KErrNone); |
3912 TEST2(active->iStatus.Int(), KErrNone); |
3918 TEST(view->Event().Id() == TLogId(runningNewId-1)); // 9, 7, 6, 5, 4, 2, 1, [0] |
3913 TEST2(view->Event().Id(), TLogId(runningNewId-1)); // 9, 7, 6, 5, 4, 2, 1, [0] |
3919 |
3914 |
3920 // Delete added event |
3915 // Delete added event |
3921 changeObs->ResetChanges(); |
3916 changeObs->ResetChanges(); |
3922 active->StartL(); |
3917 active->StartL(); |
3923 aClient.DeleteEvent(view->Event().Id(), active->iStatus); |
3918 aClient.DeleteEvent(view->Event().Id(), active->iStatus); |
3927 // Check deletion changes |
3922 // Check deletion changes |
3928 changeCount = changeObs->Changes().Count(); |
3923 changeCount = changeObs->Changes().Count(); |
3929 TEST2(changeCount, 1); |
3924 TEST2(changeCount, 1); |
3930 type = changeObs->Changes().At(0, logId, viewIndex); |
3925 type = changeObs->Changes().At(0, logId, viewIndex); |
3931 TEST2(type, ELogChangeTypeEventDeleted); |
3926 TEST2(type, ELogChangeTypeEventDeleted); |
3932 TEST(logId == runningNewId-1); |
3927 TEST2(logId, runningNewId-1); |
3933 TEST2(viewIndex, 0); |
3928 TEST2(viewIndex, 0); |
3934 |
3929 |
3935 // Go part way through view |
3930 // Go part way through view |
3936 res = view->NextL(active->iStatus); |
3931 res = view->NextL(active->iStatus); |
3937 TEST(res); |
3932 TEST(res); |
3953 changeObs->StartCollectingChanges(); |
3948 changeObs->StartCollectingChanges(); |
3954 active->StartL(); |
3949 active->StartL(); |
3955 aClient.AddEvent(*event, active->iStatus); |
3950 aClient.AddEvent(*event, active->iStatus); |
3956 CActiveScheduler::Start(); |
3951 CActiveScheduler::Start(); |
3957 TEST2(active->iStatus.Int(), KErrNone); |
3952 TEST2(active->iStatus.Int(), KErrNone); |
3958 TEST(event->Id() == runningNewId++); |
3953 TEST2(event->Id(), runningNewId++); |
3959 |
3954 |
3960 // Check changes |
3955 // Check changes |
3961 changeCount = changeObs->Changes().Count(); |
3956 changeCount = changeObs->Changes().Count(); |
3962 TEST2(changeCount, 1); |
3957 TEST2(changeCount, 1); |
3963 type = changeObs->Changes().At(0, logId, viewIndex); |
3958 type = changeObs->Changes().At(0, logId, viewIndex); |
4033 changeObs->StartCollectingChanges(); |
4028 changeObs->StartCollectingChanges(); |
4034 aClient.ChangeEvent(*event, active->iStatus); |
4029 aClient.ChangeEvent(*event, active->iStatus); |
4035 CActiveScheduler::Start(); |
4030 CActiveScheduler::Start(); |
4036 TEST2(active->iStatus.Int(), KErrNone); |
4031 TEST2(active->iStatus.Int(), KErrNone); |
4037 count = view->CountL(); |
4032 count = view->CountL(); |
4038 TEST(count == KChangeEventTest2NumberOfEventsInView+1); |
4033 TEST2(count, KChangeEventTest2NumberOfEventsInView+1); |
4039 |
4034 |
4040 // Check changes |
4035 // Check changes |
4041 changeCount = changeObs->Changes().Count(); |
4036 changeCount = changeObs->Changes().Count(); |
4042 TEST2(changeCount, 1); |
4037 TEST2(changeCount, 1); |
4043 type = changeObs->Changes().At(0, logId, viewIndex); |
4038 type = changeObs->Changes().At(0, logId, viewIndex); |
4231 active->StartL(); |
4226 active->StartL(); |
4232 aClient.DeleteEvent(TLogId(4), active->iStatus); |
4227 aClient.DeleteEvent(TLogId(4), active->iStatus); |
4233 CActiveScheduler::Start(); |
4228 CActiveScheduler::Start(); |
4234 TEST2(active->iStatus.Int(), KErrNone); |
4229 TEST2(active->iStatus.Int(), KErrNone); |
4235 count = view->CountL(); |
4230 count = view->CountL(); |
4236 TEST(count == KChangeEventTest2NumberOfEventsInView - 1); |
4231 TEST2(count, KChangeEventTest2NumberOfEventsInView - 1); |
4237 changeCount = changeObs->Changes().Count(); |
4232 changeCount = changeObs->Changes().Count(); |
4238 TEST2(changeCount, 1); |
4233 TEST2(changeCount, 1); |
4239 type = changeObs->Changes().At(0, logId, viewIndex); |
4234 type = changeObs->Changes().At(0, logId, viewIndex); |
4240 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4235 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4241 TEST2(logId, TLogId(4)); |
4236 TEST2(logId, TLogId(4)); |
4245 active->StartL(); |
4240 active->StartL(); |
4246 aClient.DeleteEvent(TLogId(7), active->iStatus); |
4241 aClient.DeleteEvent(TLogId(7), active->iStatus); |
4247 CActiveScheduler::Start(); |
4242 CActiveScheduler::Start(); |
4248 TEST2(active->iStatus.Int(), KErrNone); |
4243 TEST2(active->iStatus.Int(), KErrNone); |
4249 count = view->CountL(); |
4244 count = view->CountL(); |
4250 TEST(count == KChangeEventTest2NumberOfEventsInView - 2); |
4245 TEST2(count, KChangeEventTest2NumberOfEventsInView - 2); |
4251 changeCount = changeObs->Changes().Count(); |
4246 changeCount = changeObs->Changes().Count(); |
4252 TEST2(changeCount, 1); |
4247 TEST2(changeCount, 1); |
4253 type = changeObs->Changes().At(0, logId, viewIndex); |
4248 type = changeObs->Changes().At(0, logId, viewIndex); |
4254 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4249 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4255 TEST2(logId, TLogId(7)); |
4250 TEST2(logId, TLogId(7)); |
4259 active->StartL(); |
4254 active->StartL(); |
4260 aClient.DeleteEvent(TLogId(0), active->iStatus); |
4255 aClient.DeleteEvent(TLogId(0), active->iStatus); |
4261 CActiveScheduler::Start(); |
4256 CActiveScheduler::Start(); |
4262 TEST2(active->iStatus.Int(), KErrNone); |
4257 TEST2(active->iStatus.Int(), KErrNone); |
4263 count = view->CountL(); |
4258 count = view->CountL(); |
4264 TEST(count == KChangeEventTest2NumberOfEventsInView - 3); |
4259 TEST2(count, KChangeEventTest2NumberOfEventsInView - 3); |
4265 changeCount = changeObs->Changes().Count(); |
4260 changeCount = changeObs->Changes().Count(); |
4266 TEST2(changeCount, 1); |
4261 TEST2(changeCount, 1); |
4267 type = changeObs->Changes().At(0, logId, viewIndex); |
4262 type = changeObs->Changes().At(0, logId, viewIndex); |
4268 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4263 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4269 TEST2(logId, TLogId(0)); |
4264 TEST2(logId, TLogId(0)); |
4273 active->StartL(); |
4268 active->StartL(); |
4274 aClient.DeleteEvent(TLogId(5), active->iStatus); |
4269 aClient.DeleteEvent(TLogId(5), active->iStatus); |
4275 CActiveScheduler::Start(); |
4270 CActiveScheduler::Start(); |
4276 TEST2(active->iStatus.Int(), KErrNone); |
4271 TEST2(active->iStatus.Int(), KErrNone); |
4277 count = view->CountL(); |
4272 count = view->CountL(); |
4278 TEST(count == KChangeEventTest2NumberOfEventsInView - 4); |
4273 TEST2(count, KChangeEventTest2NumberOfEventsInView - 4); |
4279 changeCount = changeObs->Changes().Count(); |
4274 changeCount = changeObs->Changes().Count(); |
4280 TEST2(changeCount, 1); |
4275 TEST2(changeCount, 1); |
4281 type = changeObs->Changes().At(0, logId, viewIndex); |
4276 type = changeObs->Changes().At(0, logId, viewIndex); |
4282 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4277 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4283 TEST2(logId, TLogId(5)); |
4278 TEST2(logId, TLogId(5)); |
4287 active->StartL(); |
4282 active->StartL(); |
4288 aClient.DeleteEvent(TLogId(2), active->iStatus); |
4283 aClient.DeleteEvent(TLogId(2), active->iStatus); |
4289 CActiveScheduler::Start(); |
4284 CActiveScheduler::Start(); |
4290 TEST2(active->iStatus.Int(), KErrNone); |
4285 TEST2(active->iStatus.Int(), KErrNone); |
4291 count = view->CountL(); |
4286 count = view->CountL(); |
4292 TEST(count == KChangeEventTest2NumberOfEventsInView - 5); |
4287 TEST2(count, KChangeEventTest2NumberOfEventsInView - 5); |
4293 changeCount = changeObs->Changes().Count(); |
4288 changeCount = changeObs->Changes().Count(); |
4294 TEST2(changeCount, 1); |
4289 TEST2(changeCount, 1); |
4295 type = changeObs->Changes().At(0, logId, viewIndex); |
4290 type = changeObs->Changes().At(0, logId, viewIndex); |
4296 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4291 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4297 TEST2(logId, TLogId(2)); |
4292 TEST2(logId, TLogId(2)); |
4301 active->StartL(); |
4296 active->StartL(); |
4302 aClient.DeleteEvent(TLogId(6), active->iStatus); |
4297 aClient.DeleteEvent(TLogId(6), active->iStatus); |
4303 CActiveScheduler::Start(); |
4298 CActiveScheduler::Start(); |
4304 TEST2(active->iStatus.Int(), KErrNone); |
4299 TEST2(active->iStatus.Int(), KErrNone); |
4305 count = view->CountL(); |
4300 count = view->CountL(); |
4306 TEST(count == KChangeEventTest2NumberOfEventsInView - 6); |
4301 TEST2(count, KChangeEventTest2NumberOfEventsInView - 6); |
4307 changeCount = changeObs->Changes().Count(); |
4302 changeCount = changeObs->Changes().Count(); |
4308 TEST2(changeCount, 1); |
4303 TEST2(changeCount, 1); |
4309 type = changeObs->Changes().At(0, logId, viewIndex); |
4304 type = changeObs->Changes().At(0, logId, viewIndex); |
4310 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4305 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4311 TEST2(logId, TLogId(6)); |
4306 TEST2(logId, TLogId(6)); |
4334 active->StartL(); |
4329 active->StartL(); |
4335 aClient.DeleteEvent(TLogId(1), active->iStatus); |
4330 aClient.DeleteEvent(TLogId(1), active->iStatus); |
4336 CActiveScheduler::Start(); |
4331 CActiveScheduler::Start(); |
4337 TEST2(active->iStatus.Int(), KErrNone); |
4332 TEST2(active->iStatus.Int(), KErrNone); |
4338 count = view->CountL(); |
4333 count = view->CountL(); |
4339 TEST(count == KChangeEventTest2NumberOfEventsInView - 7); |
4334 TEST2(count, KChangeEventTest2NumberOfEventsInView - 7); |
4340 changeCount = changeObs->Changes().Count(); |
4335 changeCount = changeObs->Changes().Count(); |
4341 TEST2(changeCount, 1); |
4336 TEST2(changeCount, 1); |
4342 type = changeObs->Changes().At(0, logId, viewIndex); |
4337 type = changeObs->Changes().At(0, logId, viewIndex); |
4343 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4338 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4344 TEST2(logId, TLogId(1)); |
4339 TEST2(logId, TLogId(1)); |
4368 @SYMTestExpectedResults Test must not fail |
4363 @SYMTestExpectedResults Test must not fail |
4369 @SYMREQ REQ0000 |
4364 @SYMREQ REQ0000 |
4370 */ |
4365 */ |
4371 LOCAL_C void TestViewChangeEvents2aL(CLogClient& aClient) |
4366 LOCAL_C void TestViewChangeEvents2aL(CLogClient& aClient) |
4372 { |
4367 { |
4373 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0871 ")); |
4368 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0871 ")); |
4374 // Transients |
4369 // Transients |
4375 TInt i=0; |
4370 TInt i=0; |
4376 TInt count; |
4371 TInt count; |
4377 TBuf<1> description; description.SetLength(1); |
4372 TBuf<1> description; description.SetLength(1); |
4378 TInt changeCount; |
4373 TInt changeCount; |
4427 event->SetDescription(description); |
4422 event->SetDescription(description); |
4428 // |
4423 // |
4429 active->StartL(); |
4424 active->StartL(); |
4430 aClient.AddEvent(*event, active->iStatus); |
4425 aClient.AddEvent(*event, active->iStatus); |
4431 CActiveScheduler::Start(); |
4426 CActiveScheduler::Start(); |
4432 test(active->iStatus == KErrNone); |
4427 TEST2(active->iStatus.Int(), KErrNone); |
4433 test(event->Id() == runningNewId++); |
4428 TEST2(event->Id(), runningNewId++); |
4434 User::After(1 * 1000000); |
4429 User::After(1 * 1000000); |
4435 } |
4430 } |
4436 // |
4431 // |
4437 test(view->CountL() == 0); |
4432 TEST2(view->CountL(), 0); |
4438 active->StartL(); |
4433 active->StartL(); |
4439 test(view->SetFilterL(*filter, active->iStatus)); |
4434 TEST(view->SetFilterL(*filter, active->iStatus)); |
4440 CActiveScheduler::Start(); |
4435 CActiveScheduler::Start(); |
4441 test(active->iStatus == KErrNone); |
4436 TEST2(active->iStatus.Int(), KErrNone); |
4442 count = view->CountL(); |
4437 count = view->CountL(); |
4443 test(count == KChangeEventTest2NumberOfEventsInView); |
4438 TEST2(count, KChangeEventTest2NumberOfEventsInView); |
4444 |
4439 |
4445 |
4440 |
4446 test(view->FirstL(active->iStatus)); |
4441 TEST(view->FirstL(active->iStatus)); |
4447 do |
4442 do |
4448 { |
4443 { |
4449 active->StartL(); |
4444 active->StartL(); |
4450 CActiveScheduler::Start(); |
4445 CActiveScheduler::Start(); |
4451 test(active->iStatus == KErrNone); |
4446 TEST2(active->iStatus.Int(), KErrNone); |
4452 RDebug::Print(_L("View Entry[%d]: Id: %d"), i++, view->Event().Id()); |
4447 TheTest.Printf(_L("View Entry[%d]: Id: %d\r\n"), i++, view->Event().Id()); |
4453 } |
4448 } |
4454 while(view->NextL(active->iStatus)); |
4449 while(view->NextL(active->iStatus)); |
4455 |
4450 |
4456 // Check addition change events |
4451 // Check addition change events |
4457 test(view->FirstL(active->iStatus)); |
4452 TEST(view->FirstL(active->iStatus)); |
4458 active->StartL(); |
4453 active->StartL(); |
4459 CActiveScheduler::Start(); |
4454 CActiveScheduler::Start(); |
4460 test(active->iStatus == KErrNone); // [7], 6, 5, 4, 2, 1, 0 |
4455 TEST2(active->iStatus.Int(), KErrNone); // [7], 6, 5, 4, 2, 1, 0 |
4461 test(view->Event().Id() == 7); |
4456 TEST2(view->Event().Id(), 7); |
4462 |
4457 |
4463 // Add a new entry - should appear as the first item in the view |
4458 // Add a new entry - should appear as the first item in the view |
4464 description[0] = TUint16('X'); |
4459 description[0] = TUint16('X'); |
4465 event->SetDescription(description); |
4460 event->SetDescription(description); |
4466 |
4461 |
4474 // |
4469 // |
4475 changeObs->StartCollectingChanges(); |
4470 changeObs->StartCollectingChanges(); |
4476 active->StartL(); |
4471 active->StartL(); |
4477 aClient.AddEvent(*event, active->iStatus); |
4472 aClient.AddEvent(*event, active->iStatus); |
4478 CActiveScheduler::Start(); |
4473 CActiveScheduler::Start(); |
4479 test(active->iStatus == KErrNone); |
4474 TEST2(active->iStatus.Int(), KErrNone); |
4480 test(event->Id() == runningNewId++); |
4475 TEST2(event->Id(), runningNewId++); |
4481 |
4476 |
4482 // Check changes |
4477 // Check changes |
4483 changeCount = changeObs->Changes().Count(); |
4478 changeCount = changeObs->Changes().Count(); |
4484 test(changeCount == 1); |
4479 TEST2(changeCount, 1); |
4485 type = changeObs->Changes().At(0, logId, viewIndex); |
4480 type = changeObs->Changes().At(0, logId, viewIndex); |
4486 test(type == ELogChangeTypeEventAdded); |
4481 TEST2(type, ELogChangeTypeEventAdded); |
4487 test(logId == runningNewId-1); |
4482 TEST2(logId, runningNewId-1); |
4488 test(viewIndex == 0); // 8, [7], 6, 5, 4, 2, 1, 0 |
4483 TEST2(viewIndex, 0); // 8, [7], 6, 5, 4, 2, 1, 0 |
4489 |
4484 |
4490 // Check we can go forward |
4485 // Check we can go forward |
4491 test(view->NextL(active->iStatus)); |
4486 TEST(view->NextL(active->iStatus)); |
4492 active->StartL(); |
4487 active->StartL(); |
4493 CActiveScheduler::Start(); |
4488 CActiveScheduler::Start(); |
4494 test(active->iStatus == KErrNone); |
4489 TEST2(active->iStatus.Int(), KErrNone); |
4495 test(view->Event().Id() == TLogId(6)); // 8, 7, [6], 5, 4, 2, 1, 0 |
4490 TEST2(view->Event().Id(), TLogId(6)); // 8, 7, [6], 5, 4, 2, 1, 0 |
4496 |
4491 |
4497 // Check we can now go back (new first entry) |
4492 // Check we can now go back (new first entry) |
4498 test(view->PreviousL(active->iStatus)); |
4493 TEST(view->PreviousL(active->iStatus)); |
4499 active->StartL(); |
4494 active->StartL(); |
4500 CActiveScheduler::Start(); |
4495 CActiveScheduler::Start(); |
4501 test(active->iStatus == KErrNone); // 8, [7], 6, 5, 4, 2, 1, 0 |
4496 TEST2(active->iStatus.Int(), KErrNone); // 8, [7], 6, 5, 4, 2, 1, 0 |
4502 test(view->Event().Id() == 7); |
4497 TEST2(view->Event().Id(), 7); |
4503 test(view->PreviousL(active->iStatus)); |
4498 TEST(view->PreviousL(active->iStatus)); |
4504 active->StartL(); |
4499 active->StartL(); |
4505 CActiveScheduler::Start(); |
4500 CActiveScheduler::Start(); |
4506 test(active->iStatus == KErrNone); // [8], 7, 6, 5, 4, 2, 1, 0 |
4501 TEST2(active->iStatus.Int(), KErrNone); // [8], 7, 6, 5, 4, 2, 1, 0 |
4507 test(view->Event().Id() == TLogId(KChangeEventTest2NumberOfEventsInView+1)); |
4502 TEST2(view->Event().Id(), TLogId(KChangeEventTest2NumberOfEventsInView+1)); |
4508 |
4503 |
4509 // Delete added event |
4504 // Delete added event |
4510 changeObs->ResetChanges(); |
4505 changeObs->ResetChanges(); |
4511 changeCount = changeObs->Changes().Count(); |
4506 changeCount = changeObs->Changes().Count(); |
4512 test(changeCount == 0); |
4507 TEST2(changeCount, 0); |
4513 active->StartL(); |
4508 active->StartL(); |
4514 aClient.DeleteEvent(view->Event().Id(), active->iStatus); |
4509 aClient.DeleteEvent(view->Event().Id(), active->iStatus); |
4515 CActiveScheduler::Start(); |
4510 CActiveScheduler::Start(); |
4516 test(active->iStatus == KErrNone); // [7], 6, 5, 4, 2, 1, 0 |
4511 TEST2(active->iStatus.Int(), KErrNone); // [7], 6, 5, 4, 2, 1, 0 |
4517 |
4512 |
4518 // Check deletion changes |
4513 // Check deletion changes |
4519 changeCount = changeObs->Changes().Count(); |
4514 changeCount = changeObs->Changes().Count(); |
4520 test(changeCount == 1); |
4515 TEST2(changeCount, 1); |
4521 type = changeObs->Changes().At(0, logId, viewIndex); |
4516 type = changeObs->Changes().At(0, logId, viewIndex); |
4522 test(type == ELogChangeTypeEventDeleted); |
4517 TEST2(type, ELogChangeTypeEventDeleted); |
4523 test(logId == runningNewId-1); |
4518 TEST2(logId, runningNewId-1); |
4524 test(viewIndex == 0); |
4519 TEST2(viewIndex, 0); |
4525 |
4520 |
4526 // Go to end of view |
4521 // Go to end of view |
4527 test(view->LastL(active->iStatus)); |
4522 TEST(view->LastL(active->iStatus)); |
4528 active->StartL(); |
4523 active->StartL(); |
4529 CActiveScheduler::Start(); |
4524 CActiveScheduler::Start(); |
4530 test(active->iStatus == KErrNone); |
4525 TEST2(active->iStatus.Int(), KErrNone); |
4531 test(view->Event().Id() == TLogId(0)); // 7, 6, 5, 4, 2, 1, [0] |
4526 TEST2(view->Event().Id(), TLogId(0)); // 7, 6, 5, 4, 2, 1, [0] |
4532 |
4527 |
4533 // Add new event |
4528 // Add new event |
4534 description[0] = TUint16('X'); |
4529 description[0] = TUint16('X'); |
4535 event->SetDescription(description); |
4530 event->SetDescription(description); |
4536 |
4531 |
4544 // |
4539 // |
4545 changeObs->StartCollectingChanges(); |
4540 changeObs->StartCollectingChanges(); |
4546 active->StartL(); |
4541 active->StartL(); |
4547 aClient.AddEvent(*event, active->iStatus); |
4542 aClient.AddEvent(*event, active->iStatus); |
4548 CActiveScheduler::Start(); |
4543 CActiveScheduler::Start(); |
4549 test(active->iStatus == KErrNone); |
4544 TEST2(active->iStatus.Int(), KErrNone); |
4550 test(event->Id() == runningNewId++); |
4545 TEST2(event->Id(), runningNewId++); |
4551 |
4546 |
4552 // Check changes |
4547 // Check changes |
4553 changeCount = changeObs->Changes().Count(); |
4548 changeCount = changeObs->Changes().Count(); |
4554 test(changeCount == 1); |
4549 TEST2(changeCount, 1); |
4555 type = changeObs->Changes().At(0, logId, viewIndex); |
4550 type = changeObs->Changes().At(0, logId, viewIndex); |
4556 test(type == ELogChangeTypeEventAdded); |
4551 TEST2(type, ELogChangeTypeEventAdded); |
4557 test(logId == runningNewId-1); |
4552 TEST2(logId, runningNewId-1); |
4558 test(viewIndex == 0); // 9, 7, 6, 5, 4, 2, 1, [0] |
4553 TEST2(viewIndex, 0); // 9, 7, 6, 5, 4, 2, 1, [0] |
4559 |
4554 |
4560 // Check we can't go forward |
4555 // Check we can't go forward |
4561 test(!view->NextL(active->iStatus)); |
4556 TEST(!view->NextL(active->iStatus)); |
4562 |
4557 |
4563 // Go back to the first record |
4558 // Go back to the first record |
4564 test(view->FirstL(active->iStatus)); |
4559 TEST(view->FirstL(active->iStatus)); |
4565 active->StartL(); |
4560 active->StartL(); |
4566 CActiveScheduler::Start(); |
4561 CActiveScheduler::Start(); |
4567 test(active->iStatus == KErrNone); |
4562 TEST2(active->iStatus.Int(), KErrNone); |
4568 test(view->Event().Id() == TLogId(runningNewId-1)); // 9, 7, 6, 5, 4, 2, 1, [0] |
4563 TEST2(view->Event().Id(), TLogId(runningNewId-1)); // 9, 7, 6, 5, 4, 2, 1, [0] |
4569 |
4564 |
4570 // Delete added event |
4565 // Delete added event |
4571 changeObs->ResetChanges(); |
4566 changeObs->ResetChanges(); |
4572 active->StartL(); |
4567 active->StartL(); |
4573 aClient.DeleteEvent(view->Event().Id(), active->iStatus); |
4568 aClient.DeleteEvent(view->Event().Id(), active->iStatus); |
4574 CActiveScheduler::Start(); |
4569 CActiveScheduler::Start(); |
4575 test(active->iStatus == KErrNone); // [7], 6, 5, 4, 2, 1, 0 |
4570 TEST2(active->iStatus.Int(), KErrNone); // [7], 6, 5, 4, 2, 1, 0 |
4576 |
4571 |
4577 // Check deletion changes |
4572 // Check deletion changes |
4578 changeCount = changeObs->Changes().Count(); |
4573 changeCount = changeObs->Changes().Count(); |
4579 test(changeCount == 1); |
4574 TEST2(changeCount, 1); |
4580 type = changeObs->Changes().At(0, logId, viewIndex); |
4575 type = changeObs->Changes().At(0, logId, viewIndex); |
4581 test(type == ELogChangeTypeEventDeleted); |
4576 TEST2(type, ELogChangeTypeEventDeleted); |
4582 test(logId == runningNewId-1); |
4577 TEST2(logId, runningNewId-1); |
4583 test(viewIndex == 0); |
4578 TEST2(viewIndex, 0); |
4584 |
4579 |
4585 // Go part way through view |
4580 // Go part way through view |
4586 test(view->NextL(active->iStatus)); |
4581 TEST(view->NextL(active->iStatus)); |
4587 active->StartL(); |
4582 active->StartL(); |
4588 CActiveScheduler::Start(); |
4583 CActiveScheduler::Start(); |
4589 test(active->iStatus == KErrNone); |
4584 TEST2(active->iStatus.Int(), KErrNone); |
4590 test(view->Event().Id() == TLogId(6)); // 7, [6], 5, 4, 2, 1, 0 |
4585 TEST2(view->Event().Id(), TLogId(6)); // 7, [6], 5, 4, 2, 1, 0 |
4591 test(view->NextL(active->iStatus)); |
4586 TEST(view->NextL(active->iStatus)); |
4592 active->StartL(); |
4587 active->StartL(); |
4593 CActiveScheduler::Start(); |
4588 CActiveScheduler::Start(); |
4594 test(active->iStatus == KErrNone); |
4589 TEST2(active->iStatus.Int(), KErrNone); |
4595 test(view->Event().Id() == TLogId(5)); // 7, 6, [5], 4, 2, 1, 0 |
4590 TEST2(view->Event().Id(), TLogId(5)); // 7, 6, [5], 4, 2, 1, 0 |
4596 |
4591 |
4597 // Add new event |
4592 // Add new event |
4598 description[0] = TUint16('X'); |
4593 description[0] = TUint16('X'); |
4599 event->SetDescription(description); |
4594 event->SetDescription(description); |
4600 |
4595 |
4608 // |
4603 // |
4609 changeObs->StartCollectingChanges(); |
4604 changeObs->StartCollectingChanges(); |
4610 active->StartL(); |
4605 active->StartL(); |
4611 aClient.AddEvent(*event, active->iStatus); |
4606 aClient.AddEvent(*event, active->iStatus); |
4612 CActiveScheduler::Start(); |
4607 CActiveScheduler::Start(); |
4613 test(active->iStatus == KErrNone); |
4608 TEST2(active->iStatus.Int(), KErrNone); |
4614 test(event->Id() == runningNewId++); |
4609 TEST2(event->Id(), runningNewId++); |
4615 |
4610 |
4616 // Check changes |
4611 // Check changes |
4617 changeCount = changeObs->Changes().Count(); |
4612 changeCount = changeObs->Changes().Count(); |
4618 test(changeCount == 1); |
4613 TEST2(changeCount, 1); |
4619 type = changeObs->Changes().At(0, logId, viewIndex); |
4614 type = changeObs->Changes().At(0, logId, viewIndex); |
4620 test(type == ELogChangeTypeEventAdded); |
4615 TEST2(type, ELogChangeTypeEventAdded); |
4621 test(logId == runningNewId-1); |
4616 TEST2(logId, runningNewId-1); |
4622 test(viewIndex == 0); // 10, 7, 6, [5], 4, 2, 1, 0 |
4617 TEST2(viewIndex, 0); // 10, 7, 6, [5], 4, 2, 1, 0 |
4623 changeObs->ResetChanges(); |
4618 changeObs->ResetChanges(); |
4624 |
4619 |
4625 // Work back to beginning |
4620 // Work back to beginning |
4626 test(view->PreviousL(active->iStatus)); |
4621 TEST(view->PreviousL(active->iStatus)); |
4627 active->StartL(); |
4622 active->StartL(); |
4628 CActiveScheduler::Start(); |
4623 CActiveScheduler::Start(); |
4629 test(active->iStatus == KErrNone); |
4624 TEST2(active->iStatus.Int(), KErrNone); |
4630 test(view->Event().Id() == TLogId(6)); // 10, 7, [6], 5, 4, 2, 1, 0 |
4625 TEST2(view->Event().Id(), TLogId(6)); // 10, 7, [6], 5, 4, 2, 1, 0 |
4631 test(view->PreviousL(active->iStatus)); |
4626 TEST(view->PreviousL(active->iStatus)); |
4632 active->StartL(); |
4627 active->StartL(); |
4633 CActiveScheduler::Start(); |
4628 CActiveScheduler::Start(); |
4634 test(active->iStatus == KErrNone); |
4629 TEST2(active->iStatus.Int(), KErrNone); |
4635 test(view->Event().Id() == TLogId(7)); // 10, [7], 6, 5, 4, 2, 1, 0 |
4630 TEST2(view->Event().Id(), TLogId(7)); // 10, [7], 6, 5, 4, 2, 1, 0 |
4636 test(view->PreviousL(active->iStatus)); |
4631 TEST(view->PreviousL(active->iStatus)); |
4637 active->StartL(); |
4632 active->StartL(); |
4638 CActiveScheduler::Start(); |
4633 CActiveScheduler::Start(); |
4639 test(active->iStatus == KErrNone); |
4634 TEST2(active->iStatus.Int(), KErrNone); |
4640 test(view->Event().Id() == runningNewId-1); // [10], 7, 6, 5, 4, 2, 1, 0 |
4635 TEST2(view->Event().Id(), runningNewId-1); // [10], 7, 6, 5, 4, 2, 1, 0 |
4641 |
4636 |
4642 // Delete added event |
4637 // Delete added event |
4643 changeCount = changeObs->Changes().Count(); |
4638 changeCount = changeObs->Changes().Count(); |
4644 test(changeCount == 0); |
4639 TEST2(changeCount, 0); |
4645 active->StartL(); |
4640 active->StartL(); |
4646 aClient.DeleteEvent(view->Event().Id(), active->iStatus); |
4641 aClient.DeleteEvent(view->Event().Id(), active->iStatus); |
4647 CActiveScheduler::Start(); |
4642 CActiveScheduler::Start(); |
4648 test(active->iStatus == KErrNone); // [7], 6, 5, 4, 2, 1, 0 |
4643 TEST2(active->iStatus.Int(), KErrNone); // [7], 6, 5, 4, 2, 1, 0 |
4649 |
4644 |
4650 // Check deletion changes |
4645 // Check deletion changes |
4651 changeCount = changeObs->Changes().Count(); |
4646 changeCount = changeObs->Changes().Count(); |
4652 test(changeCount == 1); |
4647 TEST2(changeCount, 1); |
4653 type = changeObs->Changes().At(0, logId, viewIndex); |
4648 type = changeObs->Changes().At(0, logId, viewIndex); |
4654 test(type == ELogChangeTypeEventDeleted); |
4649 TEST2(type, ELogChangeTypeEventDeleted); |
4655 test(logId == runningNewId-1); |
4650 TEST2(logId, runningNewId-1); |
4656 test(viewIndex == 0); |
4651 TEST2(viewIndex, 0); |
4657 changeObs->ResetChanges(); |
4652 changeObs->ResetChanges(); |
4658 |
4653 |
4659 // Go back to the first record |
4654 // Go back to the first record |
4660 test(view->FirstL(active->iStatus)); |
4655 TEST(view->FirstL(active->iStatus)); |
4661 active->StartL(); |
4656 active->StartL(); |
4662 CActiveScheduler::Start(); |
4657 CActiveScheduler::Start(); |
4663 test(active->iStatus == KErrNone); |
4658 TEST2(active->iStatus.Int(), KErrNone); |
4664 test(view->Event().Id() == TLogId(7)); // [7], 6, 5, 4, 2, 1, 0 |
4659 TEST2(view->Event().Id(), TLogId(7)); // [7], 6, 5, 4, 2, 1, 0 |
4665 |
4660 |
4666 // Move one record forward |
4661 // Move one record forward |
4667 test(view->NextL(active->iStatus)); |
4662 TEST(view->NextL(active->iStatus)); |
4668 active->StartL(); |
4663 active->StartL(); |
4669 CActiveScheduler::Start(); |
4664 CActiveScheduler::Start(); |
4670 test(active->iStatus == KErrNone); |
4665 TEST2(active->iStatus.Int(), KErrNone); |
4671 test(view->Event().Id() == TLogId(6)); // 7, [6], 5, 4, 2, 1, 0 |
4666 TEST2(view->Event().Id(), TLogId(6)); // 7, [6], 5, 4, 2, 1, 0 |
4672 |
4667 |
4673 // Change 'Z' event so that it now appears in the view |
4668 // Change 'Z' event so that it now appears in the view |
4674 changeCount = changeObs->Changes().Count(); |
4669 changeCount = changeObs->Changes().Count(); |
4675 test(changeCount == 0); |
4670 TEST2(changeCount ,0); |
4676 active->StartL(); |
4671 active->StartL(); |
4677 event->SetId(TLogId(3)); |
4672 event->SetId(TLogId(3)); |
4678 aClient.GetEvent(*event, active->iStatus); |
4673 aClient.GetEvent(*event, active->iStatus); |
4679 CActiveScheduler::Start(); |
4674 CActiveScheduler::Start(); |
4680 test(active->iStatus == KErrNone); |
4675 TEST2(active->iStatus.Int(), KErrNone); |
4681 // |
4676 // |
4682 event->SetContact(KTestContact); |
4677 event->SetContact(KTestContact); |
4683 active->StartL(); |
4678 active->StartL(); |
4684 |
4679 |
4685 // Check that changes work after a backup |
4680 // Check that changes work after a backup |
4690 TestLogOpenL(); |
4685 TestLogOpenL(); |
4691 |
4686 |
4692 changeObs->StartCollectingChanges(); |
4687 changeObs->StartCollectingChanges(); |
4693 aClient.ChangeEvent(*event, active->iStatus); |
4688 aClient.ChangeEvent(*event, active->iStatus); |
4694 CActiveScheduler::Start(); |
4689 CActiveScheduler::Start(); |
4695 test(active->iStatus == KErrNone); |
4690 TEST2(active->iStatus.Int(), KErrNone); |
4696 count = view->CountL(); |
4691 count = view->CountL(); |
4697 test(count == KChangeEventTest2NumberOfEventsInView+1); |
4692 TEST2(count, KChangeEventTest2NumberOfEventsInView+1); |
4698 |
4693 |
4699 // Check changes |
4694 // Check changes |
4700 changeCount = changeObs->Changes().Count(); |
4695 changeCount = changeObs->Changes().Count(); |
4701 test(changeCount == 1); |
4696 TEST2(changeCount, 1); |
4702 type = changeObs->Changes().At(0, logId, viewIndex); |
4697 type = changeObs->Changes().At(0, logId, viewIndex); |
4703 test(type == ELogChangeTypeEventAdded); // Change resulted in an addition to the view |
4698 TEST2(type, ELogChangeTypeEventAdded); // Change resulted in an addition to the view |
4704 test(logId == TLogId(3)); |
4699 TEST2(logId, TLogId(3)); |
4705 test(viewIndex == 4); // 7, [6], 5, 4, 3, 2, 1, 0 |
4700 TEST2(viewIndex, 4); // 7, [6], 5, 4, 3, 2, 1, 0 |
4706 changeObs->ResetChanges(); |
4701 changeObs->ResetChanges(); |
4707 |
4702 |
4708 // Move forwards and check |
4703 // Move forwards and check |
4709 test(view->NextL(active->iStatus)); |
4704 TEST(view->NextL(active->iStatus)); |
4710 active->StartL(); |
4705 active->StartL(); |
4711 CActiveScheduler::Start(); |
4706 CActiveScheduler::Start(); |
4712 test(active->iStatus == KErrNone); |
4707 TEST2(active->iStatus.Int(), KErrNone); |
4713 test(view->Event().Id() == TLogId(5)); // 7, 6, [5], 4, 3, 2, 1, 0 |
4708 TEST2(view->Event().Id(), TLogId(5)); // 7, 6, [5], 4, 3, 2, 1, 0 |
4714 test(view->NextL(active->iStatus)); |
4709 TEST(view->NextL(active->iStatus)); |
4715 active->StartL(); |
4710 active->StartL(); |
4716 CActiveScheduler::Start(); |
4711 CActiveScheduler::Start(); |
4717 test(active->iStatus == KErrNone); |
4712 TEST2(active->iStatus.Int(), KErrNone); |
4718 test(view->Event().Id() == TLogId(4)); // 7, 6, 5, [4], 3, 2, 1, 0 |
4713 TEST2(view->Event().Id(), TLogId(4)); // 7, 6, 5, [4], 3, 2, 1, 0 |
4719 test(view->NextL(active->iStatus)); |
4714 TEST(view->NextL(active->iStatus)); |
4720 active->StartL(); |
4715 active->StartL(); |
4721 CActiveScheduler::Start(); |
4716 CActiveScheduler::Start(); |
4722 test(active->iStatus == KErrNone); |
4717 TEST2(active->iStatus.Int(), KErrNone); |
4723 test(view->Event().Id() == TLogId(3)); // 7, 6, 5, 4, [3], 2, 1, 0 |
4718 TEST2(view->Event().Id(), TLogId(3)); // 7, 6, 5, 4, [3], 2, 1, 0 |
4724 |
4719 |
4725 // Change 'Z' event so that its now missing from the view again |
4720 // Change 'Z' event so that its now missing from the view again |
4726 changeCount = changeObs->Changes().Count(); |
4721 changeCount = changeObs->Changes().Count(); |
4727 test(changeCount == 0); |
4722 TEST2(changeCount ,0); |
4728 active->StartL(); |
4723 active->StartL(); |
4729 event->SetId(TLogId(3)); |
4724 event->SetId(TLogId(3)); |
4730 aClient.GetEvent(*event, active->iStatus); |
4725 aClient.GetEvent(*event, active->iStatus); |
4731 CActiveScheduler::Start(); |
4726 CActiveScheduler::Start(); |
4732 test(active->iStatus == KErrNone); |
4727 TEST2(active->iStatus.Int(), KErrNone); |
4733 // |
4728 // |
4734 event->SetContact(0); |
4729 event->SetContact(0); |
4735 active->StartL(); |
4730 active->StartL(); |
4736 |
4731 |
4737 // Check that changes work after a backup |
4732 // Check that changes work after a backup |
4742 TestLogOpenL(); |
4737 TestLogOpenL(); |
4743 |
4738 |
4744 changeObs->StartCollectingChanges(); |
4739 changeObs->StartCollectingChanges(); |
4745 aClient.ChangeEvent(*event, active->iStatus); |
4740 aClient.ChangeEvent(*event, active->iStatus); |
4746 CActiveScheduler::Start(); |
4741 CActiveScheduler::Start(); |
4747 test(active->iStatus == KErrNone); |
4742 TEST2(active->iStatus.Int(), KErrNone); |
4748 count = view->CountL(); |
4743 count = view->CountL(); |
4749 test(count == KChangeEventTest2NumberOfEventsInView); |
4744 TEST2(count, KChangeEventTest2NumberOfEventsInView); |
4750 |
4745 |
4751 // Check changes |
4746 // Check changes |
4752 changeCount = changeObs->Changes().Count(); |
4747 changeCount = changeObs->Changes().Count(); |
4753 test(changeCount == 1); |
4748 TEST2(changeCount, 1); |
4754 type = changeObs->Changes().At(0, logId, viewIndex); |
4749 type = changeObs->Changes().At(0, logId, viewIndex); |
4755 test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4750 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4756 test(logId == TLogId(3)); |
4751 TEST2(logId, TLogId(3)); |
4757 test(viewIndex == 4); // 7, 6, 5, 4, [2], 1, 0 |
4752 TEST2(viewIndex, 4); // 7, 6, 5, 4, [2], 1, 0 |
4758 changeObs->ResetChanges(); |
4753 changeObs->ResetChanges(); |
4759 |
4754 |
4760 // Move forwards and check |
4755 // Move forwards and check |
4761 test(view->NextL(active->iStatus)); |
4756 TEST(view->NextL(active->iStatus)); |
4762 active->StartL(); |
4757 active->StartL(); |
4763 CActiveScheduler::Start(); |
4758 CActiveScheduler::Start(); |
4764 test(active->iStatus == KErrNone); |
4759 TEST2(active->iStatus.Int(), KErrNone); |
4765 test(view->Event().Id() == TLogId(1)); // 7, 6, 5, 4, 2, [1], 0 |
4760 TEST2(view->Event().Id(), TLogId(1)); // 7, 6, 5, 4, 2, [1], 0 |
4766 test(view->NextL(active->iStatus)); |
4761 TEST(view->NextL(active->iStatus)); |
4767 active->StartL(); |
4762 active->StartL(); |
4768 CActiveScheduler::Start(); |
4763 CActiveScheduler::Start(); |
4769 test(active->iStatus == KErrNone); |
4764 TEST2(active->iStatus.Int(), KErrNone); |
4770 test(view->Event().Id() == TLogId(0)); // 7, 6, 5, 4, 2, 1, [0] |
4765 TEST2(view->Event().Id(), TLogId(0)); // 7, 6, 5, 4, 2, 1, [0] |
4771 |
4766 |
4772 // Move back one |
4767 // Move back one |
4773 test(view->PreviousL(active->iStatus)); |
4768 TEST(view->PreviousL(active->iStatus)); |
4774 active->StartL(); |
4769 active->StartL(); |
4775 CActiveScheduler::Start(); |
4770 CActiveScheduler::Start(); |
4776 test(active->iStatus == KErrNone); |
4771 TEST2(active->iStatus.Int(), KErrNone); |
4777 test(view->Event().Id() == TLogId(1)); // 7, 6, 5, 4, 2, [1], 0 |
4772 TEST2(view->Event().Id(), TLogId(1)); // 7, 6, 5, 4, 2, [1], 0 |
4778 changeCount = changeObs->Changes().Count(); |
4773 changeCount = changeObs->Changes().Count(); |
4779 test(changeCount == 0); |
4774 TEST2(changeCount ,0); |
4780 |
4775 |
4781 // Change 'Z' event so that it now appears in the view |
4776 // Change 'Z' event so that it now appears in the view |
4782 active->StartL(); |
4777 active->StartL(); |
4783 event->SetId(TLogId(3)); |
4778 event->SetId(TLogId(3)); |
4784 aClient.GetEvent(*event, active->iStatus); |
4779 aClient.GetEvent(*event, active->iStatus); |
4785 CActiveScheduler::Start(); |
4780 CActiveScheduler::Start(); |
4786 test(active->iStatus == KErrNone); |
4781 TEST2(active->iStatus.Int(), KErrNone); |
4787 // |
4782 // |
4788 event->SetContact(KTestContact); |
4783 event->SetContact(KTestContact); |
4789 active->StartL(); |
4784 active->StartL(); |
4790 |
4785 |
4791 // Check that changes work after a backup |
4786 // Check that changes work after a backup |
4796 TestLogOpenL(); |
4791 TestLogOpenL(); |
4797 |
4792 |
4798 changeObs->StartCollectingChanges(); |
4793 changeObs->StartCollectingChanges(); |
4799 aClient.ChangeEvent(*event, active->iStatus); |
4794 aClient.ChangeEvent(*event, active->iStatus); |
4800 CActiveScheduler::Start(); |
4795 CActiveScheduler::Start(); |
4801 test(active->iStatus == KErrNone); |
4796 TEST2(active->iStatus.Int(), KErrNone); |
4802 count = view->CountL(); |
4797 count = view->CountL(); |
4803 test(count == KChangeEventTest2NumberOfEventsInView+1); |
4798 TEST2(count, KChangeEventTest2NumberOfEventsInView+1); |
4804 |
4799 |
4805 // Check changes |
4800 // Check changes |
4806 changeCount = changeObs->Changes().Count(); |
4801 changeCount = changeObs->Changes().Count(); |
4807 test(changeCount == 1); |
4802 TEST2(changeCount, 1); |
4808 type = changeObs->Changes().At(0, logId, viewIndex); |
4803 type = changeObs->Changes().At(0, logId, viewIndex); |
4809 test(type == ELogChangeTypeEventAdded); // Change resulted in an addition to the view |
4804 TEST2(type, ELogChangeTypeEventAdded); // Change resulted in an addition to the view |
4810 test(logId == TLogId(3)); |
4805 TEST2(logId, TLogId(3)); |
4811 test(viewIndex == 4); // 7, 6, 5, 4, 3, 2, [1], 0 |
4806 TEST2(viewIndex, 4); // 7, 6, 5, 4, 3, 2, [1], 0 |
4812 changeObs->ResetChanges(); |
4807 changeObs->ResetChanges(); |
4813 |
4808 |
4814 // Check can only move forward one more record |
4809 // Check can only move forward one more record |
4815 test(view->NextL(active->iStatus)); |
4810 TEST(view->NextL(active->iStatus)); |
4816 active->StartL(); |
4811 active->StartL(); |
4817 CActiveScheduler::Start(); |
4812 CActiveScheduler::Start(); |
4818 test(active->iStatus == KErrNone); |
4813 TEST2(active->iStatus.Int(), KErrNone); |
4819 test(view->Event().Id() == TLogId(0)); // 7, 6, 5, 4, 3, 2, 1, [0] |
4814 TEST2(view->Event().Id(), TLogId(0)); // 7, 6, 5, 4, 3, 2, 1, [0] |
4820 |
4815 |
4821 // Move back until we are before the inserted record |
4816 // Move back until we are before the inserted record |
4822 test(view->PreviousL(active->iStatus)); |
4817 TEST(view->PreviousL(active->iStatus)); |
4823 active->StartL(); |
4818 active->StartL(); |
4824 CActiveScheduler::Start(); |
4819 CActiveScheduler::Start(); |
4825 test(active->iStatus == KErrNone); |
4820 TEST2(active->iStatus.Int(), KErrNone); |
4826 test(view->Event().Id() == TLogId(1)); // 7, 6, 5, 4, 3, 2, [1], 0 |
4821 TEST2(view->Event().Id(), TLogId(1)); // 7, 6, 5, 4, 3, 2, [1], 0 |
4827 test(view->PreviousL(active->iStatus)); |
4822 TEST(view->PreviousL(active->iStatus)); |
4828 active->StartL(); |
4823 active->StartL(); |
4829 CActiveScheduler::Start(); |
4824 CActiveScheduler::Start(); |
4830 test(active->iStatus == KErrNone); |
4825 TEST2(active->iStatus.Int(), KErrNone); |
4831 test(view->Event().Id() == TLogId(2)); // 7, 6, 5, 4, 3, [2], 1, 0 |
4826 TEST2(view->Event().Id(), TLogId(2)); // 7, 6, 5, 4, 3, [2], 1, 0 |
4832 test(view->PreviousL(active->iStatus)); |
4827 TEST(view->PreviousL(active->iStatus)); |
4833 active->StartL(); |
4828 active->StartL(); |
4834 CActiveScheduler::Start(); |
4829 CActiveScheduler::Start(); |
4835 test(active->iStatus == KErrNone); |
4830 TEST2(active->iStatus.Int(), KErrNone); |
4836 test(view->Event().Id() == TLogId(3)); // 7, 6, 5, 4, [3], 2, 1, 0 |
4831 TEST2(view->Event().Id(), TLogId(3)); // 7, 6, 5, 4, [3], 2, 1, 0 |
4837 test(view->PreviousL(active->iStatus)); |
4832 TEST(view->PreviousL(active->iStatus)); |
4838 active->StartL(); |
4833 active->StartL(); |
4839 CActiveScheduler::Start(); |
4834 CActiveScheduler::Start(); |
4840 test(active->iStatus == KErrNone); |
4835 TEST2(active->iStatus.Int(), KErrNone); |
4841 test(view->Event().Id() == TLogId(4)); // 7, 6, 5, [4], 3, 2, 1, 0 |
4836 TEST2(view->Event().Id(), TLogId(4)); // 7, 6, 5, [4], 3, 2, 1, 0 |
4842 changeCount = changeObs->Changes().Count(); |
4837 changeCount = changeObs->Changes().Count(); |
4843 test(changeCount == 0); |
4838 TEST2(changeCount ,0); |
4844 |
4839 |
4845 // Change 'Z' event so that its now missing from the view again |
4840 // Change 'Z' event so that its now missing from the view again |
4846 active->StartL(); |
4841 active->StartL(); |
4847 event->SetId(TLogId(3)); |
4842 event->SetId(TLogId(3)); |
4848 aClient.GetEvent(*event, active->iStatus); |
4843 aClient.GetEvent(*event, active->iStatus); |
4849 CActiveScheduler::Start(); |
4844 CActiveScheduler::Start(); |
4850 test(active->iStatus == KErrNone); |
4845 TEST2(active->iStatus.Int(), KErrNone); |
4851 // |
4846 // |
4852 event->SetContact(0); |
4847 event->SetContact(0); |
4853 active->StartL(); |
4848 active->StartL(); |
4854 |
4849 |
4855 // Check that changes work after a backup |
4850 // Check that changes work after a backup |
4860 TestLogOpenL(); |
4855 TestLogOpenL(); |
4861 |
4856 |
4862 changeObs->StartCollectingChanges(); |
4857 changeObs->StartCollectingChanges(); |
4863 aClient.ChangeEvent(*event, active->iStatus); |
4858 aClient.ChangeEvent(*event, active->iStatus); |
4864 CActiveScheduler::Start(); |
4859 CActiveScheduler::Start(); |
4865 test(active->iStatus == KErrNone); |
4860 TEST2(active->iStatus.Int(), KErrNone); |
4866 count = view->CountL(); |
4861 count = view->CountL(); |
4867 test(count == KChangeEventTest2NumberOfEventsInView); |
4862 TEST2(count, KChangeEventTest2NumberOfEventsInView); |
4868 |
4863 |
4869 // Check changes |
4864 // Check changes |
4870 changeCount = changeObs->Changes().Count(); |
4865 changeCount = changeObs->Changes().Count(); |
4871 test(changeCount == 1); |
4866 TEST2(changeCount, 1); |
4872 type = changeObs->Changes().At(0, logId, viewIndex); |
4867 type = changeObs->Changes().At(0, logId, viewIndex); |
4873 test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4868 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4874 test(logId == TLogId(3)); |
4869 TEST2(logId, TLogId(3)); |
4875 test(viewIndex == 4); // 7, 6, 5, [4], 2, 1, 0 |
4870 TEST2(viewIndex, 4); // 7, 6, 5, [4], 2, 1, 0 |
4876 changeObs->ResetChanges(); |
4871 changeObs->ResetChanges(); |
4877 |
4872 |
4878 // Check navigating to the end of the view |
4873 // Check navigating to the end of the view |
4879 test(view->NextL(active->iStatus)); |
4874 TEST(view->NextL(active->iStatus)); |
4880 active->StartL(); |
4875 active->StartL(); |
4881 CActiveScheduler::Start(); |
4876 CActiveScheduler::Start(); |
4882 test(active->iStatus == KErrNone); |
4877 TEST2(active->iStatus.Int(), KErrNone); |
4883 test(view->Event().Id() == TLogId(2)); // 7, 6, 5, 4, [2], 1, 0 |
4878 TEST2(view->Event().Id(), TLogId(2)); // 7, 6, 5, 4, [2], 1, 0 |
4884 test(view->NextL(active->iStatus)); |
4879 TEST(view->NextL(active->iStatus)); |
4885 active->StartL(); |
4880 active->StartL(); |
4886 CActiveScheduler::Start(); |
4881 CActiveScheduler::Start(); |
4887 test(active->iStatus == KErrNone); |
4882 TEST2(active->iStatus.Int(), KErrNone); |
4888 test(view->Event().Id() == TLogId(1)); // 7, 6, 5, 4, 2, [1], 0 |
4883 TEST2(view->Event().Id(), TLogId(1)); // 7, 6, 5, 4, 2, [1], 0 |
4889 test(view->NextL(active->iStatus)); |
4884 TEST(view->NextL(active->iStatus)); |
4890 active->StartL(); |
4885 active->StartL(); |
4891 CActiveScheduler::Start(); |
4886 CActiveScheduler::Start(); |
4892 test(active->iStatus == KErrNone); |
4887 TEST2(active->iStatus.Int(), KErrNone); |
4893 test(view->Event().Id() == TLogId(0)); // 7, 6, 5, 4, 2, 1, [0] |
4888 TEST2(view->Event().Id(), TLogId(0)); // 7, 6, 5, 4, 2, 1, [0] |
4894 changeCount = changeObs->Changes().Count(); |
4889 changeCount = changeObs->Changes().Count(); |
4895 test(changeCount == 0); |
4890 TEST2(changeCount ,0); |
4896 test(!view->NextL(active->iStatus)); |
4891 TEST(!view->NextL(active->iStatus)); |
4897 |
4892 |
4898 // Delete everything in the view and make sure we can't navigate anymore. |
4893 // Delete everything in the view and make sure we can't navigate anymore. |
4899 active->StartL(); |
4894 active->StartL(); |
4900 aClient.DeleteEvent(TLogId(4), active->iStatus); |
4895 aClient.DeleteEvent(TLogId(4), active->iStatus); |
4901 CActiveScheduler::Start(); |
4896 CActiveScheduler::Start(); |
4902 test(active->iStatus == KErrNone); |
4897 TEST2(active->iStatus.Int(), KErrNone); |
4903 count = view->CountL(); |
4898 count = view->CountL(); |
4904 test(count == KChangeEventTest2NumberOfEventsInView - 1); |
4899 TEST2(count, KChangeEventTest2NumberOfEventsInView - 1); |
4905 changeCount = changeObs->Changes().Count(); |
4900 changeCount = changeObs->Changes().Count(); |
4906 test(changeCount == 1); |
4901 TEST2(changeCount, 1); |
4907 type = changeObs->Changes().At(0, logId, viewIndex); |
4902 type = changeObs->Changes().At(0, logId, viewIndex); |
4908 test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4903 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4909 test(logId == TLogId(4)); |
4904 TEST2(logId, TLogId(4)); |
4910 test(viewIndex == 3); // 7, 6, 5, 2, 1, [0] |
4905 TEST2(viewIndex, 3); // 7, 6, 5, 2, 1, [0] |
4911 changeObs->ResetChanges(); |
4906 changeObs->ResetChanges(); |
4912 // |
4907 // |
4913 active->StartL(); |
4908 active->StartL(); |
4914 aClient.DeleteEvent(TLogId(7), active->iStatus); |
4909 aClient.DeleteEvent(TLogId(7), active->iStatus); |
4915 CActiveScheduler::Start(); |
4910 CActiveScheduler::Start(); |
4916 test(active->iStatus == KErrNone); |
4911 TEST2(active->iStatus.Int(), KErrNone); |
4917 count = view->CountL(); |
4912 count = view->CountL(); |
4918 test(count == KChangeEventTest2NumberOfEventsInView - 2); |
4913 TEST2(count, KChangeEventTest2NumberOfEventsInView - 2); |
4919 changeCount = changeObs->Changes().Count(); |
4914 changeCount = changeObs->Changes().Count(); |
4920 test(changeCount == 1); |
4915 TEST2(changeCount, 1); |
4921 type = changeObs->Changes().At(0, logId, viewIndex); |
4916 type = changeObs->Changes().At(0, logId, viewIndex); |
4922 test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4917 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4923 test(logId == TLogId(7)); |
4918 TEST2(logId, TLogId(7)); |
4924 test(viewIndex == 0); // 6, 5, 2, 1, [0] |
4919 TEST2(viewIndex, 0); // 6, 5, 2, 1, [0] |
4925 changeObs->ResetChanges(); |
4920 changeObs->ResetChanges(); |
4926 // |
4921 // |
4927 active->StartL(); |
4922 active->StartL(); |
4928 aClient.DeleteEvent(TLogId(0), active->iStatus); |
4923 aClient.DeleteEvent(TLogId(0), active->iStatus); |
4929 CActiveScheduler::Start(); |
4924 CActiveScheduler::Start(); |
4930 test(active->iStatus == KErrNone); |
4925 TEST2(active->iStatus.Int(), KErrNone); |
4931 count = view->CountL(); |
4926 count = view->CountL(); |
4932 test(count == KChangeEventTest2NumberOfEventsInView - 3); |
4927 TEST2(count, KChangeEventTest2NumberOfEventsInView - 3); |
4933 changeCount = changeObs->Changes().Count(); |
4928 changeCount = changeObs->Changes().Count(); |
4934 test(changeCount == 1); |
4929 TEST2(changeCount, 1); |
4935 type = changeObs->Changes().At(0, logId, viewIndex); |
4930 type = changeObs->Changes().At(0, logId, viewIndex); |
4936 test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4931 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4937 test(logId == TLogId(0)); |
4932 TEST2(logId, TLogId(0)); |
4938 test(viewIndex == 4); // 6, 5, 2, [1] |
4933 TEST2(viewIndex, 4); // 6, 5, 2, [1] |
4939 changeObs->ResetChanges(); |
4934 changeObs->ResetChanges(); |
4940 // |
4935 // |
4941 active->StartL(); |
4936 active->StartL(); |
4942 aClient.DeleteEvent(TLogId(5), active->iStatus); |
4937 aClient.DeleteEvent(TLogId(5), active->iStatus); |
4943 CActiveScheduler::Start(); |
4938 CActiveScheduler::Start(); |
4944 test(active->iStatus == KErrNone); |
4939 TEST2(active->iStatus.Int(), KErrNone); |
4945 count = view->CountL(); |
4940 count = view->CountL(); |
4946 test(count == KChangeEventTest2NumberOfEventsInView - 4); |
4941 TEST2(count, KChangeEventTest2NumberOfEventsInView - 4); |
4947 changeCount = changeObs->Changes().Count(); |
4942 changeCount = changeObs->Changes().Count(); |
4948 test(changeCount == 1); |
4943 TEST2(changeCount, 1); |
4949 type = changeObs->Changes().At(0, logId, viewIndex); |
4944 type = changeObs->Changes().At(0, logId, viewIndex); |
4950 test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4945 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4951 test(logId == TLogId(5)); |
4946 TEST2(logId, TLogId(5)); |
4952 test(viewIndex == 1); // 6, 2, [1] |
4947 TEST2(viewIndex, 1); // 6, 2, [1] |
4953 changeObs->ResetChanges(); |
4948 changeObs->ResetChanges(); |
4954 // |
4949 // |
4955 active->StartL(); |
4950 active->StartL(); |
4956 aClient.DeleteEvent(TLogId(2), active->iStatus); |
4951 aClient.DeleteEvent(TLogId(2), active->iStatus); |
4957 CActiveScheduler::Start(); |
4952 CActiveScheduler::Start(); |
4958 test(active->iStatus == KErrNone); |
4953 TEST2(active->iStatus.Int(), KErrNone); |
4959 count = view->CountL(); |
4954 count = view->CountL(); |
4960 test(count == KChangeEventTest2NumberOfEventsInView - 5); |
4955 TEST2(count, KChangeEventTest2NumberOfEventsInView - 5); |
4961 changeCount = changeObs->Changes().Count(); |
4956 changeCount = changeObs->Changes().Count(); |
4962 test(changeCount == 1); |
4957 TEST2(changeCount, 1); |
4963 type = changeObs->Changes().At(0, logId, viewIndex); |
4958 type = changeObs->Changes().At(0, logId, viewIndex); |
4964 test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4959 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4965 test(logId == TLogId(2)); |
4960 TEST2(logId, TLogId(2)); |
4966 test(viewIndex == 1); // 6, [1] |
4961 TEST2(viewIndex, 1); // 6, [1] |
4967 changeObs->ResetChanges(); |
4962 changeObs->ResetChanges(); |
4968 // |
4963 // |
4969 active->StartL(); |
4964 active->StartL(); |
4970 aClient.DeleteEvent(TLogId(6), active->iStatus); |
4965 aClient.DeleteEvent(TLogId(6), active->iStatus); |
4971 CActiveScheduler::Start(); |
4966 CActiveScheduler::Start(); |
4972 test(active->iStatus == KErrNone); |
4967 TEST2(active->iStatus.Int(), KErrNone); |
4973 count = view->CountL(); |
4968 count = view->CountL(); |
4974 test(count == KChangeEventTest2NumberOfEventsInView - 6); |
4969 TEST2(count, KChangeEventTest2NumberOfEventsInView - 6); |
4975 changeCount = changeObs->Changes().Count(); |
4970 changeCount = changeObs->Changes().Count(); |
4976 test(changeCount == 1); |
4971 TEST2(changeCount, 1); |
4977 type = changeObs->Changes().At(0, logId, viewIndex); |
4972 type = changeObs->Changes().At(0, logId, viewIndex); |
4978 test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4973 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
4979 test(logId == TLogId(6)); |
4974 TEST2(logId, TLogId(6)); |
4980 test(viewIndex == 0); // [1] |
4975 TEST2(viewIndex, 0); // [1] |
4981 changeObs->ResetChanges(); |
4976 changeObs->ResetChanges(); |
4982 |
4977 |
4983 // Check we can't go backwards or forwards |
4978 // Check we can't go backwards or forwards |
4984 test(!view->NextL(active->iStatus)); |
4979 TEST(!view->NextL(active->iStatus)); |
4985 test(!view->PreviousL(active->iStatus)); |
4980 TEST(!view->PreviousL(active->iStatus)); |
4986 test(view->FirstL(active->iStatus)); |
4981 TEST(view->FirstL(active->iStatus)); |
4987 active->StartL(); |
4982 active->StartL(); |
4988 CActiveScheduler::Start(); |
4983 CActiveScheduler::Start(); |
4989 test(active->iStatus == KErrNone); |
4984 TEST2(active->iStatus.Int(), KErrNone); |
4990 test(view->Event().Id() == TLogId(1)); // [1] |
4985 TEST2(view->Event().Id(), TLogId(1)); // [1] |
4991 test(view->LastL(active->iStatus)); |
4986 TEST(view->LastL(active->iStatus)); |
4992 active->StartL(); |
4987 active->StartL(); |
4993 CActiveScheduler::Start(); |
4988 CActiveScheduler::Start(); |
4994 test(active->iStatus == KErrNone); |
4989 TEST2(active->iStatus.Int(), KErrNone); |
4995 test(view->Event().Id() == TLogId(1)); // [1] |
4990 TEST2(view->Event().Id(), TLogId(1)); // [1] |
4996 |
4991 |
4997 // Delete last event in view |
4992 // Delete last event in view |
4998 active->StartL(); |
4993 active->StartL(); |
4999 aClient.DeleteEvent(TLogId(1), active->iStatus); |
4994 aClient.DeleteEvent(TLogId(1), active->iStatus); |
5000 CActiveScheduler::Start(); |
4995 CActiveScheduler::Start(); |
5001 test(active->iStatus == KErrNone); |
4996 TEST2(active->iStatus.Int(), KErrNone); |
5002 count = view->CountL(); |
4997 count = view->CountL(); |
5003 test(count == KChangeEventTest2NumberOfEventsInView - 7); |
4998 TEST2(count, KChangeEventTest2NumberOfEventsInView - 7); |
5004 changeCount = changeObs->Changes().Count(); |
4999 changeCount = changeObs->Changes().Count(); |
5005 test(changeCount == 1); |
5000 TEST2(changeCount, 1); |
5006 type = changeObs->Changes().At(0, logId, viewIndex); |
5001 type = changeObs->Changes().At(0, logId, viewIndex); |
5007 test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
5002 TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view |
5008 test(logId == TLogId(1)); |
5003 TEST2(logId, TLogId(1)); |
5009 test(viewIndex == 0); // *Empty* |
5004 TEST2(viewIndex, 0); // *Empty* |
5010 changeObs->ResetChanges(); |
5005 changeObs->ResetChanges(); |
5011 |
5006 |
5012 // Check we can't navigate |
5007 // Check we can't navigate |
5013 test(!view->NextL(active->iStatus)); |
5008 TEST(!view->NextL(active->iStatus)); |
5014 test(!view->PreviousL(active->iStatus)); |
5009 TEST(!view->PreviousL(active->iStatus)); |
5015 test(!view->FirstL(active->iStatus)); |
5010 TEST(!view->FirstL(active->iStatus)); |
5016 test(!view->LastL(active->iStatus)); |
5011 TEST(!view->LastL(active->iStatus)); |
5017 |
5012 |
5018 CleanupStack::PopAndDestroy(5, event); // view, changeObs, active, filter, event |
5013 CleanupStack::PopAndDestroy(5, event); // view, changeObs, active, filter, event |
5019 } |
5014 } |
5020 |
5015 |
5021 /** |
5016 /** |
5027 @SYMTestExpectedResults Test must not fail |
5022 @SYMTestExpectedResults Test must not fail |
5028 @SYMREQ REQ0000 |
5023 @SYMREQ REQ0000 |
5029 */ |
5024 */ |
5030 LOCAL_C void TestViewFilteringDefect1L(CLogClient& aClient) |
5025 LOCAL_C void TestViewFilteringDefect1L(CLogClient& aClient) |
5031 { |
5026 { |
5032 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0872 ")); |
5027 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0872 ")); |
5033 CLogEvent* event = CLogEvent::NewL(); |
5028 CLogEvent* event = CLogEvent::NewL(); |
5034 CleanupStack::PushL(event); |
5029 CleanupStack::PushL(event); |
5035 |
5030 |
5036 CTestActive* active = new(ELeave) CTestActive(); |
5031 CTestActive* active = new(ELeave) CTestActive(); |
5037 CleanupStack::PushL(active); |
5032 CleanupStack::PushL(active); |
5224 @SYMTestExpectedResults Test must not fail |
5219 @SYMTestExpectedResults Test must not fail |
5225 @SYMREQ REQ0000 |
5220 @SYMREQ REQ0000 |
5226 */ |
5221 */ |
5227 LOCAL_C void TestDeletingViewWithinObserverCallbackL(CLogClient& aClient) |
5222 LOCAL_C void TestDeletingViewWithinObserverCallbackL(CLogClient& aClient) |
5228 { |
5223 { |
5229 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0873 ")); |
5224 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0873 ")); |
5230 TestUtils::DeleteDatabaseL(); |
5225 TestUtils::DeleteDatabaseL(); |
5231 |
5226 |
5232 TInt error = 0; |
5227 TInt error = 0; |
5233 // |
5228 // |
5234 CTestActive* active = new(ELeave) CTestActive(); |
5229 CTestActive* active = new(ELeave) CTestActive(); |
5470 client->AddEvent(*event, active->iStatus); |
5465 client->AddEvent(*event, active->iStatus); |
5471 CActiveScheduler::Start(); |
5466 CActiveScheduler::Start(); |
5472 __ASSERT_ALWAYS(active->iStatus == KErrNone, User::Panic(_L("ThreadPanic"), 1)); |
5467 __ASSERT_ALWAYS(active->iStatus == KErrNone, User::Panic(_L("ThreadPanic"), 1)); |
5473 ++count; |
5468 ++count; |
5474 LEAVE_IF_ERROR(aThreadData.iArray->Append(event->Id())); |
5469 LEAVE_IF_ERROR(aThreadData.iArray->Append(event->Id())); |
5475 // RDebug::Print(_L("EAdd: i:%d count:%d, id:%d\n"), i, aThreadData.iArray->Count(), event->Id()); |
5470 // TheTest.Printf(_L("EAdd: i:%d count:%d, id:%d\n"), i, aThreadData.iArray->Count(), event->Id()); |
5476 |
5471 |
5477 // Have to wait for a minimum of 1 ms here because otherwise DMBS sorts records (by time) |
5472 // Have to wait for a minimum of 1 ms here because otherwise DMBS sorts records (by time) |
5478 // in an arbitrary manor |
5473 // in an arbitrary manor |
5479 // If this occurs this test will fail the logId == arrayId test below, as the order |
5474 // If this occurs this test will fail the logId == arrayId test below, as the order |
5480 // will be different between the logeng and arrayOfIds[]. |
5475 // will be different between the logeng and arrayOfIds[]. |
5578 @SYMTestExpectedResults Test must not fail |
5573 @SYMTestExpectedResults Test must not fail |
5579 @SYMREQ REQ0000 |
5574 @SYMREQ REQ0000 |
5580 */ |
5575 */ |
5581 LOCAL_C void TestNavigationWhilstBusyL(CLogClient& aClient) |
5576 LOCAL_C void TestNavigationWhilstBusyL(CLogClient& aClient) |
5582 { |
5577 { |
5583 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0874 ")); |
5578 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0874 ")); |
5584 TestUtils::DeleteDatabaseL(); |
5579 TestUtils::DeleteDatabaseL(); |
5585 |
5580 |
5586 TInt error = 0; |
5581 TInt error = 0; |
5587 TInt count = 0; |
5582 TInt count = 0; |
5588 // |
5583 // |
5596 CleanupStack::PushL(type); |
5591 CleanupStack::PushL(type); |
5597 |
5592 |
5598 type->SetUid(TEST_LOG_UID); |
5593 type->SetUid(TEST_LOG_UID); |
5599 type->SetDescription(KTestEventDesc); |
5594 type->SetDescription(KTestEventDesc); |
5600 type->SetLoggingEnabled(ETrue); |
5595 type->SetLoggingEnabled(ETrue); |
5601 RDebug::Print(_L("\nTest event type added %x\n"),TEST_LOG_UID ); |
5596 TheTest.Printf(_L("\nTest event type added %x\n"),TEST_LOG_UID ); |
5602 |
5597 |
5603 // Register the event type |
5598 // Register the event type |
5604 active->StartL(); |
5599 active->StartL(); |
5605 aClient.AddEventType(*type, active->iStatus); |
5600 aClient.AddEventType(*type, active->iStatus); |
5606 CActiveScheduler::Start(); |
5601 CActiveScheduler::Start(); |
5613 |
5608 |
5614 CLogFilter* filter = CLogFilter::NewL(); |
5609 CLogFilter* filter = CLogFilter::NewL(); |
5615 CleanupStack::PushL(filter); |
5610 CleanupStack::PushL(filter); |
5616 filter->SetEventType(TEST_LOG_UID); |
5611 filter->SetEventType(TEST_LOG_UID); |
5617 TBool res = view->SetFilterL(*filter, active->iStatus); |
5612 TBool res = view->SetFilterL(*filter, active->iStatus); |
5618 test(!res); |
5613 TEST(!res); |
5619 |
5614 |
5620 // increase the default log size |
5615 // increase the default log size |
5621 TLogConfig Config; |
5616 TLogConfig Config; |
5622 const TInt kMaxLogSize = 2000; |
5617 const TInt kMaxLogSize = 2000; |
5623 Config.iMaxLogSize = kMaxLogSize; |
5618 Config.iMaxLogSize = kMaxLogSize; |
5641 |
5636 |
5642 // Start the worker thread going |
5637 // Start the worker thread going |
5643 thread.Resume(); |
5638 thread.Resume(); |
5644 |
5639 |
5645 // Suspend this thread |
5640 // Suspend this thread |
5646 RDebug::Print(_L("TEST CODE: Suspending thread for 2 seconds\n")); |
5641 TheTest.Printf(_L("TEST CODE: Suspending thread for 2 seconds\n")); |
5647 CLogSchedulerTimer* timer = CLogSchedulerTimer::NewLC(); |
5642 CLogSchedulerTimer* timer = CLogSchedulerTimer::NewLC(); |
5648 timer->Wait(10 * 1000000); |
5643 timer->Wait(10 * 1000000); |
5649 |
5644 |
5650 // Apply the filter now there are some records |
5645 // Apply the filter now there are some records |
5651 RDebug::Print(_L("TEST CODE: Setting filter again - should be some records now\n")); |
5646 TheTest.Printf(_L("TEST CODE: Setting filter again - should be some records now\n")); |
5652 res = view->SetFilterL(*filter, active->iStatus); |
5647 res = view->SetFilterL(*filter, active->iStatus); |
5653 test(res); |
5648 TEST(res); |
5654 active->StartL(); |
5649 active->StartL(); |
5655 CActiveScheduler::Start(); |
5650 CActiveScheduler::Start(); |
5656 test(active->iStatus == KErrNone || active->iStatus == KErrCancel); // KErrCancel when the worker thread clears the log at the same time as we are navigating to the first record |
5651 TEST(active->iStatus == KErrNone || active->iStatus == KErrCancel); // KErrCancel when the worker thread clears the log at the same time as we are navigating to the first record |
5657 count = view->CountL(); |
5652 count = view->CountL(); |
5658 test(count > 0); |
5653 TEST(count > 0); |
5659 |
5654 |
5660 // Navigate around (up and down) whilst events are being created |
5655 // Navigate around (up and down) whilst events are being created |
5661 count = view->CountL(); |
5656 count = view->CountL(); |
5662 res = view->FirstL(active->iStatus); |
5657 res = view->FirstL(active->iStatus); |
5663 test(res); |
5658 TEST(res); |
5664 do { |
5659 do { |
5665 active->StartL(); |
5660 active->StartL(); |
5666 CActiveScheduler::Start(); |
5661 CActiveScheduler::Start(); |
5667 test(active->iStatus == KErrNone || active->iStatus == KErrCancel); |
5662 TEST(active->iStatus == KErrNone || active->iStatus == KErrCancel); |
5668 count--; |
5663 count--; |
5669 if (active->iStatus == KErrNone) |
5664 if (active->iStatus == KErrNone) |
5670 test(view->Event().Id() != KLogNullId); |
5665 TEST(view->Event().Id() != KLogNullId); |
5671 } |
5666 } |
5672 while(view->NextL(active->iStatus)); |
5667 while(view->NextL(active->iStatus)); |
5673 |
5668 |
5674 timer->Wait(5 * 1000000); |
5669 timer->Wait(5 * 1000000); |
5675 count = view->CountL(); |
5670 count = view->CountL(); |
5676 res = view->FirstL(active->iStatus); |
5671 res = view->FirstL(active->iStatus); |
5677 test(res); |
5672 TEST(res); |
5678 do { |
5673 do { |
5679 active->StartL(); |
5674 active->StartL(); |
5680 CActiveScheduler::Start(); |
5675 CActiveScheduler::Start(); |
5681 test(active->iStatus == KErrNone || active->iStatus == KErrCancel); |
5676 TEST(active->iStatus == KErrNone || active->iStatus == KErrCancel); |
5682 count--; |
5677 count--; |
5683 if (active->iStatus == KErrNone) |
5678 if (active->iStatus == KErrNone) |
5684 test(view->Event().Id() != KLogNullId); |
5679 TEST(view->Event().Id() != KLogNullId); |
5685 } |
5680 } |
5686 while(view->NextL(active->iStatus)); |
5681 while(view->NextL(active->iStatus)); |
5687 |
5682 |
5688 timer->Wait(5 * 1000000); |
5683 timer->Wait(5 * 1000000); |
5689 count = view->CountL(); |
5684 count = view->CountL(); |
5690 res = view->LastL(active->iStatus); |
5685 res = view->LastL(active->iStatus); |
5691 test(res); |
5686 TEST(res); |
5692 do { |
5687 do { |
5693 active->StartL(); |
5688 active->StartL(); |
5694 CActiveScheduler::Start(); |
5689 CActiveScheduler::Start(); |
5695 test(active->iStatus == KErrNone || active->iStatus == KErrCancel); |
5690 TEST(active->iStatus == KErrNone || active->iStatus == KErrCancel); |
5696 count--; |
5691 count--; |
5697 if (active->iStatus == KErrNone) |
5692 if (active->iStatus == KErrNone) |
5698 test(view->Event().Id() != KLogNullId); |
5693 TEST(view->Event().Id() != KLogNullId); |
5699 } |
5694 } |
5700 while(view->PreviousL(active->iStatus)); |
5695 while(view->PreviousL(active->iStatus)); |
5701 |
5696 |
5702 timer->Wait(5 * 1000000); |
5697 timer->Wait(5 * 1000000); |
5703 count = view->CountL(); |
5698 count = view->CountL(); |
5704 res = view->FirstL(active->iStatus); |
5699 res = view->FirstL(active->iStatus); |
5705 test(res); |
5700 TEST(res); |
5706 do { |
5701 do { |
5707 active->StartL(); |
5702 active->StartL(); |
5708 CActiveScheduler::Start(); |
5703 CActiveScheduler::Start(); |
5709 test(active->iStatus == KErrNone || active->iStatus == KErrCancel); |
5704 TEST(active->iStatus == KErrNone || active->iStatus == KErrCancel); |
5710 count--; |
5705 count--; |
5711 if (active->iStatus == KErrNone) |
5706 if (active->iStatus == KErrNone) |
5712 test(view->Event().Id() != KLogNullId); |
5707 TEST(view->Event().Id() != KLogNullId); |
5713 } |
5708 } |
5714 while(view->NextL(active->iStatus)); |
5709 while(view->NextL(active->iStatus)); |
5715 |
5710 |
5716 timer->Wait(5 * 1000000); |
5711 timer->Wait(5 * 1000000); |
5717 count = view->CountL(); |
5712 count = view->CountL(); |
5718 res = view->LastL(active->iStatus); |
5713 res = view->LastL(active->iStatus); |
5719 test(res); |
5714 TEST(res); |
5720 do { |
5715 do { |
5721 active->StartL(); |
5716 active->StartL(); |
5722 CActiveScheduler::Start(); |
5717 CActiveScheduler::Start(); |
5723 test(active->iStatus == KErrNone || active->iStatus == KErrCancel); |
5718 TEST(active->iStatus == KErrNone || active->iStatus == KErrCancel); |
5724 count--; |
5719 count--; |
5725 if (active->iStatus == KErrNone) |
5720 if (active->iStatus == KErrNone) |
5726 test(view->Event().Id() != KLogNullId); |
5721 TEST(view->Event().Id() != KLogNullId); |
5727 } |
5722 } |
5728 while(view->PreviousL(active->iStatus)); |
5723 while(view->PreviousL(active->iStatus)); |
5729 |
5724 |
5730 timer->Wait(5 * 1000000); |
5725 timer->Wait(5 * 1000000); |
5731 count = view->CountL(); |
5726 count = view->CountL(); |
5732 res = view->LastL(active->iStatus); |
5727 res = view->LastL(active->iStatus); |
5733 test(res); |
5728 TEST(res); |
5734 do { |
5729 do { |
5735 active->StartL(); |
5730 active->StartL(); |
5736 CActiveScheduler::Start(); |
5731 CActiveScheduler::Start(); |
5737 test(active->iStatus == KErrNone || active->iStatus == KErrCancel); |
5732 TEST(active->iStatus == KErrNone || active->iStatus == KErrCancel); |
5738 count--; |
5733 count--; |
5739 if (active->iStatus == KErrNone) |
5734 if (active->iStatus == KErrNone) |
5740 test(view->Event().Id() != KLogNullId); |
5735 TEST(view->Event().Id() != KLogNullId); |
5741 } |
5736 } |
5742 while(view->PreviousL(active->iStatus)); |
5737 while(view->PreviousL(active->iStatus)); |
5743 |
5738 |
5744 // STOP THE WORKER THREAD |
5739 // STOP THE WORKER THREAD |
5745 threadData.iStopThread = ETrue; |
5740 threadData.iStopThread = ETrue; |
5746 RDebug::Print(_L("Stopping worker thread\n")); |
5741 TheTest.Printf(_L("Stopping worker thread\n")); |
5747 timer->Wait(30 * 1000000); |
5742 timer->Wait(30 * 1000000); |
5748 |
5743 |
5749 // do some checks on the log |
5744 // do some checks on the log |
5750 TLogConfig logConfig; |
5745 TLogConfig logConfig; |
5751 aClient.GetConfig( logConfig, active->iStatus); |
5746 aClient.GetConfig( logConfig, active->iStatus); |
5752 active->StartL(); |
5747 active->StartL(); |
5753 CActiveScheduler::Start(); |
5748 CActiveScheduler::Start(); |
5754 TEST2(active->iStatus.Int(), KErrNone); |
5749 TEST2(active->iStatus.Int(), KErrNone); |
5755 RDebug::Print(_L("MaxLogSize:%ld MaxRecentLogSize:%d\n"), |
5750 TheTest.Printf(_L("MaxLogSize:%ld MaxRecentLogSize:%d\n"), |
5756 logConfig.iMaxLogSize, logConfig.iMaxRecentLogSize ); |
5751 logConfig.iMaxLogSize, logConfig.iMaxRecentLogSize ); |
5757 test(logConfig.iMaxLogSize > logConfig.iMaxRecentLogSize); |
5752 TEST(logConfig.iMaxLogSize > logConfig.iMaxRecentLogSize); |
5758 |
5753 |
5759 /* Check the log has not overflowed. |
5754 /* Check the log has not overflowed. |
5760 If this fails either increase the log size or reduce the time the |
5755 If this fails either increase the log size or reduce the time the |
5761 worker thread has been running |
5756 worker thread has been running |
5762 */ |
5757 */ |
5763 test (arrayOfIds.Count() < kMaxLogSize); |
5758 TEST(arrayOfIds.Count() < kMaxLogSize); |
5764 |
5759 |
5765 // Loop though the logevents created by the worker thread and compare against the |
5760 // Loop though the logevents created by the worker thread and compare against the |
5766 // data stored in arrayOfIds. |
5761 // data stored in arrayOfIds. |
5767 res = view->LastL(active->iStatus); |
5762 res = view->LastL(active->iStatus); |
5768 test(res); |
5763 TEST(res); |
5769 count = 0; |
5764 count = 0; |
5770 do { |
5765 do { |
5771 active->StartL(); |
5766 active->StartL(); |
5772 CActiveScheduler::Start(); |
5767 CActiveScheduler::Start(); |
5773 TEST2(active->iStatus.Int(), KErrNone); |
5768 TEST2(active->iStatus.Int(), KErrNone); |
5774 |
5769 |
5775 const TLogId logId = view->Event().Id(); |
5770 const TLogId logId = view->Event().Id(); |
5776 const TLogId arrayId = arrayOfIds[count]; |
5771 const TLogId arrayId = arrayOfIds[count]; |
5777 if (logId != arrayId) |
5772 if (logId != arrayId) |
5778 RDebug::Print(_L("Events[%d] - array:%5d, id:%5d ****\n"), count, arrayId, logId); |
5773 TheTest.Printf(_L("Events[%d] - array:%5d, id:%5d ****\n"), count, arrayId, logId); |
5779 // Note: If this test fails the fist thing to check is the time delay after EAdd. |
5774 // Note: If this test fails the fist thing to check is the time delay after EAdd. |
5780 // If several events get the same time stamp, the order is arbitrary and the test fails here. |
5775 // If several events get the same time stamp, the order is arbitrary and the test fails here. |
5781 test(logId == arrayId); |
5776 TEST2(logId, arrayId); |
5782 count++; |
5777 count++; |
5783 } |
5778 } |
5784 while(view->PreviousL(active->iStatus)); |
5779 while(view->PreviousL(active->iStatus)); |
5785 |
5780 |
5786 CleanupStack::PopAndDestroy(timer); |
5781 CleanupStack::PopAndDestroy(timer); |
5805 |
5800 |
5806 @SYMDEF INC123066 |
5801 @SYMDEF INC123066 |
5807 */ |
5802 */ |
5808 LOCAL_C void INC123066L(CLogClient& aClient) |
5803 LOCAL_C void INC123066L(CLogClient& aClient) |
5809 { |
5804 { |
5810 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-4014 ")); |
5805 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-4014 ")); |
5811 CLogEvent* event = CLogEvent::NewL(); |
5806 CLogEvent* event = CLogEvent::NewL(); |
5812 CleanupStack::PushL(event); |
5807 CleanupStack::PushL(event); |
5813 event->SetEventType(KLogCallEventTypeUid); |
5808 event->SetEventType(KLogCallEventTypeUid); |
5814 |
5809 |
5815 CTestActive* active = new(ELeave)CTestActive(); |
5810 CTestActive* active = new(ELeave)CTestActive(); |
5881 @SYMTestExpectedResults SetRecentListL indicates 3 events in view |
5876 @SYMTestExpectedResults SetRecentListL indicates 3 events in view |
5882 @SYMDEF INC136334 |
5877 @SYMDEF INC136334 |
5883 */ |
5878 */ |
5884 LOCAL_C void INC136334L(CLogClient& aClient) |
5879 LOCAL_C void INC136334L(CLogClient& aClient) |
5885 { |
5880 { |
5886 test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-CT-4017 ")); |
5881 TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-CT-4017 ")); |
5887 CLogEvent* event = CLogEvent::NewL(); |
5882 CLogEvent* event = CLogEvent::NewL(); |
5888 CleanupStack::PushL(event); |
5883 CleanupStack::PushL(event); |
5889 |
5884 |
5890 CTestActive* active = new(ELeave)CTestActive(); |
5885 CTestActive* active = new(ELeave)CTestActive(); |
5891 CleanupStack::PushL(active); |
5886 CleanupStack::PushL(active); |
5960 // |
5955 // |
5961 void doTestsL() |
5956 void doTestsL() |
5962 { |
5957 { |
5963 TheMatchingIsEnabled = TestUtils::MatchingEnabledL(); |
5958 TheMatchingIsEnabled = TestUtils::MatchingEnabledL(); |
5964 |
5959 |
5965 TestUtils::Initialize(_L("T_LOGVIEW1")); |
5960 TestUtils::Initialize(_L("t_logview1")); |
5966 TestUtils::DeleteDatabaseL(); |
5961 TestUtils::DeleteDatabaseL(); |
5967 |
5962 |
5968 CLogClient* client = CLogClient::NewL(theFs); |
5963 CLogClient* client = CLogClient::NewL(theFs); |
5969 CleanupStack::PushL(client); |
5964 CleanupStack::PushL(client); |
5970 |
5965 |
5971 CLogChangeNotifier* notifier = CLogChangeNotifier::NewL(); |
5966 CLogChangeNotifier* notifier = CLogChangeNotifier::NewL(); |
5972 CleanupStack::PushL(notifier); |
5967 CleanupStack::PushL(notifier); |
5973 |
5968 |
5974 test.Start(_L("Event View With No Filter")); |
5969 TheTest.Start(_L("Event View With No Filter")); |
5975 |
5970 |
5976 TestEventViewL(*client); |
5971 TestEventViewL(*client); |
5977 theLog.Write(_L8("Test 1 OK\n")); |
5972 theLog.Write(_L8("Test 1 OK\n")); |
5978 |
5973 |
5979 test.Next(_L("Event View Filter alternative")); |
5974 TheTest.Next(_L("Event View Filter alternative")); |
5980 TestViewFilteringDefect1L(*client); |
5975 TestViewFilteringDefect1L(*client); |
5981 theLog.Write(_L8("Test 2 OK\n")); |
5976 theLog.Write(_L8("Test 2 OK\n")); |
5982 test.Next(_L("Event View With Filter")); |
5977 TheTest.Next(_L("Event View With Filter")); |
5983 TestEventViewFilter1L(*client); |
5978 TestEventViewFilter1L(*client); |
5984 TestEventViewFilter2L(*client); |
5979 TestEventViewFilter2L(*client); |
5985 test.Next(_L("INC123066 - LogView not updated if SetFilterL found no event")); |
5980 TheTest.Next(_L("INC123066 - LogView not updated if SetFilterL found no event")); |
5986 INC123066L(*client); |
5981 INC123066L(*client); |
5987 theLog.Write(_L8("Test 3 OK\n")); |
5982 theLog.Write(_L8("Test 3 OK\n")); |
5988 |
5983 |
5989 test.Next(_L("Recent View")); |
5984 TheTest.Next(_L("Recent View")); |
5990 TestRecentView1L(*client); |
5985 TestRecentView1L(*client); |
5991 TestRecentView2L(*client); |
5986 TestRecentView2L(*client); |
5992 theLog.Write(_L8("Test 4 OK\n")); |
5987 theLog.Write(_L8("Test 4 OK\n")); |
5993 |
5988 |
5994 test.Next(_L("Removing recent events")); |
5989 TheTest.Next(_L("Removing recent events")); |
5995 TestRecentRemove1L(*client); |
5990 TestRecentRemove1L(*client); |
5996 TestRecentRemove2L(*client); |
5991 TestRecentRemove2L(*client); |
5997 theLog.Write(_L8("Test 5 OK\n")); |
5992 theLog.Write(_L8("Test 5 OK\n")); |
5998 |
5993 |
5999 test.Next(_L("Duplicate View")); |
5994 TheTest.Next(_L("Duplicate View")); |
6000 TestDuplicateViewL(*client); |
5995 TestDuplicateViewL(*client); |
6001 theLog.Write(_L8("Test 6 OK\n")); |
5996 theLog.Write(_L8("Test 6 OK\n")); |
6002 |
5997 |
6003 test.Next(_L("Removing duplicate events")); |
5998 TheTest.Next(_L("Removing duplicate events")); |
6004 TestDuplicateRemoveL(*client); |
5999 TestDuplicateRemoveL(*client); |
6005 theLog.Write(_L8("Test 7 OK\n")); |
6000 theLog.Write(_L8("Test 7 OK\n")); |
6006 |
6001 |
6007 test.Next(_L("Check purge performed on view setup")); |
6002 TheTest.Next(_L("Check purge performed on view setup")); |
6008 TestPurgeOnSetup1L(*client); |
6003 TestPurgeOnSetup1L(*client); |
6009 TestPurgeOnSetup2L(*client); |
6004 TestPurgeOnSetup2L(*client); |
6010 theLog.Write(_L8("Test 8 OK\n")); |
6005 theLog.Write(_L8("Test 8 OK\n")); |
6011 |
6006 |
6012 test.Next(_L("View Purging")); |
6007 TheTest.Next(_L("View Purging")); |
6013 TestViewPurgeL(*client); |
6008 TestViewPurgeL(*client); |
6014 theLog.Write(_L8("Test 9 OK\n")); |
6009 theLog.Write(_L8("Test 9 OK\n")); |
6015 |
6010 |
6016 test.Next(_L("Clearing duplicate lists")); |
6011 TheTest.Next(_L("Clearing duplicate lists")); |
6017 TestClearDuplicatesL(*client); |
6012 TestClearDuplicatesL(*client); |
6018 theLog.Write(_L8("Test 10 OK\n")); |
6013 theLog.Write(_L8("Test 10 OK\n")); |
6019 |
6014 |
6020 test.Next(_L("Phone number matching")); |
6015 TheTest.Next(_L("Phone number matching")); |
6021 TestPhoneNumberMatchingL(*client); |
6016 TestPhoneNumberMatchingL(*client); |
6022 theLog.Write(_L8("Test 11 OK\n")); |
6017 theLog.Write(_L8("Test 11 OK\n")); |
6023 |
6018 |
6024 test.Next(_L("view flags setting/clearing")); |
6019 TheTest.Next(_L("view flags setting/clearing")); |
6025 TestViewFlagsL(*client); |
6020 TestViewFlagsL(*client); |
6026 theLog.Write(_L8("Test 12 OK\n")); |
6021 theLog.Write(_L8("Test 12 OK\n")); |
6027 |
6022 |
6028 test.Next(_L("Recent view flags setting/clearing")); |
6023 TheTest.Next(_L("Recent view flags setting/clearing")); |
6029 TestRecentFlagsL(*client); |
6024 TestRecentFlagsL(*client); |
6030 theLog.Write(_L8("Test 13 OK\n")); |
6025 theLog.Write(_L8("Test 13 OK\n")); |
6031 |
6026 |
6032 test.Next(_L("View change tests 1")); |
6027 TheTest.Next(_L("View change tests 1")); |
6033 TestViewChangeEvents1L(*client); |
6028 TestViewChangeEvents1L(*client); |
6034 TestViewChangeEvents1aL(*client); |
6029 TestViewChangeEvents1aL(*client); |
6035 theLog.Write(_L8("Test 14 OK\n")); |
6030 theLog.Write(_L8("Test 14 OK\n")); |
6036 |
6031 |
6037 test.Next(_L("View change tests 2")); |
6032 TheTest.Next(_L("View change tests 2")); |
6038 TestViewChangeEvents2L(*client); |
6033 TestViewChangeEvents2L(*client); |
6039 TestViewChangeEvents2aL(*client); |
6034 TestViewChangeEvents2aL(*client); |
6040 theLog.Write(_L8("Test 15 OK\n")); |
6035 theLog.Write(_L8("Test 15 OK\n")); |
6041 |
6036 |
6042 test.Next(_L("View deletion from within callback")); |
6037 TheTest.Next(_L("View deletion from within callback")); |
6043 TestDeletingViewWithinObserverCallbackL(*client); |
6038 TestDeletingViewWithinObserverCallbackL(*client); |
6044 theLog.Write(_L8("Test 16 OK\n")); |
6039 theLog.Write(_L8("Test 16 OK\n")); |
6045 |
6040 |
6046 test.Next(_L("Test navigation whilst events are added")); |
6041 TheTest.Next(_L("Test navigation whilst events are added")); |
6047 TestNavigationWhilstBusyL(*client); |
6042 TestNavigationWhilstBusyL(*client); |
6048 theLog.Write(_L8("Test 17 OK\n")); |
6043 theLog.Write(_L8("Test 17 OK\n")); |
6049 |
6044 |
6050 test.Next(_L("Defect INC105010 - phone number matching")); |
6045 TheTest.Next(_L("Defect INC105010 - phone number matching")); |
6051 INC105010L(*client); |
6046 INC105010L(*client); |
6052 theLog.Write(_L8("Test 18 OK\n")); |
6047 theLog.Write(_L8("Test 18 OK\n")); |
6053 |
6048 |
6054 test.Next(_L("INC136334 - The miss call log won't show if you have ' in your contact")); |
6049 TheTest.Next(_L("INC136334 - The miss call log won't show if you have ' in your contact")); |
6055 INC136334L(*client); |
6050 INC136334L(*client); |
6056 theLog.Write(_L8("Test 19 OK\n")); |
6051 theLog.Write(_L8("Test 19 OK\n")); |
6057 |
6052 |
6058 CleanupStack::PopAndDestroy(2); // notifier, client; |
6053 CleanupStack::PopAndDestroy(2); // notifier, client; |
6059 } |
6054 } |