| branch | RCL_3 |
| changeset 9 | 667e88a979d7 |
| parent 0 | 08ec8eefde2f |
| child 10 | 31a8f755b7fe |
| 8:fa9941cf3867 | 9:667e88a979d7 |
|---|---|
1 // Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies). |
1 // Copyright (c) 2003-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". |
14 // |
14 // |
15 |
15 |
16 #include <s32file.h> |
16 #include <s32file.h> |
17 #include <logeng.h> |
17 #include <logeng.h> |
18 #include <tz.h> |
18 #include <tz.h> |
19 #include "TEST.H" |
19 #include "t_logutil2.h" |
20 #include <logview.h> |
20 #include <logview.h> |
21 |
21 |
22 #undef test //there is a "test" macro which hides "RTest test" declaration. |
22 RTest TheTest(_L("t_logview2")); |
23 |
|
24 RTest test(_L("Log View Test Harness Number 2")); |
|
25 |
23 |
26 const TInt KTestEventNum = 20; |
24 const TInt KTestEventNum = 20; |
27 const TInt KTestErrorEventNum = 3; |
25 const TInt KTestErrorEventNum = 3; |
28 const TLogContactItemId KTestContact1 = 0x123; |
26 const TLogContactItemId KTestContact1 = 0x123; |
29 const TLogContactItemId KTestContact2 = 0x456; |
27 const TLogContactItemId KTestContact2 = 0x456; |
53 @SYMTestExpectedResults Test must not fail |
51 @SYMTestExpectedResults Test must not fail |
54 @SYMREQ REQ0000 |
52 @SYMREQ REQ0000 |
55 */ |
53 */ |
56 LOCAL_C void TestEventViewWithFilterListL(CLogClient& aClient) |
54 LOCAL_C void TestEventViewWithFilterListL(CLogClient& aClient) |
57 { |
55 { |
58 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0930 ")); |
56 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0930 ")); |
59 CTestActive* active = new(ELeave)CTestActive; |
57 CTestActive* active = new(ELeave)CTestActive; |
60 CleanupStack::PushL(active); |
58 CleanupStack::PushL(active); |
61 |
59 |
62 CLogEvent* event = CLogEvent::NewL(); |
60 CLogEvent* event = CLogEvent::NewL(); |
63 CleanupStack::PushL(event); |
61 CleanupStack::PushL(event); |
532 @SYMTestExpectedResults Log view has expected number of events and no LogServ panic. |
530 @SYMTestExpectedResults Log view has expected number of events and no LogServ panic. |
533 @SYMDEF INC102412 |
531 @SYMDEF INC102412 |
534 */ |
532 */ |
535 LOCAL_C void TestEventViewWithTimestampsInFilterListL(CLogClient& aClient) |
533 LOCAL_C void TestEventViewWithTimestampsInFilterListL(CLogClient& aClient) |
536 { |
534 { |
537 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-3432 ")); |
535 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-3432 ")); |
538 TTime testStartTime; |
536 TTime testStartTime; |
539 testStartTime.UniversalTime(); |
537 testStartTime.UniversalTime(); |
540 TTime tomorrow = testStartTime + (TTimeIntervalDays)1; |
538 TTime tomorrow = testStartTime + (TTimeIntervalDays)1; |
541 TTime twoDaysFromNow = tomorrow + (TTimeIntervalDays)1; |
539 TTime twoDaysFromNow = tomorrow + (TTimeIntervalDays)1; |
542 |
540 |
733 @SYMTestExpectedResults Test must not fail |
731 @SYMTestExpectedResults Test must not fail |
734 @SYMREQ REQ0000 |
732 @SYMREQ REQ0000 |
735 */ |
733 */ |
736 LOCAL_C void TestRecentViewWithFilterL(CLogClient& aClient) |
734 LOCAL_C void TestRecentViewWithFilterL(CLogClient& aClient) |
737 { |
735 { |
738 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0931 ")); |
736 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0931 ")); |
739 CLogEvent* event = CLogEvent::NewL(); |
737 CLogEvent* event = CLogEvent::NewL(); |
740 CleanupStack::PushL(event); |
738 CleanupStack::PushL(event); |
741 |
739 |
742 CTestActive* active = new(ELeave)CTestActive(); |
740 CTestActive* active = new(ELeave)CTestActive(); |
743 CleanupStack::PushL(active); |
741 CleanupStack::PushL(active); |
845 @SYMTestExpectedResults Test must not fail |
843 @SYMTestExpectedResults Test must not fail |
846 @SYMREQ REQ0000 |
844 @SYMREQ REQ0000 |
847 */ |
845 */ |
848 LOCAL_C void TestRecentViewWithFilterListL(CLogClient& aClient) |
846 LOCAL_C void TestRecentViewWithFilterListL(CLogClient& aClient) |
849 { |
847 { |
850 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0932 ")); |
848 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0932 ")); |
851 CLogEvent* event = CLogEvent::NewL(); |
849 CLogEvent* event = CLogEvent::NewL(); |
852 CleanupStack::PushL(event); |
850 CleanupStack::PushL(event); |
853 |
851 |
854 CTestActive* active = new(ELeave)CTestActive(); |
852 CTestActive* active = new(ELeave)CTestActive(); |
855 CleanupStack::PushL(active); |
853 CleanupStack::PushL(active); |
965 @SYMTestExpectedResults Test must not fail |
963 @SYMTestExpectedResults Test must not fail |
966 @SYMREQ REQ0000 |
964 @SYMREQ REQ0000 |
967 */ |
965 */ |
968 LOCAL_C void TestDuplicateViewWithFilterL(CLogClient& aClient) |
966 LOCAL_C void TestDuplicateViewWithFilterL(CLogClient& aClient) |
969 { |
967 { |
970 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0933 ")); |
968 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0933 ")); |
971 CLogEvent* event = CLogEvent::NewL(); |
969 CLogEvent* event = CLogEvent::NewL(); |
972 CleanupStack::PushL(event); |
970 CleanupStack::PushL(event); |
973 |
971 |
974 CTestActive* active = new(ELeave)CTestActive(); |
972 CTestActive* active = new(ELeave)CTestActive(); |
975 CleanupStack::PushL(active); |
973 CleanupStack::PushL(active); |
1085 @SYMTestExpectedResults Test must not fail |
1083 @SYMTestExpectedResults Test must not fail |
1086 @SYMREQ REQ0000 |
1084 @SYMREQ REQ0000 |
1087 */ |
1085 */ |
1088 LOCAL_C void TestDuplicateViewWithFilterListL(CLogClient& aClient) |
1086 LOCAL_C void TestDuplicateViewWithFilterListL(CLogClient& aClient) |
1089 { |
1087 { |
1090 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0934 ")); |
1088 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0934 ")); |
1091 CLogEvent* event = CLogEvent::NewL(); |
1089 CLogEvent* event = CLogEvent::NewL(); |
1092 CleanupStack::PushL(event); |
1090 CleanupStack::PushL(event); |
1093 |
1091 |
1094 CTestActive* active = new(ELeave)CTestActive(); |
1092 CTestActive* active = new(ELeave)CTestActive(); |
1095 CleanupStack::PushL(active); |
1093 CleanupStack::PushL(active); |
1201 @SYMTestExpectedResults Test must not fail |
1199 @SYMTestExpectedResults Test must not fail |
1202 @SYMREQ REQ0000 |
1200 @SYMREQ REQ0000 |
1203 */ |
1201 */ |
1204 LOCAL_C void TestEventViewForNullFieldsL(CLogClient& aClient) |
1202 LOCAL_C void TestEventViewForNullFieldsL(CLogClient& aClient) |
1205 { |
1203 { |
1206 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0935 ")); |
1204 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0935 ")); |
1207 CTestActive* active = new(ELeave)CTestActive; |
1205 CTestActive* active = new(ELeave)CTestActive; |
1208 CleanupStack::PushL(active); |
1206 CleanupStack::PushL(active); |
1209 |
1207 |
1210 CLogEvent* event = CLogEvent::NewL(); |
1208 CLogEvent* event = CLogEvent::NewL(); |
1211 CleanupStack::PushL(event); |
1209 CleanupStack::PushL(event); |
1384 @SYMTestExpectedResults Test must not fail |
1382 @SYMTestExpectedResults Test must not fail |
1385 @SYMREQ REQ0000 |
1383 @SYMREQ REQ0000 |
1386 */ |
1384 */ |
1387 LOCAL_C void TestRecentViewForNullFieldsL(CLogClient& aClient) |
1385 LOCAL_C void TestRecentViewForNullFieldsL(CLogClient& aClient) |
1388 { |
1386 { |
1389 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0936 ")); |
1387 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0936 ")); |
1390 CLogEvent* event = CLogEvent::NewL(); |
1388 CLogEvent* event = CLogEvent::NewL(); |
1391 CleanupStack::PushL(event); |
1389 CleanupStack::PushL(event); |
1392 |
1390 |
1393 CTestActive* active = new(ELeave)CTestActive(); |
1391 CTestActive* active = new(ELeave)CTestActive(); |
1394 CleanupStack::PushL(active); |
1392 CleanupStack::PushL(active); |
1492 @SYMTestExpectedResults Test must not fail |
1490 @SYMTestExpectedResults Test must not fail |
1493 @SYMREQ REQ0000 |
1491 @SYMREQ REQ0000 |
1494 */ |
1492 */ |
1495 LOCAL_C void TestDuplicateViewForNullFieldsL(CLogClient& aClient) |
1493 LOCAL_C void TestDuplicateViewForNullFieldsL(CLogClient& aClient) |
1496 { |
1494 { |
1497 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0937 ")); |
1495 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0937 ")); |
1498 CLogEvent* event = CLogEvent::NewL(); |
1496 CLogEvent* event = CLogEvent::NewL(); |
1499 CleanupStack::PushL(event); |
1497 CleanupStack::PushL(event); |
1500 |
1498 |
1501 CTestActive* active = new(ELeave)CTestActive(); |
1499 CTestActive* active = new(ELeave)CTestActive(); |
1502 CleanupStack::PushL(active); |
1500 CleanupStack::PushL(active); |
1628 @SYMTestExpectedResults Test must not fail |
1626 @SYMTestExpectedResults Test must not fail |
1629 @SYMREQ REQ0000 |
1627 @SYMREQ REQ0000 |
1630 */ |
1628 */ |
1631 LOCAL_C void TestEventViewForFlagsL(CLogClient& aClient) |
1629 LOCAL_C void TestEventViewForFlagsL(CLogClient& aClient) |
1632 { |
1630 { |
1633 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0938 ")); |
1631 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0938 ")); |
1634 CLogEvent* event = CLogEvent::NewL(); |
1632 CLogEvent* event = CLogEvent::NewL(); |
1635 CleanupStack::PushL(event); |
1633 CleanupStack::PushL(event); |
1636 |
1634 |
1637 CTestActive* active = new(ELeave)CTestActive(); |
1635 CTestActive* active = new(ELeave)CTestActive(); |
1638 CleanupStack::PushL(active); |
1636 CleanupStack::PushL(active); |
1739 @SYMTestExpectedResults Test must not fail |
1737 @SYMTestExpectedResults Test must not fail |
1740 @SYMREQ REQ0000 |
1738 @SYMREQ REQ0000 |
1741 */ |
1739 */ |
1742 LOCAL_C void TestRecentViewForFlagsL(CLogClient& aClient) |
1740 LOCAL_C void TestRecentViewForFlagsL(CLogClient& aClient) |
1743 { |
1741 { |
1744 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0939 ")); |
1742 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0939 ")); |
1745 CLogEvent* event = CLogEvent::NewL(); |
1743 CLogEvent* event = CLogEvent::NewL(); |
1746 CleanupStack::PushL(event); |
1744 CleanupStack::PushL(event); |
1747 |
1745 |
1748 CTestActive* active = new(ELeave)CTestActive(); |
1746 CTestActive* active = new(ELeave)CTestActive(); |
1749 CleanupStack::PushL(active); |
1747 CleanupStack::PushL(active); |
1857 @SYMTestExpectedResults Test must not fail |
1855 @SYMTestExpectedResults Test must not fail |
1858 @SYMREQ REQ0000 |
1856 @SYMREQ REQ0000 |
1859 */ |
1857 */ |
1860 LOCAL_C void TestDuplicateViewForFlagsL(CLogClient& aClient) |
1858 LOCAL_C void TestDuplicateViewForFlagsL(CLogClient& aClient) |
1861 { |
1859 { |
1862 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0940 ")); |
1860 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0940 ")); |
1863 CLogEvent* event = CLogEvent::NewL(); |
1861 CLogEvent* event = CLogEvent::NewL(); |
1864 CleanupStack::PushL(event); |
1862 CleanupStack::PushL(event); |
1865 |
1863 |
1866 CTestActive* active = new(ELeave)CTestActive(); |
1864 CTestActive* active = new(ELeave)CTestActive(); |
1867 CleanupStack::PushL(active); |
1865 CleanupStack::PushL(active); |
1976 @SYMTestExpectedResults Test must not fail |
1974 @SYMTestExpectedResults Test must not fail |
1977 @SYMREQ REQ0000 |
1975 @SYMREQ REQ0000 |
1978 */ |
1976 */ |
1979 LOCAL_C void TestRemovingRecentEventsL(CLogClient& aClient) |
1977 LOCAL_C void TestRemovingRecentEventsL(CLogClient& aClient) |
1980 { |
1978 { |
1981 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0941 ")); |
1979 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0941 ")); |
1982 CLogEvent* event = CLogEvent::NewL(); |
1980 CLogEvent* event = CLogEvent::NewL(); |
1983 CleanupStack::PushL(event); |
1981 CleanupStack::PushL(event); |
1984 |
1982 |
1985 CTestActive* active = new(ELeave)CTestActive(); |
1983 CTestActive* active = new(ELeave)CTestActive(); |
1986 CleanupStack::PushL(active); |
1984 CleanupStack::PushL(active); |
2049 @SYMTestExpectedResults Test must not fail |
2047 @SYMTestExpectedResults Test must not fail |
2050 @SYMREQ REQ0000 |
2048 @SYMREQ REQ0000 |
2051 */ |
2049 */ |
2052 LOCAL_C void TestRemovingDuplicateEventsL(CLogClient& aClient) |
2050 LOCAL_C void TestRemovingDuplicateEventsL(CLogClient& aClient) |
2053 { |
2051 { |
2054 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0942 ")); |
2052 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0942 ")); |
2055 CLogEvent* event = CLogEvent::NewL(); |
2053 CLogEvent* event = CLogEvent::NewL(); |
2056 CleanupStack::PushL(event); |
2054 CleanupStack::PushL(event); |
2057 |
2055 |
2058 CTestActive* active = new(ELeave)CTestActive(); |
2056 CTestActive* active = new(ELeave)CTestActive(); |
2059 CleanupStack::PushL(active); |
2057 CleanupStack::PushL(active); |
2090 // Add event |
2088 // Add event |
2091 active->StartL(); |
2089 active->StartL(); |
2092 aClient.AddEvent(*event, active->iStatus); |
2090 aClient.AddEvent(*event, active->iStatus); |
2093 CActiveScheduler::Start(); |
2091 CActiveScheduler::Start(); |
2094 TEST2(active->iStatus.Int(), KErrNone); |
2092 TEST2(active->iStatus.Int(), KErrNone); |
2095 RDebug::Print(_L("EVENT ID: %d\n"), event->Id()); |
2093 TheTest.Printf(_L("EVENT ID: %d\n"), event->Id()); |
2096 } |
2094 } |
2097 |
2095 |
2098 // Create the view |
2096 // Create the view |
2099 active->StartL(); |
2097 active->StartL(); |
2100 TEST(view->SetRecentListL(KLogNullRecentList, active->iStatus)); |
2098 TEST(view->SetRecentListL(KLogNullRecentList, active->iStatus)); |
2140 @SYMTestExpectedResults Test must not fail |
2138 @SYMTestExpectedResults Test must not fail |
2141 @SYMREQ REQ0000 |
2139 @SYMREQ REQ0000 |
2142 */ |
2140 */ |
2143 LOCAL_C void TestMultipleViews1L(CLogClient& aClient) |
2141 LOCAL_C void TestMultipleViews1L(CLogClient& aClient) |
2144 { |
2142 { |
2145 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0943 ")); |
2143 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0943 ")); |
2146 CTestActive* active1 = new(ELeave)CTestActive; |
2144 CTestActive* active1 = new(ELeave)CTestActive; |
2147 CleanupStack::PushL(active1); |
2145 CleanupStack::PushL(active1); |
2148 |
2146 |
2149 // Wait a second |
2147 // Wait a second |
2150 User::After(1000000); |
2148 User::After(1000000); |
2712 @SYMTestExpectedResults Test must not fail |
2710 @SYMTestExpectedResults Test must not fail |
2713 @SYMREQ REQ0000 |
2711 @SYMREQ REQ0000 |
2714 */ |
2712 */ |
2715 LOCAL_C void TestMultipleViews2L(CLogClient& aClient) |
2713 LOCAL_C void TestMultipleViews2L(CLogClient& aClient) |
2716 { |
2714 { |
2717 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0944 ")); |
2715 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0944 ")); |
2718 CTestActive* active1 = new(ELeave)CTestActive; |
2716 CTestActive* active1 = new(ELeave)CTestActive; |
2719 CleanupStack::PushL(active1); |
2717 CleanupStack::PushL(active1); |
2720 |
2718 |
2721 // Wait a second |
2719 // Wait a second |
2722 User::After(1000000); |
2720 User::After(1000000); |
3287 @SYMTestExpectedResults Test must not fail |
3285 @SYMTestExpectedResults Test must not fail |
3288 @SYMREQ REQ0000 |
3286 @SYMREQ REQ0000 |
3289 */ |
3287 */ |
3290 LOCAL_C void TestViewChangeEventsL(CLogClient& aClient) |
3288 LOCAL_C void TestViewChangeEventsL(CLogClient& aClient) |
3291 { |
3289 { |
3292 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0945 ")); |
3290 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0945 ")); |
3293 TestUtils::DeleteDatabaseL(); |
3291 TestUtils::DeleteDatabaseL(); |
3294 |
3292 |
3295 CLogEvent* event = CLogEvent::NewL(); |
3293 CLogEvent* event = CLogEvent::NewL(); |
3296 CleanupStack::PushL(event); |
3294 CleanupStack::PushL(event); |
3297 event->SetEventType(KLogCallEventTypeUid); |
3295 event->SetEventType(KLogCallEventTypeUid); |
3340 @SYMTestExpectedResults Test must not fail |
3338 @SYMTestExpectedResults Test must not fail |
3341 @SYMREQ REQ0000 |
3339 @SYMREQ REQ0000 |
3342 */ |
3340 */ |
3343 LOCAL_C void TestAltEventsInRecentListL(CLogClient& aClient) |
3341 LOCAL_C void TestAltEventsInRecentListL(CLogClient& aClient) |
3344 { |
3342 { |
3345 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0946 ")); |
3343 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0946 ")); |
3346 CLogEvent* event = CLogEvent::NewL(); |
3344 CLogEvent* event = CLogEvent::NewL(); |
3347 CleanupStack::PushL(event); |
3345 CleanupStack::PushL(event); |
3348 |
3346 |
3349 CTestActive* active = new(ELeave)CTestActive(); |
3347 CTestActive* active = new(ELeave)CTestActive(); |
3350 CleanupStack::PushL(active); |
3348 CleanupStack::PushL(active); |
3438 @SYMTestExpectedResults Test must not fail |
3436 @SYMTestExpectedResults Test must not fail |
3439 @SYMREQ REQ0000 |
3437 @SYMREQ REQ0000 |
3440 */ |
3438 */ |
3441 LOCAL_C void TestFilterByTimeL(CLogClient& aClient) |
3439 LOCAL_C void TestFilterByTimeL(CLogClient& aClient) |
3442 { |
3440 { |
3443 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0947 ")); |
3441 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0947 ")); |
3444 CLogEvent* event = CLogEvent::NewL(); |
3442 CLogEvent* event = CLogEvent::NewL(); |
3445 CleanupStack::PushL(event); |
3443 CleanupStack::PushL(event); |
3446 |
3444 |
3447 CTestActive* active = new(ELeave)CTestActive(); |
3445 CTestActive* active = new(ELeave)CTestActive(); |
3448 CleanupStack::PushL(active); |
3446 CleanupStack::PushL(active); |
3569 @SYMTestExpectedResults Test must not fail |
3567 @SYMTestExpectedResults Test must not fail |
3570 @SYMREQ REQ0000 |
3568 @SYMREQ REQ0000 |
3571 */ |
3569 */ |
3572 LOCAL_C void TestHiddenChangeEvents1L(CLogClient& aClient) |
3570 LOCAL_C void TestHiddenChangeEvents1L(CLogClient& aClient) |
3573 { |
3571 { |
3574 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0948 ")); |
3572 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0948 ")); |
3575 TLogId logId; |
3573 TLogId logId; |
3576 TInt viewIndex; |
3574 TInt viewIndex; |
3577 TLogDatabaseChangeType type; |
3575 TLogDatabaseChangeType type; |
3578 |
3576 |
3579 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
3577 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
3685 @SYMTestExpectedResults Test must not fail |
3683 @SYMTestExpectedResults Test must not fail |
3686 @SYMREQ REQ0000 |
3684 @SYMREQ REQ0000 |
3687 */ |
3685 */ |
3688 LOCAL_C void TestHiddenChangeEvents2L(CLogClient& aClient) |
3686 LOCAL_C void TestHiddenChangeEvents2L(CLogClient& aClient) |
3689 { |
3687 { |
3690 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0949 ")); |
3688 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0949 ")); |
3691 TLogId logId; |
3689 TLogId logId; |
3692 TInt viewIndex; |
3690 TInt viewIndex; |
3693 TLogDatabaseChangeType type; |
3691 TLogDatabaseChangeType type; |
3694 |
3692 |
3695 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
3693 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
3808 @SYMTestExpectedResults Test must not fail |
3806 @SYMTestExpectedResults Test must not fail |
3809 @SYMREQ REQ0000 |
3807 @SYMREQ REQ0000 |
3810 */ |
3808 */ |
3811 LOCAL_C void TestHiddenChangeEvents3L(CLogClient& aClient) |
3809 LOCAL_C void TestHiddenChangeEvents3L(CLogClient& aClient) |
3812 { |
3810 { |
3813 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0950 ")); |
3811 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0950 ")); |
3814 TLogId logId; |
3812 TLogId logId; |
3815 TInt viewIndex; |
3813 TInt viewIndex; |
3816 TLogDatabaseChangeType type; |
3814 TLogDatabaseChangeType type; |
3817 |
3815 |
3818 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
3816 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
3929 @SYMTestExpectedResults Test must not fail |
3927 @SYMTestExpectedResults Test must not fail |
3930 @SYMREQ REQ0000 |
3928 @SYMREQ REQ0000 |
3931 */ |
3929 */ |
3932 LOCAL_C void TestHiddenChangeEvents4L(CLogClient& aClient) |
3930 LOCAL_C void TestHiddenChangeEvents4L(CLogClient& aClient) |
3933 { |
3931 { |
3934 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0951 ")); |
3932 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0951 ")); |
3935 TLogId logId; |
3933 TLogId logId; |
3936 TInt viewIndex; |
3934 TInt viewIndex; |
3937 TLogDatabaseChangeType type; |
3935 TLogDatabaseChangeType type; |
3938 |
3936 |
3939 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
3937 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
4040 @SYMTestExpectedResults Test must not fail |
4038 @SYMTestExpectedResults Test must not fail |
4041 @SYMREQ REQ0000 |
4039 @SYMREQ REQ0000 |
4042 */ |
4040 */ |
4043 LOCAL_C void TestHiddenChangeEvents5L(CLogClient& aClient) |
4041 LOCAL_C void TestHiddenChangeEvents5L(CLogClient& aClient) |
4044 { |
4042 { |
4045 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0952 ")); |
4043 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0952 ")); |
4046 TLogId logId; |
4044 TLogId logId; |
4047 TInt viewIndex; |
4045 TInt viewIndex; |
4048 TLogDatabaseChangeType type; |
4046 TLogDatabaseChangeType type; |
4049 |
4047 |
4050 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
4048 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
4150 @SYMTestExpectedResults Test must not fail |
4148 @SYMTestExpectedResults Test must not fail |
4151 @SYMREQ REQ0000 |
4149 @SYMREQ REQ0000 |
4152 */ |
4150 */ |
4153 LOCAL_C void TestHiddenChangeEvents6L(CLogClient& aClient) |
4151 LOCAL_C void TestHiddenChangeEvents6L(CLogClient& aClient) |
4154 { |
4152 { |
4155 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0953 ")); |
4153 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0953 ")); |
4156 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
4154 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
4157 changeObs1->StartCollectingChanges(); |
4155 changeObs1->StartCollectingChanges(); |
4158 |
4156 |
4159 CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs1); |
4157 CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs1); |
4160 CleanupStack::PushL(view); |
4158 CleanupStack::PushL(view); |
4259 @SYMTestExpectedResults Test must not fail |
4257 @SYMTestExpectedResults Test must not fail |
4260 @SYMREQ REQ0000 |
4258 @SYMREQ REQ0000 |
4261 */ |
4259 */ |
4262 LOCAL_C void TestHiddenChangeEvents7L(CLogClient& aClient) |
4260 LOCAL_C void TestHiddenChangeEvents7L(CLogClient& aClient) |
4263 { |
4261 { |
4264 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0954 ")); |
4262 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0954 ")); |
4265 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
4263 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
4266 changeObs1->StartCollectingChanges(); |
4264 changeObs1->StartCollectingChanges(); |
4267 |
4265 |
4268 CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs1); |
4266 CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs1); |
4269 CleanupStack::PushL(view); |
4267 CleanupStack::PushL(view); |
4361 @SYMTestExpectedResults Test must not fail |
4359 @SYMTestExpectedResults Test must not fail |
4362 @SYMDEF DEF066296 |
4360 @SYMDEF DEF066296 |
4363 */ |
4361 */ |
4364 LOCAL_C void DEF066296L(CLogClient& aClient) |
4362 LOCAL_C void DEF066296L(CLogClient& aClient) |
4365 { |
4363 { |
4366 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1363 ")); |
4364 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1363 ")); |
4367 TBuf<KLogMaxDirectionLength> buf; |
4365 TBuf<KLogMaxDirectionLength> buf; |
4368 |
4366 |
4369 CLogEvent* event = CLogEvent::NewL(); |
4367 CLogEvent* event = CLogEvent::NewL(); |
4370 CleanupStack::PushL(event); |
4368 CleanupStack::PushL(event); |
4371 |
4369 |
4386 CActiveScheduler::Start(); |
4384 CActiveScheduler::Start(); |
4387 TEST2(active->iStatus.Int(), KErrNone); |
4385 TEST2(active->iStatus.Int(), KErrNone); |
4388 |
4386 |
4389 // Set up the view to display the recent call list |
4387 // Set up the view to display the recent call list |
4390 active->StartL(); |
4388 active->StartL(); |
4391 test(view->SetRecentListL(-1, active->iStatus)); |
4389 TEST(view->SetRecentListL(-1, active->iStatus)); |
4392 CActiveScheduler::Start(); |
4390 CActiveScheduler::Start(); |
4393 TEST2(active->iStatus.Int(), KErrNone); |
4391 TEST2(active->iStatus.Int(), KErrNone); |
4394 |
4392 |
4395 // Get and print current UTC time |
4393 // Get and print current UTC time |
4396 TTime now; |
4394 TTime now; |
4397 now.UniversalTime(); |
4395 now.UniversalTime(); |
4398 TBuf<0x80> testString; |
4396 TBuf<0x80> testString; |
4399 now.FormatL(testString,(_L("%H:%T %1\\%2\\%3 %E"))); |
4397 now.FormatL(testString,(_L("%H:%T %1\\%2\\%3 %E"))); |
4400 RDebug::Print(_L("Current UTC time - %S\n"), &testString); |
4398 TheTest.Printf(_L("Current UTC time - %S\n"), &testString); |
4401 |
4399 |
4402 // Move the UTC time forward by one day |
4400 // Move the UTC time forward by one day |
4403 now += TTimeIntervalDays(1); |
4401 now += TTimeIntervalDays(1); |
4404 User::SetUTCTime(now); |
4402 User::SetUTCTime(now); |
4405 |
4403 |
4406 now.FormatL(testString,(_L("%H:%T %1\\%2\\%3 %E"))); |
4404 now.FormatL(testString,(_L("%H:%T %1\\%2\\%3 %E"))); |
4407 RDebug::Print(_L("Changed UTC time to - %S\n"), &testString); |
4405 TheTest.Printf(_L("Changed UTC time to - %S\n"), &testString); |
4408 |
4406 |
4409 // Set up the event and log a call from number 555 |
4407 // Set up the event and log a call from number 555 |
4410 event->SetNumber(_L("555")); |
4408 event->SetNumber(_L("555")); |
4411 active->StartL(); |
4409 active->StartL(); |
4412 aClient.AddEvent(*event, active->iStatus); |
4410 aClient.AddEvent(*event, active->iStatus); |
4456 now.UniversalTime(); |
4454 now.UniversalTime(); |
4457 now -= TTimeIntervalDays(1); |
4455 now -= TTimeIntervalDays(1); |
4458 User::SetUTCTime(now); |
4456 User::SetUTCTime(now); |
4459 |
4457 |
4460 now.FormatL(testString,(_L("%H:%T %1\\%2\\%3 %E"))); |
4458 now.FormatL(testString,(_L("%H:%T %1\\%2\\%3 %E"))); |
4461 RDebug::Print(_L("Restored UTC time to - %S\n"), &testString); |
4459 TheTest.Printf(_L("Restored UTC time to - %S\n"), &testString); |
4462 |
4460 |
4463 CleanupStack::PopAndDestroy(3, event); //event, active, view |
4461 CleanupStack::PopAndDestroy(3, event); //event, active, view |
4464 } |
4462 } |
4465 |
4463 |
4466 /** |
4464 /** |
4471 @SYMTestExpectedResults Test must not fail |
4469 @SYMTestExpectedResults Test must not fail |
4472 @SYMDEF DEF087459 |
4470 @SYMDEF DEF087459 |
4473 */ |
4471 */ |
4474 LOCAL_C void DEF087459L(CLogClient& aClient) |
4472 LOCAL_C void DEF087459L(CLogClient& aClient) |
4475 { |
4473 { |
4476 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1807 ")); |
4474 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1807 ")); |
4477 RTz tz; |
4475 RTz tz; |
4478 TInt err = tz.Connect(); |
4476 TInt err = tz.Connect(); |
4479 TEST2(err, KErrNone); |
4477 TEST2(err, KErrNone); |
4480 CleanupClosePushL(tz); |
4478 CleanupClosePushL(tz); |
4481 TTime now, saveNow; |
4479 TTime now, saveNow; |
4484 now.HomeTime(); |
4482 now.HomeTime(); |
4485 saveNow=now; |
4483 saveNow=now; |
4486 |
4484 |
4487 TBuf<0x80> testString; |
4485 TBuf<0x80> testString; |
4488 now.FormatL(testString,(_L("%H:%T %1\\%2\\%3 %E"))); |
4486 now.FormatL(testString,(_L("%H:%T %1\\%2\\%3 %E"))); |
4489 RDebug::Print(_L("Current home time - %S\n"), &testString); |
4487 TheTest.Printf(_L("Current home time - %S\n"), &testString); |
4490 |
4488 |
4491 // Problem occurred between midnight and 01:00am hometime, so change home time to |
4489 // Problem occurred between midnight and 01:00am hometime, so change home time to |
4492 // be 00:30am |
4490 // be 00:30am |
4493 TDateTime midnight = now.DateTime(); |
4491 TDateTime midnight = now.DateTime(); |
4494 midnight.SetHour(0); |
4492 midnight.SetHour(0); |
4502 TEST2(err, KErrNone); |
4500 TEST2(err, KErrNone); |
4503 |
4501 |
4504 // Get and print new home time |
4502 // Get and print new home time |
4505 now.HomeTime(); |
4503 now.HomeTime(); |
4506 now.FormatL(testString,(_L("%H:%T %1\\%2\\%3 %E"))); |
4504 now.FormatL(testString,(_L("%H:%T %1\\%2\\%3 %E"))); |
4507 RDebug::Print(_L("Changed home time to - %S\n"), &testString); |
4505 TheTest.Printf(_L("Changed home time to - %S\n"), &testString); |
4508 RDebug::Print(_L("Re-running DEF066296 test\n")); |
4506 TheTest.Printf(_L("Re-running DEF066296 test\n")); |
4509 |
4507 |
4510 DEF066296L(aClient); |
4508 DEF066296L(aClient); |
4511 |
4509 |
4512 // Restore and print hometime |
4510 // Restore and print hometime |
4513 err = tz.SetHomeTime(saveNow); |
4511 err = tz.SetHomeTime(saveNow); |
4514 TEST2(err, KErrNone); |
4512 TEST2(err, KErrNone); |
4515 now.HomeTime(); |
4513 now.HomeTime(); |
4516 now.FormatL(testString,(_L("%H:%T %1\\%2\\%3 %E"))); |
4514 now.FormatL(testString,(_L("%H:%T %1\\%2\\%3 %E"))); |
4517 RDebug::Print(_L("Restored home time to - %S\n"), &testString); |
4515 TheTest.Printf(_L("Restored home time to - %S\n"), &testString); |
4518 |
4516 |
4519 CleanupStack::PopAndDestroy(); //tz |
4517 CleanupStack::PopAndDestroy(); //tz |
4520 } |
4518 } |
4521 |
4519 |
4522 /** |
4520 /** |
4527 @SYMTestExpectedResults Test must not fail |
4525 @SYMTestExpectedResults Test must not fail |
4528 @SYMREQ REQ0000 |
4526 @SYMREQ REQ0000 |
4529 */ |
4527 */ |
4530 LOCAL_C void TestChangeEventRecentView1L(CLogClient& aClient) |
4528 LOCAL_C void TestChangeEventRecentView1L(CLogClient& aClient) |
4531 { |
4529 { |
4532 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0955 ")); |
4530 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0955 ")); |
4533 CTestActive* active = new(ELeave)CTestActive(); |
4531 CTestActive* active = new(ELeave)CTestActive(); |
4534 CleanupStack::PushL(active); |
4532 CleanupStack::PushL(active); |
4535 |
4533 |
4536 CLogEvent* event = CLogEvent::NewL(); |
4534 CLogEvent* event = CLogEvent::NewL(); |
4537 CleanupStack::PushL(event); |
4535 CleanupStack::PushL(event); |
4809 @SYMTestExpectedResults Test must not fail |
4807 @SYMTestExpectedResults Test must not fail |
4810 @SYMREQ REQ0000 |
4808 @SYMREQ REQ0000 |
4811 */ |
4809 */ |
4812 LOCAL_C void TestChangeEventRecentView2L(CLogClient& aClient) |
4810 LOCAL_C void TestChangeEventRecentView2L(CLogClient& aClient) |
4813 { |
4811 { |
4814 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0956 ")); |
4812 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0956 ")); |
4815 CTestActive* active = new(ELeave)CTestActive(); |
4813 CTestActive* active = new(ELeave)CTestActive(); |
4816 CleanupStack::PushL(active); |
4814 CleanupStack::PushL(active); |
4817 |
4815 |
4818 CLogEvent* event = CLogEvent::NewL(); |
4816 CLogEvent* event = CLogEvent::NewL(); |
4819 CleanupStack::PushL(event); |
4817 CleanupStack::PushL(event); |
5089 @SYMTestExpectedResults Test must not fail |
5087 @SYMTestExpectedResults Test must not fail |
5090 @SYMREQ REQ0000 |
5088 @SYMREQ REQ0000 |
5091 */ |
5089 */ |
5092 LOCAL_C void TestChangeEventRecentViewAndPurgeL(CLogClient& aClient) |
5090 LOCAL_C void TestChangeEventRecentViewAndPurgeL(CLogClient& aClient) |
5093 { |
5091 { |
5094 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0957 ")); |
5092 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0957 ")); |
5095 CTestActive* active = new(ELeave)CTestActive(); |
5093 CTestActive* active = new(ELeave)CTestActive(); |
5096 CleanupStack::PushL(active); |
5094 CleanupStack::PushL(active); |
5097 |
5095 |
5098 CLogEvent* event = CLogEvent::NewL(); |
5096 CLogEvent* event = CLogEvent::NewL(); |
5099 CleanupStack::PushL(event); |
5097 CleanupStack::PushL(event); |
5330 @SYMTestExpectedResults Test must not fail |
5328 @SYMTestExpectedResults Test must not fail |
5331 @SYMREQ REQ0000 |
5329 @SYMREQ REQ0000 |
5332 */ |
5330 */ |
5333 LOCAL_C void TestChangeEventRecentViewRemoveL(CLogClient& aClient) |
5331 LOCAL_C void TestChangeEventRecentViewRemoveL(CLogClient& aClient) |
5334 { |
5332 { |
5335 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0958 ")); |
5333 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0958 ")); |
5336 CTestActive* active = new(ELeave)CTestActive(); |
5334 CTestActive* active = new(ELeave)CTestActive(); |
5337 CleanupStack::PushL(active); |
5335 CleanupStack::PushL(active); |
5338 |
5336 |
5339 CLogEvent* event = CLogEvent::NewL(); |
5337 CLogEvent* event = CLogEvent::NewL(); |
5340 CleanupStack::PushL(event); |
5338 CleanupStack::PushL(event); |
5509 return TestUtils::IsDatabaseOpenL(); |
5507 return TestUtils::IsDatabaseOpenL(); |
5510 } |
5508 } |
5511 |
5509 |
5512 LOCAL_C void TestLogOpenL() |
5510 LOCAL_C void TestLogOpenL() |
5513 { |
5511 { |
5514 test(IsLogOpenL()); |
5512 TEST(IsLogOpenL()); |
5515 } |
5513 } |
5516 |
5514 |
5517 LOCAL_C void TestLogClosedL() |
5515 LOCAL_C void TestLogClosedL() |
5518 { |
5516 { |
5519 test(!IsLogOpenL()); |
5517 TEST(!IsLogOpenL()); |
5520 } |
5518 } |
5521 |
5519 |
5522 LOCAL_C void StartBackupL() |
5520 LOCAL_C void StartBackupL() |
5523 { |
5521 { |
5524 User::InfoPrint(_L("Backup")); |
5522 User::InfoPrint(_L("Backup")); |
5561 @SYMTestExpectedResults Test must not fail |
5559 @SYMTestExpectedResults Test must not fail |
5562 @SYMREQ REQ0000 |
5560 @SYMREQ REQ0000 |
5563 */ |
5561 */ |
5564 LOCAL_C void TestHiddenChangeEvents1aL(CLogClient& aClient) |
5562 LOCAL_C void TestHiddenChangeEvents1aL(CLogClient& aClient) |
5565 { |
5563 { |
5566 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0959 ")); |
5564 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0959 ")); |
5567 TLogId logId; |
5565 TLogId logId; |
5568 TInt viewIndex; |
5566 TInt viewIndex; |
5569 TLogDatabaseChangeType type; |
5567 TLogDatabaseChangeType type; |
5570 |
5568 |
5571 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
5569 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
5590 |
5588 |
5591 // Get rid of all the events in the log |
5589 // Get rid of all the events in the log |
5592 active->StartL(); |
5590 active->StartL(); |
5593 aClient.ClearLog(now, active->iStatus); |
5591 aClient.ClearLog(now, active->iStatus); |
5594 CActiveScheduler::Start(); |
5592 CActiveScheduler::Start(); |
5595 test(active->iStatus.Int() == KErrNone); |
5593 TEST2(active->iStatus.Int(), KErrNone); |
5596 |
5594 |
5597 // Incoming call event |
5595 // Incoming call event |
5598 event->SetEventType(KLogCallEventTypeUid); |
5596 event->SetEventType(KLogCallEventTypeUid); |
5599 TBuf<KLogMaxDirectionLength> buf; |
5597 TBuf<KLogMaxDirectionLength> buf; |
5600 aClient.GetString(buf, R_LOG_DIR_IN); |
5598 aClient.GetString(buf, R_LOG_DIR_IN); |
5602 |
5600 |
5603 // Add an event |
5601 // Add an event |
5604 active->StartL(); |
5602 active->StartL(); |
5605 aClient.AddEvent(*event, active->iStatus); |
5603 aClient.AddEvent(*event, active->iStatus); |
5606 CActiveScheduler::Start(); |
5604 CActiveScheduler::Start(); |
5607 test(active->iStatus == KErrNone); |
5605 TEST2(active->iStatus.Int(), KErrNone); |
5608 |
5606 |
5609 // Setup normal event view |
5607 // Setup normal event view |
5610 active->StartL(); |
5608 active->StartL(); |
5611 test(view->SetFilterL(*filter, active->iStatus)); |
5609 TEST(view->SetFilterL(*filter, active->iStatus)); |
5612 CActiveScheduler::Start(); |
5610 CActiveScheduler::Start(); |
5613 test(active->iStatus == KErrNone); |
5611 TEST2(active->iStatus.Int(), KErrNone); |
5614 |
5612 |
5615 CLogViewChangeObserver* changeObs2 = CLogViewChangeObserver::NewLC(); |
5613 CLogViewChangeObserver* changeObs2 = CLogViewChangeObserver::NewLC(); |
5616 changeObs2->StartCollectingChanges(); |
5614 changeObs2->StartCollectingChanges(); |
5617 |
5615 |
5618 CLogViewRecent* recent = CLogViewRecent::NewL(aClient, *changeObs2); |
5616 CLogViewRecent* recent = CLogViewRecent::NewL(aClient, *changeObs2); |
5619 CleanupStack::PushL(recent); |
5617 CleanupStack::PushL(recent); |
5620 |
5618 |
5621 // Check recent view |
5619 // Check recent view |
5622 active->StartL(); |
5620 active->StartL(); |
5623 test(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
5621 TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
5624 CActiveScheduler::Start(); |
5622 CActiveScheduler::Start(); |
5625 test(active->iStatus == KErrNone); |
5623 TEST2(active->iStatus.Int(), KErrNone); |
5626 test(recent->CountL() == 1); |
5624 TEST2(recent->CountL(), 1); |
5627 |
5625 |
5628 // Add a new event |
5626 // Add a new event |
5629 active->StartL(); |
5627 active->StartL(); |
5630 aClient.AddEvent(*event, active->iStatus); |
5628 aClient.AddEvent(*event, active->iStatus); |
5631 CActiveScheduler::Start(); |
5629 CActiveScheduler::Start(); |
5632 test(active->iStatus == KErrNone); |
5630 TEST2(active->iStatus.Int(), KErrNone); |
5633 |
5631 |
5634 // Check that changes work after a backup |
5632 // Check that changes work after a backup |
5635 StartBackupL(); |
5633 StartBackupL(); |
5636 DelayL(1000000); |
5634 DelayL(1000000); |
5637 TestLogClosedL(); |
5635 TestLogClosedL(); |
5638 EndBackupL(); |
5636 EndBackupL(); |
5639 DelayL(1000000); |
5637 DelayL(1000000); |
5640 TestLogOpenL(); |
5638 TestLogOpenL(); |
5641 |
5639 |
5642 test(changeObs2->Changes().Count() == 2); |
5640 TEST2(changeObs2->Changes().Count(), 2); |
5643 type = changeObs2->Changes().At(0, logId, viewIndex); |
5641 type = changeObs2->Changes().At(0, logId, viewIndex); |
5644 test(type == ELogChangeTypeEventAdded); |
5642 TEST2(type, ELogChangeTypeEventAdded); |
5645 type = changeObs2->Changes().At(1, logId, viewIndex); |
5643 type = changeObs2->Changes().At(1, logId, viewIndex); |
5646 test(type == ELogChangeTypeEventDeleted); |
5644 TEST2(type, ELogChangeTypeEventDeleted); |
5647 |
5645 |
5648 // Check recent view |
5646 // Check recent view |
5649 active->StartL(); |
5647 active->StartL(); |
5650 test(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
5648 TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
5651 CActiveScheduler::Start(); |
5649 CActiveScheduler::Start(); |
5652 test(active->iStatus == KErrNone); |
5650 TEST2(active->iStatus.Int(), KErrNone); |
5653 test(recent->CountL() == 1); |
5651 TEST2(recent->CountL(), 1); |
5654 |
5652 |
5655 CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(aClient); |
5653 CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(aClient); |
5656 CleanupStack::PushL(duplicate); |
5654 CleanupStack::PushL(duplicate); |
5657 |
5655 |
5658 // Check duplicate count |
5656 // Check duplicate count |
5659 active->StartL(); |
5657 active->StartL(); |
5660 test(recent->DuplicatesL(*duplicate, active->iStatus)); |
5658 TEST(recent->DuplicatesL(*duplicate, active->iStatus)); |
5661 CActiveScheduler::Start(); |
5659 CActiveScheduler::Start(); |
5662 test(active->iStatus.Int() == KErrNone); |
5660 TEST2(active->iStatus.Int(), KErrNone); |
5663 test(duplicate->CountL() == 1); |
5661 TEST2(duplicate->CountL(), 1); |
5664 |
5662 |
5665 // Check that changes work after a backup |
5663 // Check that changes work after a backup |
5666 StartBackupL(); |
5664 StartBackupL(); |
5667 DelayL(1000000); |
5665 DelayL(1000000); |
5668 TestLogClosedL(); |
5666 TestLogClosedL(); |
5669 EndBackupL(); |
5667 EndBackupL(); |
5670 TestLogOpenL(); |
5668 TestLogOpenL(); |
5671 |
5669 |
5672 // Check change events |
5670 // Check change events |
5673 User::After(100000); |
5671 User::After(100000); |
5674 test(changeObs1->Changes().Count() == 1); |
5672 TEST2(changeObs1->Changes().Count(), 1); |
5675 type = changeObs1->Changes().At(0, logId, viewIndex); |
5673 type = changeObs1->Changes().At(0, logId, viewIndex); |
5676 test(type == ELogChangeTypeEventAdded); |
5674 TEST2(type, ELogChangeTypeEventAdded); |
5677 |
5675 |
5678 CleanupStack::PopAndDestroy(8, changeObs1); // changeObs1, changeObs2, view, filter, event, active, recent, duplicate |
5676 CleanupStack::PopAndDestroy(8, changeObs1); // changeObs1, changeObs2, view, filter, event, active, recent, duplicate |
5679 } |
5677 } |
5680 |
5678 |
5681 /** |
5679 /** |
5688 @SYMTestExpectedResults Test must not fail |
5686 @SYMTestExpectedResults Test must not fail |
5689 @SYMREQ REQ0000 |
5687 @SYMREQ REQ0000 |
5690 */ |
5688 */ |
5691 LOCAL_C void TestHiddenChangeEvents2aL(CLogClient& aClient) |
5689 LOCAL_C void TestHiddenChangeEvents2aL(CLogClient& aClient) |
5692 { |
5690 { |
5693 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0960 ")); |
5691 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0960 ")); |
5694 TLogId logId; |
5692 TLogId logId; |
5695 TInt viewIndex; |
5693 TInt viewIndex; |
5696 TLogDatabaseChangeType type; |
5694 TLogDatabaseChangeType type; |
5697 |
5695 |
5698 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
5696 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
5716 |
5714 |
5717 // Get rid of all the events in the log |
5715 // Get rid of all the events in the log |
5718 active->StartL(); |
5716 active->StartL(); |
5719 aClient.ClearLog(now, active->iStatus); |
5717 aClient.ClearLog(now, active->iStatus); |
5720 CActiveScheduler::Start(); |
5718 CActiveScheduler::Start(); |
5721 test(active->iStatus.Int() == KErrNone); |
5719 TEST2(active->iStatus.Int(), KErrNone); |
5722 |
5720 |
5723 // Get config |
5721 // Get config |
5724 TLogConfig config; |
5722 TLogConfig config; |
5725 active->StartL(); |
5723 active->StartL(); |
5726 aClient.GetConfig(config, active->iStatus); |
5724 aClient.GetConfig(config, active->iStatus); |
5727 CActiveScheduler::Start(); |
5725 CActiveScheduler::Start(); |
5728 test(active->iStatus == KErrNone); |
5726 TEST2(active->iStatus.Int(), KErrNone); |
5729 |
5727 |
5730 // Incoming call event |
5728 // Incoming call event |
5731 event->SetEventType(KLogCallEventTypeUid); |
5729 event->SetEventType(KLogCallEventTypeUid); |
5732 TBuf<KLogMaxDirectionLength> buf; |
5730 TBuf<KLogMaxDirectionLength> buf; |
5733 aClient.GetString(buf, R_LOG_DIR_IN); |
5731 aClient.GetString(buf, R_LOG_DIR_IN); |
5739 { |
5737 { |
5740 event->SetContact(count+1); |
5738 event->SetContact(count+1); |
5741 active->StartL(); |
5739 active->StartL(); |
5742 aClient.AddEvent(*event, active->iStatus); |
5740 aClient.AddEvent(*event, active->iStatus); |
5743 CActiveScheduler::Start(); |
5741 CActiveScheduler::Start(); |
5744 test(active->iStatus == KErrNone); |
5742 TEST2(active->iStatus.Int(), KErrNone); |
5745 } |
5743 } |
5746 |
5744 |
5747 // Setup normal event view |
5745 // Setup normal event view |
5748 active->StartL(); |
5746 active->StartL(); |
5749 test(view->SetFilterL(*filter, active->iStatus)); |
5747 TEST(view->SetFilterL(*filter, active->iStatus)); |
5750 CActiveScheduler::Start(); |
5748 CActiveScheduler::Start(); |
5751 test(active->iStatus == KErrNone); |
5749 TEST2(active->iStatus.Int(), KErrNone); |
5752 |
5750 |
5753 CLogViewChangeObserver* changeObs2 = CLogViewChangeObserver::NewLC(); |
5751 CLogViewChangeObserver* changeObs2 = CLogViewChangeObserver::NewLC(); |
5754 changeObs2->StartCollectingChanges(); |
5752 changeObs2->StartCollectingChanges(); |
5755 |
5753 |
5756 CLogViewRecent* recent = CLogViewRecent::NewL(aClient, *changeObs2); |
5754 CLogViewRecent* recent = CLogViewRecent::NewL(aClient, *changeObs2); |
5757 CleanupStack::PushL(recent); |
5755 CleanupStack::PushL(recent); |
5758 |
5756 |
5759 // Check recent view |
5757 // Check recent view |
5760 active->StartL(); |
5758 active->StartL(); |
5761 test(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
5759 TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
5762 CActiveScheduler::Start(); |
5760 CActiveScheduler::Start(); |
5763 test(active->iStatus == KErrNone); |
5761 TEST2(active->iStatus.Int(), KErrNone); |
5764 test(recent->CountL() == config.iMaxRecentLogSize); |
5762 TEST2(recent->CountL(), config.iMaxRecentLogSize); |
5765 |
5763 |
5766 // Add a new event, will cause one to be purged from recent view |
5764 // Add a new event, will cause one to be purged from recent view |
5767 event->SetContact(1234); |
5765 event->SetContact(1234); |
5768 active->StartL(); |
5766 active->StartL(); |
5769 aClient.AddEvent(*event, active->iStatus); |
5767 aClient.AddEvent(*event, active->iStatus); |
5770 CActiveScheduler::Start(); |
5768 CActiveScheduler::Start(); |
5771 test(active->iStatus == KErrNone); |
5769 TEST2(active->iStatus.Int(), KErrNone); |
5772 |
5770 |
5773 // Check that changes work after a backup |
5771 // Check that changes work after a backup |
5774 StartBackupL(); |
5772 StartBackupL(); |
5775 DelayL(1000000); |
5773 DelayL(1000000); |
5776 TestLogClosedL(); |
5774 TestLogClosedL(); |
5777 EndBackupL(); |
5775 EndBackupL(); |
5778 TestLogOpenL(); |
5776 TestLogOpenL(); |
5779 DelayL(1000000); |
5777 DelayL(1000000); |
5780 |
5778 |
5781 test(changeObs2->Changes().Count() == 2); |
5779 TEST2(changeObs2->Changes().Count(), 2); |
5782 type = changeObs2->Changes().At(0, logId, viewIndex); |
5780 type = changeObs2->Changes().At(0, logId, viewIndex); |
5783 test(type == ELogChangeTypeEventAdded); |
5781 TEST2(type, ELogChangeTypeEventAdded); |
5784 type = changeObs2->Changes().At(1, logId, viewIndex); |
5782 type = changeObs2->Changes().At(1, logId, viewIndex); |
5785 test(type == ELogChangeTypeEventDeleted); |
5783 TEST2(type, ELogChangeTypeEventDeleted); |
5786 |
5784 |
5787 // Check recent view |
5785 // Check recent view |
5788 active->StartL(); |
5786 active->StartL(); |
5789 test(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
5787 TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
5790 CActiveScheduler::Start(); |
5788 CActiveScheduler::Start(); |
5791 test(active->iStatus == KErrNone); |
5789 TEST2(active->iStatus.Int(), KErrNone); |
5792 test(recent->CountL() == config.iMaxRecentLogSize); |
5790 TEST2(recent->CountL(), config.iMaxRecentLogSize); |
5793 |
5791 |
5794 CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(aClient); |
5792 CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(aClient); |
5795 CleanupStack::PushL(duplicate); |
5793 CleanupStack::PushL(duplicate); |
5796 |
5794 |
5797 // Check duplicate count |
5795 // Check duplicate count |
5798 test(!recent->DuplicatesL(*duplicate, active->iStatus)); |
5796 TEST(!recent->DuplicatesL(*duplicate, active->iStatus)); |
5799 |
5797 |
5800 // Check that changes work after a backup |
5798 // Check that changes work after a backup |
5801 StartBackupL(); |
5799 StartBackupL(); |
5802 DelayL(1000000); |
5800 DelayL(1000000); |
5803 TestLogClosedL(); |
5801 TestLogClosedL(); |
5804 EndBackupL(); |
5802 EndBackupL(); |
5805 TestLogOpenL(); |
5803 TestLogOpenL(); |
5806 |
5804 |
5807 // Check change events |
5805 // Check change events |
5808 User::After(100000); |
5806 User::After(100000); |
5809 test(changeObs1->Changes().Count() == 1); |
5807 TEST2(changeObs1->Changes().Count(), 1); |
5810 type = changeObs1->Changes().At(0, logId, viewIndex); |
5808 type = changeObs1->Changes().At(0, logId, viewIndex); |
5811 test(type == ELogChangeTypeEventAdded); |
5809 TEST2(type, ELogChangeTypeEventAdded); |
5812 |
5810 |
5813 CleanupStack::PopAndDestroy(8, changeObs1); // changeObs1, changeObs2, view, filter, event, active, recent, duplicate |
5811 CleanupStack::PopAndDestroy(8, changeObs1); // changeObs1, changeObs2, view, filter, event, active, recent, duplicate |
5814 } |
5812 } |
5815 |
5813 |
5816 /** |
5814 /** |
5823 @SYMTestExpectedResults Test must not fail |
5821 @SYMTestExpectedResults Test must not fail |
5824 @SYMREQ REQ0000 |
5822 @SYMREQ REQ0000 |
5825 */ |
5823 */ |
5826 LOCAL_C void TestHiddenChangeEvents3aL(CLogClient& aClient) |
5824 LOCAL_C void TestHiddenChangeEvents3aL(CLogClient& aClient) |
5827 { |
5825 { |
5828 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0961 ")); |
5826 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0961 ")); |
5829 TLogId logId; |
5827 TLogId logId; |
5830 TInt viewIndex; |
5828 TInt viewIndex; |
5831 TLogDatabaseChangeType type; |
5829 TLogDatabaseChangeType type; |
5832 |
5830 |
5833 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
5831 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
5851 |
5849 |
5852 // Get rid of all the events in the log |
5850 // Get rid of all the events in the log |
5853 active->StartL(); |
5851 active->StartL(); |
5854 aClient.ClearLog(now, active->iStatus); |
5852 aClient.ClearLog(now, active->iStatus); |
5855 CActiveScheduler::Start(); |
5853 CActiveScheduler::Start(); |
5856 test(active->iStatus.Int() == KErrNone); |
5854 TEST2(active->iStatus.Int(), KErrNone); |
5857 |
5855 |
5858 // Get and set config |
5856 // Get and set config |
5859 TLogConfig config; |
5857 TLogConfig config; |
5860 active->StartL(); |
5858 active->StartL(); |
5861 aClient.GetConfig(config, active->iStatus); |
5859 aClient.GetConfig(config, active->iStatus); |
5862 CActiveScheduler::Start(); |
5860 CActiveScheduler::Start(); |
5863 test(active->iStatus == KErrNone); |
5861 TEST2(active->iStatus.Int(), KErrNone); |
5864 config.iMaxRecentLogSize = 2; |
5862 config.iMaxRecentLogSize = 2; |
5865 active->StartL(); |
5863 active->StartL(); |
5866 aClient.ChangeConfig(config, active->iStatus); |
5864 aClient.ChangeConfig(config, active->iStatus); |
5867 CActiveScheduler::Start(); |
5865 CActiveScheduler::Start(); |
5868 test(active->iStatus == KErrNone); |
5866 TEST2(active->iStatus.Int(), KErrNone); |
5869 |
5867 |
5870 // Incoming call event |
5868 // Incoming call event |
5871 event->SetEventType(KLogCallEventTypeUid); |
5869 event->SetEventType(KLogCallEventTypeUid); |
5872 TBuf<KLogMaxDirectionLength> buf; |
5870 TBuf<KLogMaxDirectionLength> buf; |
5873 aClient.GetString(buf, R_LOG_DIR_IN); |
5871 aClient.GetString(buf, R_LOG_DIR_IN); |
5879 { |
5877 { |
5880 event->SetContact(count+1); |
5878 event->SetContact(count+1); |
5881 active->StartL(); |
5879 active->StartL(); |
5882 aClient.AddEvent(*event, active->iStatus); |
5880 aClient.AddEvent(*event, active->iStatus); |
5883 CActiveScheduler::Start(); |
5881 CActiveScheduler::Start(); |
5884 test(active->iStatus == KErrNone); |
5882 TEST2(active->iStatus.Int(), KErrNone); |
5885 } |
5883 } |
5886 |
5884 |
5887 // Setup normal event view |
5885 // Setup normal event view |
5888 active->StartL(); |
5886 active->StartL(); |
5889 test(view->SetFilterL(*filter, active->iStatus)); |
5887 TEST(view->SetFilterL(*filter, active->iStatus)); |
5890 CActiveScheduler::Start(); |
5888 CActiveScheduler::Start(); |
5891 test(active->iStatus == KErrNone); |
5889 TEST2(active->iStatus.Int(), KErrNone); |
5892 |
5890 |
5893 CLogViewChangeObserver* changeObs2 = CLogViewChangeObserver::NewLC(); |
5891 CLogViewChangeObserver* changeObs2 = CLogViewChangeObserver::NewLC(); |
5894 changeObs2->StartCollectingChanges(); |
5892 changeObs2->StartCollectingChanges(); |
5895 |
5893 |
5896 CLogViewRecent* recent = CLogViewRecent::NewL(aClient, *changeObs2); |
5894 CLogViewRecent* recent = CLogViewRecent::NewL(aClient, *changeObs2); |
5897 CleanupStack::PushL(recent); |
5895 CleanupStack::PushL(recent); |
5898 |
5896 |
5899 // Check recent view |
5897 // Check recent view |
5900 active->StartL(); |
5898 active->StartL(); |
5901 test(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
5899 TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
5902 CActiveScheduler::Start(); |
5900 CActiveScheduler::Start(); |
5903 test(active->iStatus == KErrNone); |
5901 TEST2(active->iStatus.Int(), KErrNone); |
5904 test(recent->CountL() == config.iMaxRecentLogSize); |
5902 TEST2(recent->CountL(), config.iMaxRecentLogSize); |
5905 |
5903 |
5906 // Change config, will cause one event to be purged from recent view |
5904 // Change config, will cause one event to be purged from recent view |
5907 config.iMaxRecentLogSize = 1; |
5905 config.iMaxRecentLogSize = 1; |
5908 active->StartL(); |
5906 active->StartL(); |
5909 aClient.ChangeConfig(config, active->iStatus); |
5907 aClient.ChangeConfig(config, active->iStatus); |
5910 CActiveScheduler::Start(); |
5908 CActiveScheduler::Start(); |
5911 test(active->iStatus == KErrNone); |
5909 TEST2(active->iStatus.Int(), KErrNone); |
5912 |
5910 |
5913 // Check that changes work after a backup |
5911 // Check that changes work after a backup |
5914 StartBackupL(); |
5912 StartBackupL(); |
5915 DelayL(1000000); |
5913 DelayL(1000000); |
5916 TestLogClosedL(); |
5914 TestLogClosedL(); |
5918 TestLogOpenL(); |
5916 TestLogOpenL(); |
5919 DelayL(1000000); |
5917 DelayL(1000000); |
5920 |
5918 |
5921 // Check change events |
5919 // Check change events |
5922 User::After(100000); |
5920 User::After(100000); |
5923 test(changeObs2->Changes().Count() == 1); |
5921 TEST2(changeObs2->Changes().Count(), 1); |
5924 type = changeObs2->Changes().At(0, logId, viewIndex); |
5922 type = changeObs2->Changes().At(0, logId, viewIndex); |
5925 test(type == ELogChangeTypeEventDeleted); |
5923 TEST2(type, ELogChangeTypeEventDeleted); |
5926 |
5924 |
5927 // Check recent view |
5925 // Check recent view |
5928 active->StartL(); |
5926 active->StartL(); |
5929 test(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
5927 TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
5930 CActiveScheduler::Start(); |
5928 CActiveScheduler::Start(); |
5931 test(active->iStatus == KErrNone); |
5929 TEST2(active->iStatus.Int(), KErrNone); |
5932 test(recent->CountL() == config.iMaxRecentLogSize); |
5930 TEST2(recent->CountL(), config.iMaxRecentLogSize); |
5933 |
5931 |
5934 CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(aClient); |
5932 CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(aClient); |
5935 CleanupStack::PushL(duplicate); |
5933 CleanupStack::PushL(duplicate); |
5936 |
5934 |
5937 // Check duplicate count |
5935 // Check duplicate count |
5938 test(!recent->DuplicatesL(*duplicate, active->iStatus)); |
5936 TEST(!recent->DuplicatesL(*duplicate, active->iStatus)); |
5939 |
5937 |
5940 // Check that changes work after a backup |
5938 // Check that changes work after a backup |
5941 StartBackupL(); |
5939 StartBackupL(); |
5942 DelayL(1000000); |
5940 DelayL(1000000); |
5943 TestLogClosedL(); |
5941 TestLogClosedL(); |
5944 EndBackupL(); |
5942 EndBackupL(); |
5945 TestLogOpenL(); |
5943 TestLogOpenL(); |
5946 |
5944 |
5947 // Check change events |
5945 // Check change events |
5948 User::After(100000); |
5946 User::After(100000); |
5949 test(!changeObs1->HaveChanges()); |
5947 TEST(!changeObs1->HaveChanges()); |
5950 |
5948 |
5951 CleanupStack::PopAndDestroy(8, changeObs1); // changeObs1, changeObs2, view, filter, event, active, recent, duplicate |
5949 CleanupStack::PopAndDestroy(8, changeObs1); // changeObs1, changeObs2, view, filter, event, active, recent, duplicate |
5952 } |
5950 } |
5953 |
5951 |
5954 /** |
5952 /** |
5962 @SYMTestExpectedResults Test must not fail |
5960 @SYMTestExpectedResults Test must not fail |
5963 @SYMREQ REQ0000 |
5961 @SYMREQ REQ0000 |
5964 */ |
5962 */ |
5965 LOCAL_C void TestHiddenChangeEvents4aL(CLogClient& aClient) |
5963 LOCAL_C void TestHiddenChangeEvents4aL(CLogClient& aClient) |
5966 { |
5964 { |
5967 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0962 ")); |
5965 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0962 ")); |
5968 TLogId logId; |
5966 TLogId logId; |
5969 TInt viewIndex; |
5967 TInt viewIndex; |
5970 TLogDatabaseChangeType type; |
5968 TLogDatabaseChangeType type; |
5971 |
5969 |
5972 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
5970 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
5991 |
5989 |
5992 // Get rid of all the events in the log |
5990 // Get rid of all the events in the log |
5993 active->StartL(); |
5991 active->StartL(); |
5994 aClient.ClearLog(now, active->iStatus); |
5992 aClient.ClearLog(now, active->iStatus); |
5995 CActiveScheduler::Start(); |
5993 CActiveScheduler::Start(); |
5996 test(active->iStatus.Int() == KErrNone); |
5994 TEST2(active->iStatus.Int(), KErrNone); |
5997 |
5995 |
5998 // Incoming call event |
5996 // Incoming call event |
5999 event->SetEventType(KLogCallEventTypeUid); |
5997 event->SetEventType(KLogCallEventTypeUid); |
6000 TBuf<KLogMaxDirectionLength> buf; |
5998 TBuf<KLogMaxDirectionLength> buf; |
6001 aClient.GetString(buf, R_LOG_DIR_IN); |
5999 aClient.GetString(buf, R_LOG_DIR_IN); |
6005 |
6003 |
6006 // Add an event |
6004 // Add an event |
6007 active->StartL(); |
6005 active->StartL(); |
6008 aClient.AddEvent(*event, active->iStatus); |
6006 aClient.AddEvent(*event, active->iStatus); |
6009 CActiveScheduler::Start(); |
6007 CActiveScheduler::Start(); |
6010 test(active->iStatus == KErrNone); |
6008 TEST2(active->iStatus.Int(), KErrNone); |
6011 |
6009 |
6012 // Add an event |
6010 // Add an event |
6013 active->StartL(); |
6011 active->StartL(); |
6014 aClient.AddEvent(*event, active->iStatus); |
6012 aClient.AddEvent(*event, active->iStatus); |
6015 CActiveScheduler::Start(); |
6013 CActiveScheduler::Start(); |
6016 test(active->iStatus == KErrNone); |
6014 TEST2(active->iStatus.Int(), KErrNone); |
6017 |
6015 |
6018 event->ClearFlags(0xF); |
6016 event->ClearFlags(0xF); |
6019 |
6017 |
6020 // Add an event |
6018 // Add an event |
6021 active->StartL(); |
6019 active->StartL(); |
6022 aClient.AddEvent(*event, active->iStatus); |
6020 aClient.AddEvent(*event, active->iStatus); |
6023 CActiveScheduler::Start(); |
6021 CActiveScheduler::Start(); |
6024 test(active->iStatus == KErrNone); |
6022 TEST2(active->iStatus.Int(), KErrNone); |
6025 |
6023 |
6026 // Setup normal event view |
6024 // Setup normal event view |
6027 active->StartL(); |
6025 active->StartL(); |
6028 test(view->SetFilterL(*filter, active->iStatus)); |
6026 TEST(view->SetFilterL(*filter, active->iStatus)); |
6029 CActiveScheduler::Start(); |
6027 CActiveScheduler::Start(); |
6030 test(active->iStatus == KErrNone); |
6028 TEST2(active->iStatus.Int(), KErrNone); |
6031 test(view->CountL() == 2); |
6029 TEST2(view->CountL(), 2); |
6032 |
6030 |
6033 CLogViewChangeObserver* changeObs2 = CLogViewChangeObserver::NewLC(); |
6031 CLogViewChangeObserver* changeObs2 = CLogViewChangeObserver::NewLC(); |
6034 changeObs2->StartCollectingChanges(); |
6032 changeObs2->StartCollectingChanges(); |
6035 |
6033 |
6036 CLogViewRecent* recent = CLogViewRecent::NewL(aClient, *changeObs2); |
6034 CLogViewRecent* recent = CLogViewRecent::NewL(aClient, *changeObs2); |
6037 CleanupStack::PushL(recent); |
6035 CleanupStack::PushL(recent); |
6038 |
6036 |
6039 // Check recent view |
6037 // Check recent view |
6040 active->StartL(); |
6038 active->StartL(); |
6041 test(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
6039 TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
6042 CActiveScheduler::Start(); |
6040 CActiveScheduler::Start(); |
6043 test(active->iStatus == KErrNone); |
6041 TEST2(active->iStatus.Int(), KErrNone); |
6044 test(recent->CountL() == 1); |
6042 TEST2(recent->CountL(), 1); |
6045 |
6043 |
6046 changeObs1->StartCollectingChanges(); |
6044 changeObs1->StartCollectingChanges(); |
6047 changeObs2->StartCollectingChanges(); |
6045 changeObs2->StartCollectingChanges(); |
6048 |
6046 |
6049 // Delete the event in recent list |
6047 // Delete the event in recent list |
6050 active->StartL(); |
6048 active->StartL(); |
6051 aClient.DeleteEvent(event->Id(), active->iStatus); |
6049 aClient.DeleteEvent(event->Id(), active->iStatus); |
6052 CActiveScheduler::Start(); |
6050 CActiveScheduler::Start(); |
6053 test(active->iStatus == KErrNone); |
6051 TEST2(active->iStatus.Int(), KErrNone); |
6054 |
6052 |
6055 // Check that changes work after a backup |
6053 // Check that changes work after a backup |
6056 StartBackupL(); |
6054 StartBackupL(); |
6057 DelayL(1000000); |
6055 DelayL(1000000); |
6058 TestLogClosedL(); |
6056 TestLogClosedL(); |
6059 EndBackupL(); |
6057 EndBackupL(); |
6060 TestLogOpenL(); |
6058 TestLogOpenL(); |
6061 |
6059 |
6062 // Check change events |
6060 // Check change events |
6063 test(changeObs2->Changes().Count() == 2); |
6061 TEST2(changeObs2->Changes().Count(), 2); |
6064 type = changeObs2->Changes().At(0, logId, viewIndex); |
6062 type = changeObs2->Changes().At(0, logId, viewIndex); |
6065 test(type == ELogChangeTypeEventAdded); |
6063 TEST2(type, ELogChangeTypeEventAdded); |
6066 type = changeObs2->Changes().At(1, logId, viewIndex); |
6064 type = changeObs2->Changes().At(1, logId, viewIndex); |
6067 test(type == ELogChangeTypeEventDeleted); |
6065 TEST2(type, ELogChangeTypeEventDeleted); |
6068 |
6066 |
6069 test(!changeObs1->HaveChanges()); |
6067 TEST(!changeObs1->HaveChanges()); |
6070 |
6068 |
6071 CleanupStack::PopAndDestroy(7, changeObs1); // changeObs1, changeObs2, view, filter, event, active, recent |
6069 CleanupStack::PopAndDestroy(7, changeObs1); // changeObs1, changeObs2, view, filter, event, active, recent |
6072 } |
6070 } |
6073 |
6071 |
6074 /** |
6072 /** |
6080 @SYMTestExpectedResults Test must not fail |
6078 @SYMTestExpectedResults Test must not fail |
6081 @SYMREQ REQ0000 |
6079 @SYMREQ REQ0000 |
6082 */ |
6080 */ |
6083 LOCAL_C void TestHiddenChangeEvents5aL(CLogClient& aClient) |
6081 LOCAL_C void TestHiddenChangeEvents5aL(CLogClient& aClient) |
6084 { |
6082 { |
6085 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0963 ")); |
6083 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0963 ")); |
6086 TLogId logId; |
6084 TLogId logId; |
6087 TInt viewIndex; |
6085 TInt viewIndex; |
6088 TLogDatabaseChangeType type; |
6086 TLogDatabaseChangeType type; |
6089 |
6087 |
6090 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
6088 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
6108 |
6106 |
6109 // Get rid of all the events in the log |
6107 // Get rid of all the events in the log |
6110 active->StartL(); |
6108 active->StartL(); |
6111 aClient.ClearLog(now, active->iStatus); |
6109 aClient.ClearLog(now, active->iStatus); |
6112 CActiveScheduler::Start(); |
6110 CActiveScheduler::Start(); |
6113 test(active->iStatus.Int() == KErrNone); |
6111 TEST2(active->iStatus.Int(), KErrNone); |
6114 |
6112 |
6115 // Get config |
6113 // Get config |
6116 TLogConfig config; |
6114 TLogConfig config; |
6117 active->StartL(); |
6115 active->StartL(); |
6118 aClient.GetConfig(config, active->iStatus); |
6116 aClient.GetConfig(config, active->iStatus); |
6119 CActiveScheduler::Start(); |
6117 CActiveScheduler::Start(); |
6120 test(active->iStatus == KErrNone); |
6118 TEST2(active->iStatus.Int(), KErrNone); |
6121 |
6119 |
6122 // Incoming call event |
6120 // Incoming call event |
6123 event->SetEventType(KLogCallEventTypeUid); |
6121 event->SetEventType(KLogCallEventTypeUid); |
6124 TBuf<KLogMaxDirectionLength> buf; |
6122 TBuf<KLogMaxDirectionLength> buf; |
6125 aClient.GetString(buf, R_LOG_DIR_IN); |
6123 aClient.GetString(buf, R_LOG_DIR_IN); |
6131 { |
6129 { |
6132 event->SetContact(count+1); |
6130 event->SetContact(count+1); |
6133 active->StartL(); |
6131 active->StartL(); |
6134 aClient.AddEvent(*event, active->iStatus); |
6132 aClient.AddEvent(*event, active->iStatus); |
6135 CActiveScheduler::Start(); |
6133 CActiveScheduler::Start(); |
6136 test(active->iStatus == KErrNone); |
6134 TEST2(active->iStatus.Int(), KErrNone); |
6137 } |
6135 } |
6138 |
6136 |
6139 // Setup normal event view |
6137 // Setup normal event view |
6140 active->StartL(); |
6138 active->StartL(); |
6141 test(view->SetFilterL(*filter, active->iStatus)); |
6139 TEST(view->SetFilterL(*filter, active->iStatus)); |
6142 CActiveScheduler::Start(); |
6140 CActiveScheduler::Start(); |
6143 test(active->iStatus == KErrNone); |
6141 TEST2(active->iStatus.Int(), KErrNone); |
6144 |
6142 |
6145 CLogViewChangeObserver* changeObs2 = CLogViewChangeObserver::NewLC(); |
6143 CLogViewChangeObserver* changeObs2 = CLogViewChangeObserver::NewLC(); |
6146 changeObs2->StartCollectingChanges(); |
6144 changeObs2->StartCollectingChanges(); |
6147 |
6145 |
6148 CLogViewRecent* recent = CLogViewRecent::NewL(aClient, *changeObs2); |
6146 CLogViewRecent* recent = CLogViewRecent::NewL(aClient, *changeObs2); |
6149 CleanupStack::PushL(recent); |
6147 CleanupStack::PushL(recent); |
6150 |
6148 |
6151 // Check recent view |
6149 // Check recent view |
6152 active->StartL(); |
6150 active->StartL(); |
6153 test(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
6151 TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
6154 CActiveScheduler::Start(); |
6152 CActiveScheduler::Start(); |
6155 test(active->iStatus == KErrNone); |
6153 TEST2(active->iStatus.Int(), KErrNone); |
6156 test(recent->CountL() == config.iMaxRecentLogSize); |
6154 TEST2(recent->CountL(), config.iMaxRecentLogSize); |
6157 |
6155 |
6158 // Clear recent view |
6156 // Clear recent view |
6159 active->StartL(); |
6157 active->StartL(); |
6160 aClient.ClearLog(KLogRecentIncomingCalls, active->iStatus); |
6158 aClient.ClearLog(KLogRecentIncomingCalls, active->iStatus); |
6161 CActiveScheduler::Start(); |
6159 CActiveScheduler::Start(); |
6162 test(active->iStatus == KErrNone); |
6160 TEST2(active->iStatus.Int(), KErrNone); |
6163 |
6161 |
6164 // Check that changes work after a backup |
6162 // Check that changes work after a backup |
6165 StartBackupL(); |
6163 StartBackupL(); |
6166 DelayL(1000000); |
6164 DelayL(1000000); |
6167 TestLogClosedL(); |
6165 TestLogClosedL(); |
6168 EndBackupL(); |
6166 EndBackupL(); |
6169 TestLogOpenL(); |
6167 TestLogOpenL(); |
6170 |
6168 |
6171 count = config.iMaxRecentLogSize; |
6169 count = config.iMaxRecentLogSize; |
6172 test(changeObs2->Changes().Count() == count); |
6170 TEST2(changeObs2->Changes().Count(), count); |
6173 while(count--) |
6171 while(count--) |
6174 { |
6172 { |
6175 type = changeObs2->Changes().At(count, logId, viewIndex); |
6173 type = changeObs2->Changes().At(count, logId, viewIndex); |
6176 test(type == ELogChangeTypeEventDeleted); |
6174 TEST2(type, ELogChangeTypeEventDeleted); |
6177 } |
6175 } |
6178 |
6176 |
6179 // Check recent view |
6177 // Check recent view |
6180 test(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
6178 TEST(!recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
6181 |
6179 |
6182 // Check that changes work after a backup |
6180 // Check that changes work after a backup |
6183 StartBackupL(); |
6181 StartBackupL(); |
6184 DelayL(1000000); |
6182 DelayL(1000000); |
6185 TestLogClosedL(); |
6183 TestLogClosedL(); |
6186 EndBackupL(); |
6184 EndBackupL(); |
6187 TestLogOpenL(); |
6185 TestLogOpenL(); |
6188 |
6186 |
6189 // Check change events |
6187 // Check change events |
6190 User::After(100000); |
6188 User::After(100000); |
6191 test(!changeObs1->HaveChanges()); |
6189 TEST(!changeObs1->HaveChanges()); |
6192 |
6190 |
6193 CleanupStack::PopAndDestroy(7, changeObs1); // changeObs1, changeObs2, view, filter, event, active, recent |
6191 CleanupStack::PopAndDestroy(7, changeObs1); // changeObs1, changeObs2, view, filter, event, active, recent |
6194 } |
6192 } |
6195 |
6193 |
6196 /** |
6194 /** |
6202 @SYMTestExpectedResults Test must not fail |
6200 @SYMTestExpectedResults Test must not fail |
6203 @SYMREQ REQ0000 |
6201 @SYMREQ REQ0000 |
6204 */ |
6202 */ |
6205 LOCAL_C void TestHiddenChangeEvents6aL(CLogClient& aClient) |
6203 LOCAL_C void TestHiddenChangeEvents6aL(CLogClient& aClient) |
6206 { |
6204 { |
6207 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0964 ")); |
6205 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0964 ")); |
6208 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
6206 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
6209 changeObs1->StartCollectingChanges(); |
6207 changeObs1->StartCollectingChanges(); |
6210 |
6208 |
6211 CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs1); |
6209 CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs1); |
6212 CleanupStack::PushL(view); |
6210 CleanupStack::PushL(view); |
6226 |
6224 |
6227 // Get rid of all the events in the log |
6225 // Get rid of all the events in the log |
6228 active->StartL(); |
6226 active->StartL(); |
6229 aClient.ClearLog(now, active->iStatus); |
6227 aClient.ClearLog(now, active->iStatus); |
6230 CActiveScheduler::Start(); |
6228 CActiveScheduler::Start(); |
6231 test(active->iStatus.Int() == KErrNone); |
6229 TEST2(active->iStatus.Int(), KErrNone); |
6232 |
6230 |
6233 // Incoming call event |
6231 // Incoming call event |
6234 event->SetEventType(KLogCallEventTypeUid); |
6232 event->SetEventType(KLogCallEventTypeUid); |
6235 TBuf<KLogMaxDirectionLength> buf; |
6233 TBuf<KLogMaxDirectionLength> buf; |
6236 aClient.GetString(buf, R_LOG_DIR_IN); |
6234 aClient.GetString(buf, R_LOG_DIR_IN); |
6238 |
6236 |
6239 // Add an event |
6237 // Add an event |
6240 active->StartL(); |
6238 active->StartL(); |
6241 aClient.AddEvent(*event, active->iStatus); |
6239 aClient.AddEvent(*event, active->iStatus); |
6242 CActiveScheduler::Start(); |
6240 CActiveScheduler::Start(); |
6243 test(active->iStatus == KErrNone); |
6241 TEST2(active->iStatus.Int(), KErrNone); |
6244 |
6242 |
6245 // Add a duplicate |
6243 // Add a duplicate |
6246 active->StartL(); |
6244 active->StartL(); |
6247 aClient.AddEvent(*event, active->iStatus); |
6245 aClient.AddEvent(*event, active->iStatus); |
6248 CActiveScheduler::Start(); |
6246 CActiveScheduler::Start(); |
6249 test(active->iStatus == KErrNone); |
6247 TEST2(active->iStatus.Int(), KErrNone); |
6250 |
6248 |
6251 // Setup normal event view |
6249 // Setup normal event view |
6252 active->StartL(); |
6250 active->StartL(); |
6253 test(view->SetFilterL(*filter, active->iStatus)); |
6251 TEST(view->SetFilterL(*filter, active->iStatus)); |
6254 CActiveScheduler::Start(); |
6252 CActiveScheduler::Start(); |
6255 test(active->iStatus == KErrNone); |
6253 TEST2(active->iStatus.Int(), KErrNone); |
6256 test(view->CountL() == 2); |
6254 TEST(view->CountL() == 2); |
6257 |
6255 |
6258 CLogViewChangeObserver* changeObs2 = CLogViewChangeObserver::NewLC(); |
6256 CLogViewChangeObserver* changeObs2 = CLogViewChangeObserver::NewLC(); |
6259 changeObs2->StartCollectingChanges(); |
6257 changeObs2->StartCollectingChanges(); |
6260 |
6258 |
6261 CLogViewRecent* recent = CLogViewRecent::NewL(aClient, *changeObs2); |
6259 CLogViewRecent* recent = CLogViewRecent::NewL(aClient, *changeObs2); |
6262 CleanupStack::PushL(recent); |
6260 CleanupStack::PushL(recent); |
6263 |
6261 |
6264 // Check recent view |
6262 // Check recent view |
6265 active->StartL(); |
6263 active->StartL(); |
6266 test(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
6264 TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
6267 CActiveScheduler::Start(); |
6265 CActiveScheduler::Start(); |
6268 test(active->iStatus == KErrNone); |
6266 TEST2(active->iStatus.Int(), KErrNone); |
6269 test(recent->CountL() == 1); |
6267 TEST2(recent->CountL(), 1); |
6270 |
6268 |
6271 CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(aClient); |
6269 CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(aClient); |
6272 CleanupStack::PushL(duplicate); |
6270 CleanupStack::PushL(duplicate); |
6273 |
6271 |
6274 // Check duplicate count |
6272 // Check duplicate count |
6275 active->StartL(); |
6273 active->StartL(); |
6276 test(recent->DuplicatesL(*duplicate, active->iStatus)); |
6274 TEST(recent->DuplicatesL(*duplicate, active->iStatus)); |
6277 CActiveScheduler::Start(); |
6275 CActiveScheduler::Start(); |
6278 test(active->iStatus == KErrNone); |
6276 TEST2(active->iStatus.Int(), KErrNone); |
6279 test(recent->CountL() == 1); |
6277 TEST2(recent->CountL(), 1); |
6280 |
6278 |
6281 // Remove duplicate |
6279 // Remove duplicate |
6282 duplicate->RemoveL(duplicate->Event().Id()); |
6280 duplicate->RemoveL(duplicate->Event().Id()); |
6283 |
6281 |
6284 // Check that changes work after a backup |
6282 // Check that changes work after a backup |
6287 TestLogClosedL(); |
6285 TestLogClosedL(); |
6288 EndBackupL(); |
6286 EndBackupL(); |
6289 TestLogOpenL(); |
6287 TestLogOpenL(); |
6290 |
6288 |
6291 // Check change events |
6289 // Check change events |
6292 test(!changeObs1->HaveChanges()); |
6290 TEST(!changeObs1->HaveChanges()); |
6293 test(!changeObs2->HaveChanges()); |
6291 TEST(!changeObs2->HaveChanges()); |
6294 |
6292 |
6295 // Remove recent |
6293 // Remove recent |
6296 recent->RemoveL(recent->Event().Id()); |
6294 recent->RemoveL(recent->Event().Id()); |
6297 |
6295 |
6298 // Check that changes work after a backup |
6296 // Check that changes work after a backup |
6300 DelayL(1000000); |
6298 DelayL(1000000); |
6301 TestLogClosedL(); |
6299 TestLogClosedL(); |
6302 EndBackupL(); |
6300 EndBackupL(); |
6303 TestLogOpenL(); |
6301 TestLogOpenL(); |
6304 |
6302 |
6305 test(!changeObs1->HaveChanges()); |
6303 TEST(!changeObs1->HaveChanges()); |
6306 test(!changeObs2->HaveChanges()); // No event because we should know we called Remove on ourselves |
6304 TEST(!changeObs2->HaveChanges()); // No event because we should know we called Remove on ourselves |
6307 |
6305 |
6308 CleanupStack::PopAndDestroy(8, changeObs1); // changeObs1, changeObs2, view, filter, event, active, recent, duplicate |
6306 CleanupStack::PopAndDestroy(8, changeObs1); // changeObs1, changeObs2, view, filter, event, active, recent, duplicate |
6309 } |
6307 } |
6310 |
6308 |
6311 /** |
6309 /** |
6317 @SYMTestExpectedResults Test must not fail |
6315 @SYMTestExpectedResults Test must not fail |
6318 @SYMREQ REQ0000 |
6316 @SYMREQ REQ0000 |
6319 */ |
6317 */ |
6320 LOCAL_C void TestHiddenChangeEvents7aL(CLogClient& aClient) |
6318 LOCAL_C void TestHiddenChangeEvents7aL(CLogClient& aClient) |
6321 { |
6319 { |
6322 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0965 ")); |
6320 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0965 ")); |
6323 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
6321 CLogViewChangeObserver* changeObs1 = CLogViewChangeObserver::NewLC(); |
6324 changeObs1->StartCollectingChanges(); |
6322 changeObs1->StartCollectingChanges(); |
6325 |
6323 |
6326 CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs1); |
6324 CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs1); |
6327 CleanupStack::PushL(view); |
6325 CleanupStack::PushL(view); |
6341 |
6339 |
6342 // Get rid of all the events in the log |
6340 // Get rid of all the events in the log |
6343 active->StartL(); |
6341 active->StartL(); |
6344 aClient.ClearLog(now, active->iStatus); |
6342 aClient.ClearLog(now, active->iStatus); |
6345 CActiveScheduler::Start(); |
6343 CActiveScheduler::Start(); |
6346 test(active->iStatus.Int() == KErrNone); |
6344 TEST2(active->iStatus.Int(), KErrNone); |
6347 |
6345 |
6348 // Incoming call event |
6346 // Incoming call event |
6349 event->SetEventType(KLogCallEventTypeUid); |
6347 event->SetEventType(KLogCallEventTypeUid); |
6350 TBuf<KLogMaxDirectionLength> buf; |
6348 TBuf<KLogMaxDirectionLength> buf; |
6351 aClient.GetString(buf, R_LOG_DIR_IN); |
6349 aClient.GetString(buf, R_LOG_DIR_IN); |
6353 |
6351 |
6354 // Add an event |
6352 // Add an event |
6355 active->StartL(); |
6353 active->StartL(); |
6356 aClient.AddEvent(*event, active->iStatus); |
6354 aClient.AddEvent(*event, active->iStatus); |
6357 CActiveScheduler::Start(); |
6355 CActiveScheduler::Start(); |
6358 test(active->iStatus == KErrNone); |
6356 TEST2(active->iStatus.Int(), KErrNone); |
6359 |
6357 |
6360 // Add a duplicate |
6358 // Add a duplicate |
6361 active->StartL(); |
6359 active->StartL(); |
6362 aClient.AddEvent(*event, active->iStatus); |
6360 aClient.AddEvent(*event, active->iStatus); |
6363 CActiveScheduler::Start(); |
6361 CActiveScheduler::Start(); |
6364 test(active->iStatus == KErrNone); |
6362 TEST2(active->iStatus.Int(), KErrNone); |
6365 |
6363 |
6366 // Setup normal event view |
6364 // Setup normal event view |
6367 active->StartL(); |
6365 active->StartL(); |
6368 test(view->SetFilterL(*filter, active->iStatus)); |
6366 TEST(view->SetFilterL(*filter, active->iStatus)); |
6369 CActiveScheduler::Start(); |
6367 CActiveScheduler::Start(); |
6370 test(active->iStatus == KErrNone); |
6368 TEST2(active->iStatus.Int(), KErrNone); |
6371 test(view->CountL() == 2); |
6369 TEST2(view->CountL(), 2); |
6372 |
6370 |
6373 CLogViewChangeObserver* changeObs2 = CLogViewChangeObserver::NewLC(); |
6371 CLogViewChangeObserver* changeObs2 = CLogViewChangeObserver::NewLC(); |
6374 changeObs2->StartCollectingChanges(); |
6372 changeObs2->StartCollectingChanges(); |
6375 |
6373 |
6376 CLogViewRecent* recent = CLogViewRecent::NewL(aClient, *changeObs2); |
6374 CLogViewRecent* recent = CLogViewRecent::NewL(aClient, *changeObs2); |
6377 CleanupStack::PushL(recent); |
6375 CleanupStack::PushL(recent); |
6378 |
6376 |
6379 // Check recent view |
6377 // Check recent view |
6380 active->StartL(); |
6378 active->StartL(); |
6381 test(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
6379 TEST(recent->SetRecentListL(KLogRecentIncomingCalls, active->iStatus)); |
6382 CActiveScheduler::Start(); |
6380 CActiveScheduler::Start(); |
6383 test(active->iStatus == KErrNone); |
6381 TEST2(active->iStatus.Int(), KErrNone); |
6384 test(recent->CountL() == 1); |
6382 TEST2(recent->CountL(), 1); |
6385 |
6383 |
6386 CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(aClient); |
6384 CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(aClient); |
6387 CleanupStack::PushL(duplicate); |
6385 CleanupStack::PushL(duplicate); |
6388 |
6386 |
6389 // Check duplicate count |
6387 // Check duplicate count |
6390 active->StartL(); |
6388 active->StartL(); |
6391 test(recent->DuplicatesL(*duplicate, active->iStatus)); |
6389 TEST(recent->DuplicatesL(*duplicate, active->iStatus)); |
6392 CActiveScheduler::Start(); |
6390 CActiveScheduler::Start(); |
6393 test(active->iStatus == KErrNone); |
6391 TEST2(active->iStatus.Int(), KErrNone); |
6394 test(recent->CountL() == 1); |
6392 TEST2(recent->CountL(), 1); |
6395 |
6393 |
6396 // Remove duplicate |
6394 // Remove duplicate |
6397 recent->ClearDuplicatesL(); |
6395 recent->ClearDuplicatesL(); |
6398 |
6396 |
6399 // Check that changes work after a backup |
6397 // Check that changes work after a backup |
6402 TestLogClosedL(); |
6400 TestLogClosedL(); |
6403 EndBackupL(); |
6401 EndBackupL(); |
6404 TestLogOpenL(); |
6402 TestLogOpenL(); |
6405 |
6403 |
6406 // Check change events |
6404 // Check change events |
6407 test(!changeObs1->HaveChanges()); |
6405 TEST(!changeObs1->HaveChanges()); |
6408 test(!changeObs2->HaveChanges()); |
6406 TEST(!changeObs2->HaveChanges()); |
6409 |
6407 |
6410 CleanupStack::PopAndDestroy(8, changeObs1); // changeObs1, changeObs2, view, filter, event, active, recent, duplicate |
6408 CleanupStack::PopAndDestroy(8, changeObs1); // changeObs1, changeObs2, view, filter, event, active, recent, duplicate |
6411 } |
6409 } |
6412 |
6410 |
6413 /** |
6411 /** |
6420 @SYMTestExpectedResults Test must not fail |
6418 @SYMTestExpectedResults Test must not fail |
6421 @SYMDEF DEF108741 |
6419 @SYMDEF DEF108741 |
6422 */ |
6420 */ |
6423 LOCAL_C void DEF108741L(CLogClient& aClient) |
6421 LOCAL_C void DEF108741L(CLogClient& aClient) |
6424 { |
6422 { |
6425 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-3511 ")); |
6423 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-3511 ")); |
6426 // Perform clean up |
6424 // Perform clean up |
6427 TestUtils::DeleteDatabaseL(); |
6425 TestUtils::DeleteDatabaseL(); |
6428 |
6426 |
6429 // Create a new event |
6427 // Create a new event |
6430 CLogEvent* event = CLogEvent::NewL(); |
6428 CLogEvent* event = CLogEvent::NewL(); |
6488 @SYMTestExpectedResults Test must not fail |
6486 @SYMTestExpectedResults Test must not fail |
6489 @SYMDEF INC108225 |
6487 @SYMDEF INC108225 |
6490 */ |
6488 */ |
6491 LOCAL_C void TestNumberFieldINC108225L(CLogClient& aClient) |
6489 LOCAL_C void TestNumberFieldINC108225L(CLogClient& aClient) |
6492 { |
6490 { |
6493 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-3716 ")); |
6491 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-3716 ")); |
6494 CLogEvent* event = CLogEvent::NewL(); |
6492 CLogEvent* event = CLogEvent::NewL(); |
6495 CleanupStack::PushL(event); |
6493 CleanupStack::PushL(event); |
6496 |
6494 |
6497 CLogEvent* event1 = CLogEvent::NewL(); |
6495 CLogEvent* event1 = CLogEvent::NewL(); |
6498 CleanupStack::PushL(event1); |
6496 CleanupStack::PushL(event1); |
6640 @SYMTestExpectedResults Test must not fail |
6638 @SYMTestExpectedResults Test must not fail |
6641 @SYMDEF INC108225 |
6639 @SYMDEF INC108225 |
6642 */ |
6640 */ |
6643 LOCAL_C void TestOtherFieldsINC108225L(CLogClient& aClient) |
6641 LOCAL_C void TestOtherFieldsINC108225L(CLogClient& aClient) |
6644 { |
6642 { |
6645 test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-3755 ")); |
6643 TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-3755 ")); |
6646 CLogEvent* event = CLogEvent::NewL(); |
6644 CLogEvent* event = CLogEvent::NewL(); |
6647 CleanupStack::PushL(event); |
6645 CleanupStack::PushL(event); |
6648 |
6646 |
6649 CTestActive* active = new(ELeave)CTestActive(); |
6647 CTestActive* active = new(ELeave)CTestActive(); |
6650 CleanupStack::PushL(active); |
6648 CleanupStack::PushL(active); |
6787 CleanupStack::PopAndDestroy(4); |
6785 CleanupStack::PopAndDestroy(4); |
6788 } |
6786 } |
6789 |
6787 |
6790 void doTestsL() |
6788 void doTestsL() |
6791 { |
6789 { |
6792 TestUtils::Initialize(_L("T_LOGVIEW2")); |
6790 TestUtils::Initialize(_L("t_logview2")); |
6793 TestUtils::DeleteDatabaseL(); |
6791 TestUtils::DeleteDatabaseL(); |
6794 |
6792 |
6795 CLogClient* client = CLogClient::NewL(theFs); |
6793 CLogClient* client = CLogClient::NewL(theFs); |
6796 CleanupStack::PushL(client); |
6794 CleanupStack::PushL(client); |
6797 |
6795 |
6798 CLogChangeNotifier* notifier = CLogChangeNotifier::NewL(); |
6796 CLogChangeNotifier* notifier = CLogChangeNotifier::NewL(); |
6799 CleanupStack::PushL(notifier); |
6797 CleanupStack::PushL(notifier); |
6800 |
6798 |
6801 test.Start(_L("Event View With Filter List")); |
6799 TheTest.Start(_L("Event View With Filter List")); |
6802 TestEventViewWithFilterListL(*client); |
6800 TestEventViewWithFilterListL(*client); |
6803 theLog.Write(_L8("Test 1 OK\n")); |
6801 theLog.Write(_L8("Test 1 OK\n")); |
6804 |
6802 |
6805 test.Next(_L("View change observer")); |
6803 TheTest.Next(_L("View change observer")); |
6806 TestViewChangeEventsL(*client); |
6804 TestViewChangeEventsL(*client); |
6807 theLog.Write(_L8("Test 2 OK\n")); |
6805 theLog.Write(_L8("Test 2 OK\n")); |
6808 |
6806 |
6809 test.Next(_L("Recent View With Filter")); |
6807 TheTest.Next(_L("Recent View With Filter")); |
6810 TestRecentViewWithFilterL(*client); |
6808 TestRecentViewWithFilterL(*client); |
6811 theLog.Write(_L8("Test 3 OK\n")); |
6809 theLog.Write(_L8("Test 3 OK\n")); |
6812 |
6810 |
6813 test.Next(_L("Recent View With Filter List")); |
6811 TheTest.Next(_L("Recent View With Filter List")); |
6814 TestRecentViewWithFilterListL(*client); |
6812 TestRecentViewWithFilterListL(*client); |
6815 theLog.Write(_L8("Test 4 OK\n")); |
6813 theLog.Write(_L8("Test 4 OK\n")); |
6816 |
6814 |
6817 test.Next(_L("Duplicate View With Filter")); |
6815 TheTest.Next(_L("Duplicate View With Filter")); |
6818 TestDuplicateViewWithFilterL(*client); |
6816 TestDuplicateViewWithFilterL(*client); |
6819 theLog.Write(_L8("Test 5 OK\n")); |
6817 theLog.Write(_L8("Test 5 OK\n")); |
6820 |
6818 |
6821 test.Next(_L("Duplicate View With Filter List")); |
6819 TheTest.Next(_L("Duplicate View With Filter List")); |
6822 TestDuplicateViewWithFilterListL(*client); |
6820 TestDuplicateViewWithFilterListL(*client); |
6823 theLog.Write(_L8("Test 6 OK\n")); |
6821 theLog.Write(_L8("Test 6 OK\n")); |
6824 |
6822 |
6825 test.Next(_L("Querying Event View For Null Fields")); |
6823 TheTest.Next(_L("Querying Event View For Null Fields")); |
6826 TestEventViewForNullFieldsL(*client); |
6824 TestEventViewForNullFieldsL(*client); |
6827 theLog.Write(_L8("Test 7 OK\n")); |
6825 theLog.Write(_L8("Test 7 OK\n")); |
6828 |
6826 |
6829 test.Next(_L("Querying Recent View For Null Fields")); |
6827 TheTest.Next(_L("Querying Recent View For Null Fields")); |
6830 TestRecentViewForNullFieldsL(*client); |
6828 TestRecentViewForNullFieldsL(*client); |
6831 theLog.Write(_L8("Test 8 OK\n")); |
6829 theLog.Write(_L8("Test 8 OK\n")); |
6832 |
6830 |
6833 test.Next(_L("Querying Duplicate View For Null Fields")); |
6831 TheTest.Next(_L("Querying Duplicate View For Null Fields")); |
6834 TestDuplicateViewForNullFieldsL(*client); |
6832 TestDuplicateViewForNullFieldsL(*client); |
6835 theLog.Write(_L8("Test 9 OK\n")); |
6833 theLog.Write(_L8("Test 9 OK\n")); |
6836 |
6834 |
6837 test.Next(_L("Querying Event View For Flags")); |
6835 TheTest.Next(_L("Querying Event View For Flags")); |
6838 TestEventViewForFlagsL(*client); |
6836 TestEventViewForFlagsL(*client); |
6839 theLog.Write(_L8("Test 10 OK\n")); |
6837 theLog.Write(_L8("Test 10 OK\n")); |
6840 |
6838 |
6841 test.Next(_L("Querying Recent View For Flags")); |
6839 TheTest.Next(_L("Querying Recent View For Flags")); |
6842 TestRecentViewForFlagsL(*client); |
6840 TestRecentViewForFlagsL(*client); |
6843 theLog.Write(_L8("Test 11 OK\n")); |
6841 theLog.Write(_L8("Test 11 OK\n")); |
6844 |
6842 |
6845 test.Next(_L("Querying Duplicate View For Flags")); |
6843 TheTest.Next(_L("Querying Duplicate View For Flags")); |
6846 TestDuplicateViewForFlagsL(*client); |
6844 TestDuplicateViewForFlagsL(*client); |
6847 theLog.Write(_L8("Test 12 OK\n")); |
6845 theLog.Write(_L8("Test 12 OK\n")); |
6848 |
6846 |
6849 test.Next(_L("Removing Recent Events")); |
6847 TheTest.Next(_L("Removing Recent Events")); |
6850 TestRemovingRecentEventsL(*client); |
6848 TestRemovingRecentEventsL(*client); |
6851 theLog.Write(_L8("Test 13 OK\n")); |
6849 theLog.Write(_L8("Test 13 OK\n")); |
6852 |
6850 |
6853 test.Next(_L("Removing Duplicate Events")); |
6851 TheTest.Next(_L("Removing Duplicate Events")); |
6854 TestRemovingDuplicateEventsL(*client); |
6852 TestRemovingDuplicateEventsL(*client); |
6855 theLog.Write(_L8("Test 14 OK\n")); |
6853 theLog.Write(_L8("Test 14 OK\n")); |
6856 |
6854 |
6857 test.Next(_L("Multiple Views")); |
6855 TheTest.Next(_L("Multiple Views")); |
6858 TestMultipleViews1L(*client); |
6856 TestMultipleViews1L(*client); |
6859 TestMultipleViews2L(*client); |
6857 TestMultipleViews2L(*client); |
6860 theLog.Write(_L8("Test 15 OK\n")); |
6858 theLog.Write(_L8("Test 15 OK\n")); |
6861 |
6859 |
6862 test.Next(_L("Test _ALT Events In Recent List")); |
6860 TheTest.Next(_L("Test _ALT Events In Recent List")); |
6863 TestAltEventsInRecentListL(*client); |
6861 TestAltEventsInRecentListL(*client); |
6864 theLog.Write(_L8("Test 16 OK\n")); |
6862 theLog.Write(_L8("Test 16 OK\n")); |
6865 |
6863 |
6866 test.Next(_L("Test filtering Events by time")); |
6864 TheTest.Next(_L("Test filtering Events by time")); |
6867 // This TEST sets system's 'Home Time' |
6865 // This TEST sets system's 'Home Time' |
6868 TestFilterByTimeL(*client); |
6866 TestFilterByTimeL(*client); |
6869 theLog.Write(_L8("Test 17 OK\n")); |
6867 theLog.Write(_L8("Test 17 OK\n")); |
6870 |
6868 |
6871 test.Next(_L("Test hidden change events")); |
6869 TheTest.Next(_L("Test hidden change events")); |
6872 TestUtils::DeleteDatabaseL(); |
6870 TestUtils::DeleteDatabaseL(); |
6873 TestHiddenChangeEvents1L(*client); |
6871 TestHiddenChangeEvents1L(*client); |
6874 TestHiddenChangeEvents1aL(*client); |
6872 TestHiddenChangeEvents1aL(*client); |
6875 TestHiddenChangeEvents2L(*client); |
6873 TestHiddenChangeEvents2L(*client); |
6876 TestHiddenChangeEvents2aL(*client); |
6874 TestHiddenChangeEvents2aL(*client); |
6884 TestHiddenChangeEvents6aL(*client); |
6882 TestHiddenChangeEvents6aL(*client); |
6885 TestHiddenChangeEvents7L(*client); |
6883 TestHiddenChangeEvents7L(*client); |
6886 TestHiddenChangeEvents7aL(*client); |
6884 TestHiddenChangeEvents7aL(*client); |
6887 theLog.Write(_L8("Test 18 OK\n")); |
6885 theLog.Write(_L8("Test 18 OK\n")); |
6888 |
6886 |
6889 test.Next(_L("Changing events and recent views")); |
6887 TheTest.Next(_L("Changing events and recent views")); |
6890 TestChangeEventRecentView1L(*client); |
6888 TestChangeEventRecentView1L(*client); |
6891 TestChangeEventRecentView2L(*client); |
6889 TestChangeEventRecentView2L(*client); |
6892 TestChangeEventRecentViewAndPurgeL(*client); |
6890 TestChangeEventRecentViewAndPurgeL(*client); |
6893 TestChangeEventRecentViewRemoveL(*client); |
6891 TestChangeEventRecentViewRemoveL(*client); |
6894 theLog.Write(_L8("Test 19 OK\n")); |
6892 theLog.Write(_L8("Test 19 OK\n")); |
6895 |
6893 |
6896 test.Next(_L("Test for DEF066296")); |
6894 TheTest.Next(_L("Test for DEF066296")); |
6897 DEF066296L(*client); |
6895 DEF066296L(*client); |
6898 test.Next(_L("Test for DEF087459")); |
6896 TheTest.Next(_L("Test for DEF087459")); |
6899 DEF087459L(*client); |
6897 DEF087459L(*client); |
6900 theLog.Write(_L8("Test 20 OK\n")); |
6898 theLog.Write(_L8("Test 20 OK\n")); |
6901 |
6899 |
6902 test.Next(_L("Event View With Filter List containing StartTime and EndTime")); |
6900 TheTest.Next(_L("Event View With Filter List containing StartTime and EndTime")); |
6903 TestEventViewWithTimestampsInFilterListL(*client); |
6901 TestEventViewWithTimestampsInFilterListL(*client); |
6904 theLog.Write(_L8("Test 21 OK\n")); |
6902 theLog.Write(_L8("Test 21 OK\n")); |
6905 |
6903 |
6906 test.Next(_L("Test for DEF108741 - View change observer, error condition")); |
6904 TheTest.Next(_L("Test for DEF108741 - View change observer, error condition")); |
6907 DEF108741L(*client); |
6905 DEF108741L(*client); |
6908 theLog.Write(_L8("Test 22 OK\n")); |
6906 theLog.Write(_L8("Test 22 OK\n")); |
6909 |
6907 |
6910 test.Next(_L("Test Defect INC108225: Call history check for the CS & PS(VOIP) calls ")); |
6908 TheTest.Next(_L("Test Defect INC108225: Call history check for the CS & PS(VOIP) calls ")); |
6911 TestNumberFieldINC108225L(*client); |
6909 TestNumberFieldINC108225L(*client); |
6912 TestOtherFieldsINC108225L(*client); |
6910 TestOtherFieldsINC108225L(*client); |
6913 theLog.Write(_L8("Test 23 OK\n")); |
6911 theLog.Write(_L8("Test 23 OK\n")); |
6914 |
6912 |
6915 CleanupStack::PopAndDestroy(2); // client, notifier |
6913 CleanupStack::PopAndDestroy(2); // client, notifier |