diff -r 000000000000 -r 08ec8eefde2f loggingservices/eventlogger/test/src/t_logview1.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/loggingservices/eventlogger/test/src/t_logview1.cpp Fri Jan 22 11:06:30 2010 +0200 @@ -0,0 +1,6053 @@ +// Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#include +#include +#include + +#include "TEST.H" +#include + +#undef test //there is a "test" macro which hides "RTest test" declaration. + +#define UNUSED_VAR(a) a = a + +RTest test(_L("Log View Test Harness Number 1")); + +const TInt KTestLogNumberCharsToMatch = 9; // should be the same as KLogNumberCharsToMatch defined in LogServ\src\LOGFILTQ.CPP +const TInt KTestEventNum = 10; +const TUid KTestEventUid = {0x10005393}; +const TLogDurationType KTestDurationType = 0x12; +const TLogContactItemId KTestContact = 0x1234; +_LIT(KTestEventDesc, "Test Event"); +_LIT(KTestRemoteParty, "Test Remote Party"); +_LIT(KTestDirection, "Test Direction"); +_LIT(KTestStatus, "Test Status"); +_LIT(KTestNumber, "Test Number"); +_LIT(KThreadSemaphoreName, "T_VIEW1_TEST_CODE"); + + +TBool TheMatchingIsEnabled = EFalse; + +#define TEST_LOG_UID KTestEventUid + +//View's DoCancel() test +void DoViewCancelTestL(CTestActive& aActive, CLogViewEvent& aView) + { + //Call FirstL() and cancel the operation + aActive.StartL(); + (void)aView.FirstL(aActive.iStatus); + aView.Cancel(); + TEST(!aView.IsActive()); + CActiveScheduler::Start(); + TEST2(aActive.iStatus.Int(), KErrCancel); + + //Call FirstL(). View cursor positioned on the first record. + aActive.StartL(); + (void)aView.FirstL(aActive.iStatus); + CActiveScheduler::Start(); + TEST2(aActive.iStatus.Int(), KErrNone); + + //Call NextL() and cancel the operation + aActive.StartL(); + (void)aView.NextL(aActive.iStatus); + aView.Cancel(); + TEST(!aView.IsActive()); + CActiveScheduler::Start(); + TEST2(aActive.iStatus.Int(), KErrCancel); + + //Call LastL() and cancel the operation + aActive.StartL(); + (void)aView.LastL(aActive.iStatus); + aView.Cancel(); + TEST(!aView.IsActive()); + CActiveScheduler::Start(); + TEST2(aActive.iStatus.Int(), KErrCancel); + + //Call LastL(). View cursor positioned on the last record. + aActive.StartL(); + (void)aView.LastL(aActive.iStatus); + CActiveScheduler::Start(); + TEST2(aActive.iStatus.Int(), KErrNone); + + //Call PreviousL() and cancel the operation + aActive.StartL(); + (void)aView.PreviousL(aActive.iStatus); + aView.Cancel(); + TEST(!aView.IsActive()); + CActiveScheduler::Start(); + TEST2(aActive.iStatus.Int(), KErrCancel); + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0851 +@SYMTestCaseDesc Tests for adding event types to the log +@SYMTestPriority High +@SYMTestActions Tests for adding events,check event count,clearing all the events +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestEventViewL(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0851 ")); + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + event->SetEventType(KLogCallEventTypeUid); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + TInt count; + for(count = 0; count < KTestEventNum; count++) + { + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + + CLogViewChangeObserver* changeObs = CLogViewChangeObserver::NewLC(); + changeObs->SetActive(); + + CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs); + CleanupStack::PushL(view); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + count = view->CountL(); + TEST2(count, 0); + TBool res = view->SetFilterL(*filter, active->iStatus); + TEST(res); + + // Move forward + count = KTestEventNum; + do { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + const TInt viewCount = view->CountL(); + TEST2(viewCount, KTestEventNum); + const TLogId eventId = view->Event().Id(); + TLogId id = --count; + TEST2(eventId, id); + } + while(view->NextL(active->iStatus)); + TEST2(count, 0); + + // Move back + while(view->PreviousL(active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST2(view->CountL(), KTestEventNum); + TLogId id = ++count; + TEST2(view->Event().Id(), id); + } + TEST(count == KTestEventNum - 1); + + active->StartL(); + res = view->FirstL(active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + active->StartL(); + res = view->LastL(active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Nothing has changed in the view yet + TEST(!changeObs->HaveChanges()); + + DoViewCancelTestL(*active, *view); + + TTime now; + now.UniversalTime(); + now+=(TTimeIntervalDays) 1; + + // Clear all the events + active->StartL(); + aClient.ClearLog(now, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + res = view->SetFilterL(*filter, active->iStatus); + TEST(!res); + TEST2(view->CountL(), 0); + res = view->FirstL(active->iStatus); + TEST(!res); + res = view->LastL(active->iStatus); + TEST(!res); + res = view->NextL(active->iStatus); + TEST(!res); + res = view->PreviousL(active->iStatus); + TEST(!res); + + CleanupStack::PopAndDestroy(5, event); // filter, view, changeObs, active, event + + CLogSchedulerTimer* timer = CLogSchedulerTimer::NewLC(); + timer->Wait(10 * 1000000); + CleanupStack::PopAndDestroy(timer); + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0852 +@SYMTestCaseDesc Tests for adding event types to the filter list +@SYMTestPriority High +@SYMTestActions Set the configuration data of event type.Add the event type to the filter and + compare the configuration data of event type and from filter view. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestViewFilterL(CLogClient& aClient, CLogFilter& aFilter) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0852 ")); + CLogViewEvent* view = CLogViewEvent::NewL(aClient); + CleanupStack::PushL(view); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + event->SetEventType(KTestEventUid); + event->SetRemoteParty(aFilter.RemoteParty()); + event->SetDirection(aFilter.Direction()); + event->SetDurationType(aFilter.DurationType()); + event->SetStatus(aFilter.Status()); + event->SetContact(aFilter.Contact()); + event->SetNumber(aFilter.Number()); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + if (view->SetFilterL(aFilter, active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + + TInt total = view->CountL(); + + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TBool res = view->SetFilterL(aFilter, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST(view->CountL() == total + 1); + + TEST(event->EventType() == KTestEventUid); + TEST(event->RemoteParty() == aFilter.RemoteParty()); + TEST(event->Direction() == aFilter.Direction()); + TEST(event->DurationType() == aFilter.DurationType()); + TEST(event->Status() == aFilter.Status()); + TEST(event->Contact() == aFilter.Contact()); + TEST(event->Number() == aFilter.Number()); + + TTime now; + now.UniversalTime(); + + TInt count = 1; + + while(view->NextL(active->iStatus)) + { + count++; + TEST(count <= total + 1); + + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST(now >= event->Time()); + + if (aFilter.EventType() != KNullUid) + TEST(event->EventType() == aFilter.EventType()); + + if (aFilter.RemoteParty().Length() > 0) + TEST(event->RemoteParty() == aFilter.RemoteParty()); + + if (aFilter.Direction().Length() > 0) + TEST(event->Direction() == aFilter.Direction()); + + if (aFilter.DurationType() != KLogNullDurationType) + TEST(event->DurationType() == aFilter.DurationType()); + + if (aFilter.Status().Length() > 0) + TEST(event->Status() == aFilter.Status()); + + if (aFilter.Contact() > KLogNullContactId) + TEST(event->Contact() == aFilter.Contact()); + + if (aFilter.Number().Length() > 0) + TEST(event->Number() == aFilter.Number()); + } + + TEST(count == total + 1); + + CleanupStack::PopAndDestroy(3); // active, event, view; + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0853 +@SYMTestCaseDesc Tests for filtering the log view +@SYMTestPriority High +@SYMTestActions Tests for the log view filter,which is set with different configuration data +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestEventViewFilter1L(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0853 ")); + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + // Create a test event type + CLogEventType* type = CLogEventType::NewL(); + CleanupStack::PushL(type); + + type->SetUid(KTestEventUid); + type->SetDescription(KTestEventDesc); + type->SetLoggingEnabled(ETrue); + + // Register the event type + active->StartL(); + aClient.AddEventType(*type, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + CleanupStack::PopAndDestroy(); // type + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + filter->SetEventType(KTestEventUid); + TestViewFilterL(aClient, *filter); + + filter->SetEventType(KTestEventUid); + filter->SetRemoteParty(KTestRemoteParty); + TestViewFilterL(aClient, *filter); + + filter->SetEventType(KTestEventUid); + filter->SetRemoteParty(KTestRemoteParty); + filter->SetDirection(KTestDirection); + TestViewFilterL(aClient, *filter); + + filter->SetEventType(KTestEventUid); + filter->SetRemoteParty(KTestRemoteParty); + filter->SetDirection(KTestDirection); + filter->SetDurationType(KTestDurationType); + TestViewFilterL(aClient, *filter); + + filter->SetEventType(KTestEventUid); + filter->SetRemoteParty(KTestRemoteParty); + filter->SetDirection(KTestDirection); + filter->SetDurationType(KTestDurationType); + filter->SetStatus(KTestStatus); + TestViewFilterL(aClient, *filter); + + filter->SetEventType(KTestEventUid); + filter->SetRemoteParty(KTestRemoteParty); + filter->SetDirection(KTestDirection); + filter->SetDurationType(KTestDurationType); + filter->SetStatus(KTestStatus); + filter->SetContact(KTestContact); + TestViewFilterL(aClient, *filter); + + filter->SetEventType(KTestEventUid); + filter->SetRemoteParty(KTestRemoteParty); + filter->SetDirection(KTestDirection); + filter->SetDurationType(KTestDurationType); + filter->SetStatus(KTestStatus); + filter->SetContact(KTestContact); + filter->SetNumber(KTestNumber); + TestViewFilterL(aClient, *filter); + + CleanupStack::PopAndDestroy(); // filter + + filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + filter->SetRemoteParty(KTestRemoteParty); + TestViewFilterL(aClient, *filter); + + filter->SetRemoteParty(KTestRemoteParty); + filter->SetDirection(KTestDirection); + TestViewFilterL(aClient, *filter); + + filter->SetRemoteParty(KTestRemoteParty); + filter->SetDirection(KTestDirection); + filter->SetDurationType(KTestDurationType); + TestViewFilterL(aClient, *filter); + + filter->SetRemoteParty(KTestRemoteParty); + filter->SetDirection(KTestDirection); + filter->SetDurationType(KTestDurationType); + filter->SetStatus(KTestStatus); + TestViewFilterL(aClient, *filter); + + filter->SetRemoteParty(KTestRemoteParty); + filter->SetDirection(KTestDirection); + filter->SetDurationType(KTestDurationType); + filter->SetStatus(KTestStatus); + filter->SetContact(KTestContact); + TestViewFilterL(aClient, *filter); + + filter->SetRemoteParty(KTestRemoteParty); + filter->SetDirection(KTestDirection); + filter->SetDurationType(KTestDurationType); + filter->SetStatus(KTestStatus); + filter->SetContact(KTestContact); + filter->SetNumber(KTestNumber); + TestViewFilterL(aClient, *filter); + + CleanupStack::PopAndDestroy(); // filter + + filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + filter->SetDirection(KTestDirection); + TestViewFilterL(aClient, *filter); + + filter->SetDirection(KTestDirection); + filter->SetDurationType(KTestDurationType); + TestViewFilterL(aClient, *filter); + + filter->SetDirection(KTestDirection); + filter->SetDurationType(KTestDurationType); + filter->SetStatus(KTestStatus); + TestViewFilterL(aClient, *filter); + + filter->SetDirection(KTestDirection); + filter->SetDurationType(KTestDurationType); + filter->SetStatus(KTestStatus); + filter->SetContact(KTestContact); + TestViewFilterL(aClient, *filter); + + filter->SetDirection(KTestDirection); + filter->SetDurationType(KTestDurationType); + filter->SetStatus(KTestStatus); + filter->SetContact(KTestContact); + filter->SetNumber(KTestNumber); + TestViewFilterL(aClient, *filter); + + CleanupStack::PopAndDestroy(); // filter + + filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + filter->SetDurationType(KTestDurationType); + TestViewFilterL(aClient, *filter); + + filter->SetDurationType(KTestDurationType); + filter->SetStatus(KTestStatus); + TestViewFilterL(aClient, *filter); + + filter->SetDurationType(KTestDurationType); + filter->SetStatus(KTestStatus); + filter->SetContact(KTestContact); + TestViewFilterL(aClient, *filter); + + filter->SetDurationType(KTestDurationType); + filter->SetStatus(KTestStatus); + filter->SetContact(KTestContact); + filter->SetNumber(KTestNumber); + TestViewFilterL(aClient, *filter); + + CleanupStack::PopAndDestroy(); // filter + + filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + filter->SetStatus(KTestStatus); + TestViewFilterL(aClient, *filter); + + filter->SetStatus(KTestStatus); + filter->SetContact(KTestContact); + TestViewFilterL(aClient, *filter); + + filter->SetStatus(KTestStatus); + filter->SetContact(KTestContact); + filter->SetNumber(KTestNumber); + TestViewFilterL(aClient, *filter); + + CleanupStack::PopAndDestroy(); // filter + + filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + filter->SetContact(KTestContact); + TestViewFilterL(aClient, *filter); + + filter->SetContact(KTestContact); + filter->SetNumber(KTestNumber); + TestViewFilterL(aClient, *filter); + + CleanupStack::PopAndDestroy(); // filter + + filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + filter->SetNumber(KTestNumber); + TestViewFilterL(aClient, *filter); + + CleanupStack::PopAndDestroy(2); // filter, active + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0854 +@SYMTestCaseDesc Tests for filtering list event types +@SYMTestPriority High +@SYMTestActions Get the count of all event types,call,data,fax events. + Add some event types to the filter,test for the new count + Check for non existing event type. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestEventViewFilter2L(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0854 ")); + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogViewEvent* view = CLogViewEvent::NewL(aClient); + CleanupStack::PushL(view); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + // Get total count of all events + if (view->SetFilterL(*filter, active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + TInt total = view->CountL(); + + filter->SetEventType(KLogCallEventTypeUid); + + // Get number of call events + if (view->SetFilterL(*filter, active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + TInt calls = view->CountL(); + + filter->SetEventType(KLogDataEventTypeUid); + + // Get number of data events + if (view->SetFilterL(*filter, active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + TInt data = view->CountL(); + + filter->SetEventType(KLogFaxEventTypeUid); + + // Get number of fax events + if (view->SetFilterL(*filter, active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + TInt fax = view->CountL(); + + filter->SetEventType(KLogLbsSelfLocateEventTypeUid); + + // Get number of Lbs self locate events + if (view->SetFilterL(*filter, active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + TInt lbsSelf = view->CountL(); + + filter->SetEventType(KLogLbsExternalLocateEventTypeUid); + + // Get number of Lbs self locate events + if (view->SetFilterL(*filter, active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + TInt lbsExternal = view->CountL(); + + filter->SetEventType(KLogLbsTransmitLocationEventTypeUid); + + // Get number of Lbs transmit location events + if (view->SetFilterL(*filter, active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + TInt lbsXmitLoc = view->CountL(); + + filter->SetEventType(KLogLbsNetworkLocateEventTypeUid); + + // Get number of Lbs network locate events + if (view->SetFilterL(*filter, active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + TInt lbsNetwork = view->CountL(); + + filter->SetEventType(KLogLbsAssistanceDataEventTypeUid); + + // Get number of Lbs assistance data events + if (view->SetFilterL(*filter, active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + TInt lbsAssistance = view->CountL(); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + event->SetEventType(KLogCallEventTypeUid); + + // Add two call events + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + event->SetEventType(KLogDataEventTypeUid); + + // Add two data events + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Filter all event types + filter->SetEventType(KNullUid); + + // Get view of all events + active->StartL(); + TBool res = view->SetFilterL(*filter, active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Check the count is correct + TEST(view->CountL() == total + 4); + + filter->SetEventType(KLogCallEventTypeUid); + + // Get view of call events + active->StartL(); + res = view->SetFilterL(*filter, active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST(view->CountL() == calls + 2); + + filter->SetEventType(KLogDataEventTypeUid); + + // Get view of data events + active->StartL(); + res = view->SetFilterL(*filter, active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST(view->CountL() == data + 2); + + filter->SetEventType(KLogFaxEventTypeUid); + + // Get view of fax events + if (view->SetFilterL(*filter, active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + TEST2(view->CountL(), fax); + + filter->SetEventType(KLogLbsSelfLocateEventTypeUid); + + // Get number of Lbs self locate events + if (view->SetFilterL(*filter, active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + TEST2(view->CountL(), lbsSelf); + + filter->SetEventType(KLogLbsExternalLocateEventTypeUid); + + // Get number of Lbs self locate events + if (view->SetFilterL(*filter, active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + TEST2(view->CountL(), lbsExternal); + + filter->SetEventType(KLogLbsTransmitLocationEventTypeUid); + + // Get number of Lbs transmit location events + if (view->SetFilterL(*filter, active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + TEST2(view->CountL(), lbsXmitLoc); + + filter->SetEventType(KLogLbsNetworkLocateEventTypeUid); + + // Get number of Lbs network locate events + if (view->SetFilterL(*filter, active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + TEST2(view->CountL(), lbsNetwork); + + filter->SetEventType(KLogLbsAssistanceDataEventTypeUid); + + // Get number of Lbs assistance data events + if (view->SetFilterL(*filter, active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + TEST2(view->CountL(), lbsAssistance); + + // Test a non existing event type + filter->SetEventType(TUid::Uid(0x12345678)); + res = view->SetFilterL(*filter, active->iStatus); + TEST(!res); + TEST2(view->CountL(), 0); + + CleanupStack::PopAndDestroy(4); // view, filter, event, active + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0855 +@SYMTestCaseDesc Tests for CLogViewRecent::SetRecentListL() function +@SYMTestPriority High +@SYMTestActions Tests for the count of events,outgoing calls. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestRecentView1L(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0855 ")); + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogViewRecent* view = CLogViewRecent::NewL(aClient); + CleanupStack::PushL(view); + + // Incoming + TBuf buf; + aClient.GetString(buf, R_LOG_DIR_IN); + + event->SetEventType(KLogCallEventTypeUid); + event->SetDirection(buf); + + TInt count; + for(count = 0; count < KTestEventNum; count++) + { + event->SetContact(count); + + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + + TEST2(view->CountL(), 0); + TBool res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + + // Move forward + count = KTestEventNum; + do { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST2(view->CountL(), KTestEventNum); + TEST2(view->RecentList(), KLogRecentIncomingCalls); + count--; + } + while(view->NextL(active->iStatus)); + TEST2(count, 0); + TEST2(view->CountL(), KTestEventNum); + + // Move back + while(view->PreviousL(active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST2(view->CountL(), KTestEventNum); + TEST2(view->RecentList(), KLogRecentIncomingCalls); + count++; + } + TEST(count == KTestEventNum - 1); + + active->StartL(); + res = view->FirstL(active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + active->StartL(); + res = view->LastL(active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST2(view->CountL(), KTestEventNum); + + // Outgoing + res = view->SetRecentListL(KLogRecentOutgoingCalls, active->iStatus); + TEST(!res); + count = view->CountL(); + TEST2(count, 0); + CleanupStack::PopAndDestroy(view); + // + view = CLogViewRecent::NewL(aClient); + CleanupStack::PushL(view); + res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + TEST2(view->CountL(), KTestEventNum); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + aClient.GetString(buf, R_LOG_DIR_OUT); + + event->SetEventType(KLogCallEventTypeUid); + event->SetDirection(buf); + + for(count = 0; count < KTestEventNum; count++) + { + event->SetContact(count); + + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + + count = view->CountL(); + TEST2(count, KTestEventNum); + res = view->SetRecentListL(KLogRecentOutgoingCalls, active->iStatus); + TEST(res); + + // Move forward + count = KTestEventNum; + do { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST2(view->CountL(), KTestEventNum); + TEST2(view->RecentList(), KLogRecentOutgoingCalls); + count--; + } + while(view->NextL(active->iStatus)); + TEST2(count, 0); + TEST2(view->CountL(), KTestEventNum); + + // Move back + while(view->PreviousL(active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST2(view->CountL(), KTestEventNum); + TEST2(view->RecentList(), KLogRecentOutgoingCalls); + count++; + } + TEST(count == KTestEventNum - 1); + + active->StartL(); + res = view->FirstL(active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + active->StartL(); + res = view->LastL(active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Missed + aClient.GetString(buf, R_LOG_DIR_MISSED); + + event->SetEventType(KLogCallEventTypeUid); + event->SetDirection(buf); + + TEST2(view->CountL(), KTestEventNum); + res = view->SetRecentListL(KLogRecentMissedCalls, active->iStatus); + TEST(!res); + TEST2(view->CountL(), 0); + + for(count = 0; count < KTestEventNum; count++) + { + event->SetContact(count); + + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Test INC123066 - LogView not updated if log count is zero at + // time of SetFilterL. + TEST2(view->CountL(), count+1); + } + + + // Move forward + count = KTestEventNum; + while(view->NextL(active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST2(view->CountL(), KTestEventNum); + TEST2(view->RecentList(), KLogRecentMissedCalls); + count--; + } + TEST2(count, 0); + + // Move back + while(view->PreviousL(active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST2(view->CountL(), KTestEventNum); + TEST2(view->RecentList(), KLogRecentMissedCalls); + count++; + } + TEST(count == KTestEventNum - 1); + + active->StartL(); + res = view->FirstL(active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + active->StartL(); + res = view->LastL(active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // All + TEST2(view->CountL(), KTestEventNum); + res = view->SetRecentListL(KLogNullRecentList, active->iStatus); + TEST(res); + + // Move forward + count = KTestEventNum * 3; + TEST2(view->CountL(), count); + do { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST(view->CountL() == KTestEventNum * 3); + count--; + } + while(view->NextL(active->iStatus)); + TEST2(count, 0); + + // Move back + while(view->PreviousL(active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST(view->CountL() == KTestEventNum * 3); + count++; + } + TEST(count == KTestEventNum * 3 - 1); + + active->StartL(); + res = view->FirstL(active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + active->StartL(); + res = view->LastL(active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + CleanupStack::PopAndDestroy(3); // view, active, event + theLog.Write(_L8("Test 3.1 OK\n")); + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0856 +@SYMTestCaseDesc Tests for CLogViewRecent::SetRecentListL(),DuplicatesL() functions +@SYMTestPriority High +@SYMTestActions Tests for the count of events in the log +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestRecentView2L(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0856 ")); + TInt count; + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogViewRecent* view = CLogViewRecent::NewL(aClient); + CleanupStack::PushL(view); + + TEST2(view->CountL(), 0); + TBool res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST2(count, KTestEventNum); + + aClient.ClearLog(KLogRecentIncomingCalls, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + count = view->CountL(); + TEST2(count, 0); + + CleanupStack::PopAndDestroy(view); + view = CLogViewRecent::NewL(aClient); + CleanupStack::PushL(view); + + + // Incoming + TBuf buf; + aClient.GetString(buf, R_LOG_DIR_IN); + + event->SetEventType(KLogCallEventTypeUid); + event->SetDirection(buf); + + // All fields are null, they should all be duplicates + for(count = 0; count < KTestEventNum; count++) + { + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + + TEST2(view->CountL(), 0); + + // Move forward + res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->CountL(), 1); + + CLogViewDuplicate* dView = CLogViewDuplicate::NewL(aClient); + CleanupStack::PushL(dView); + + res = view->DuplicatesL(*dView, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST(dView->CountL() == KTestEventNum - 1); + + CleanupStack::PopAndDestroy(4); // view, active, event, dView + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0857 +@SYMTestCaseDesc Tests for CLogViewRecent::RemoveL() functions +@SYMTestPriority High +@SYMTestActions Add the recently view events to the view.Remove the items and check for the count. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestRecentRemove1L(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0857 ")); + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogViewRecent* view = CLogViewRecent::NewL(aClient); + CleanupStack::PushL(view); + + TBool res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TInt count = view->CountL(); + + while(view->RemoveL(active->iStatus)) + { + TEST(view->CountL() == count - 1); + count = view->CountL(); + + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + TEST2(view->CountL(), 0); + + res = view->SetRecentListL(KLogRecentOutgoingCalls, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->CountL(), KTestEventNum); + + aClient.ClearLog(KLogRecentOutgoingCalls, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->CountL(), 0); + + res = view->SetRecentListL(KLogRecentOutgoingCalls, active->iStatus); + TEST(!res); + + res = view->SetRecentListL(KLogNullRecentList, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->CountL(), KTestEventNum); + + aClient.ClearLog(KLogNullRecentList, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + res = view->SetRecentListL(KLogNullRecentList, active->iStatus); + TEST(!res); + TEST2(view->CountL(), 0); + + CleanupStack::PopAndDestroy(2); // view, active + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0858 +@SYMTestCaseDesc Tests for CLogViewRecent::RemoveL() functions +@SYMTestPriority High +@SYMTestActions Add the recently view events to the two logviewrecents.Remove the items and check for the count of the first logview. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestRecentRemove2L(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0858 ")); + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogViewRecent* view1 = CLogViewRecent::NewL(aClient); + CleanupStack::PushL(view1); + + // Incoming + TBuf buf; + aClient.GetString(buf, R_LOG_DIR_IN); + + event->SetEventType(KLogCallEventTypeUid); + event->SetDirection(buf); + + TInt count; + for(count = 0; count < KTestEventNum; count++) + { + event->SetContact(count); + + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + + // Create another invalid view and remove an event using it + CLogViewRecent* view2 = CLogViewRecent::NewL(aClient); + CleanupStack::PushL(view2); + + TEST2(view1->CountL(), 0); + TBool res = view1->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + TEST2(view1->CountL(), KTestEventNum); + + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + view2->RemoveL(view1->Event().Id()); + } + while(view1->NextL(active->iStatus)); + + aClient.ClearLog(KLogRecentIncomingCalls, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view1->CountL(), 0); + + CleanupStack::PopAndDestroy(4); // view2, view1, active, event + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0859 +@SYMTestCaseDesc Tests for CLogViewDuplicate::SetRecentListL(),DuplicatesL() functions +@SYMTestPriority High +@SYMTestActions Tests for the count of events and the event ID +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestDuplicateViewL(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0859 ")); + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogViewRecent* view = CLogViewRecent::NewL(aClient); + CleanupStack::PushL(view); + + CLogViewDuplicate* dView = CLogViewDuplicate::NewL(aClient); + CleanupStack::PushL(dView); + + TEST2(dView->CountL(), 0); + + TBool res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(!res); + TEST2(view->CountL(), 0); + + res = view->DuplicatesL(*dView, active->iStatus); + TEST(!res); + TEST2(dView->CountL(), 0); + + // Incoming + TBuf incoming; + aClient.GetString(incoming, R_LOG_DIR_IN); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + event->SetEventType(KLogCallEventTypeUid); + event->SetDirection(incoming); + event->SetRemoteParty(KTestRemoteParty); + event->SetContact(KTestContact); + event->SetNumber(KTestNumber); + + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST2(view->CountL(), 1); + res = view->FirstL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), event->Id()); + + TEST2(dView->CountL(), 0); + + event->SetRemoteParty(KTestRemoteParty); + event->SetContact(KTestContact); + event->SetNumber(KNullDesC); + + //Add event with Number field set to NULL + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST2(view->CountL(), 2); + res = view->FirstL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), event->Id()); + + res = view->DuplicatesL(*dView, active->iStatus); + TEST(!res); + + TEST2(dView->CountL(), 0); + + event->SetRemoteParty(KTestRemoteParty); + event->SetContact(KLogNullContactId); + event->SetNumber(KNullDesC); + + //Add event with Number field set to NULL & Contact set to -1 + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST2(view->CountL(), 3); + res = view->FirstL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), event->Id()); + + res = view->DuplicatesL(*dView, active->iStatus); + TEST(!res); + + TEST2(dView->CountL(), 0); + + event->SetRemoteParty(KNullDesC); + event->SetContact(KLogNullContactId); + event->SetNumber(KNullDesC); + + //Add event with Number, Remote Party field set to NULL & Contact set to -1 + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST2(view->CountL(), 4); + + res = view->DuplicatesL(*dView, active->iStatus); + TEST(!res); + + TEST2(dView->CountL(), 0); + + TLogId lastId = event->Id(); + + //Add event with Number, Remote Party field set to NULL & Contact set to -1 + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST2(view->CountL(), 4); + + res = view->DuplicatesL(*dView, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST2(dView->CountL(), 1); + TEST2(dView->Event().Id(), lastId); + + CleanupStack::PopAndDestroy(4); // event, dView, view, active + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0860 +@SYMTestCaseDesc Tests for CLogViewDuplicate::RemoveL() functions +@SYMTestPriority High +@SYMTestActions Tests for removing the events and test for the count +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestDuplicateRemoveL(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0860 ")); + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogViewRecent* view = CLogViewRecent::NewL(aClient); + CleanupStack::PushL(view); + + CLogViewDuplicate* dView = CLogViewDuplicate::NewL(aClient); + CleanupStack::PushL(dView); + + TBool res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + //The incoming call list should have count as 4. These calls were added in + //...the previous function named TestDuplicateViewL() + TEST2(view->CountL(), 4); + + res = view->DuplicatesL(*dView, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TLogId id = dView->Event().Id(); + TEST2(dView->CountL(), 1); + + res = dView->RemoveL(active->iStatus); + TEST(!res); + + TEST2(dView->CountL(), 0); + + res = dView->RemoveL(active->iStatus); + TEST(!res); + TEST2(dView->CountL(), 0); + + TEST2(view->CountL(), 4); + + CleanupStack::PopAndDestroy(3); // dView, view, active + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0861 +@SYMTestCaseDesc Tests for purging on log engine +@SYMTestPriority High +@SYMTestActions Tests for changing the log engine configuration,add event and test for retrieving them back. + Set up a purge which clears the log and reset the log configuration +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestPurgeOnSetup1L(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0861 ")); + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + User::After(0x100000); + + TTime now; + now.UniversalTime(); + + // Clear all the events + active->StartL(); + aClient.ClearLog(now, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + event->SetEventType(KLogCallEventTypeUid); + + TLogConfig config; + + // Get log configuration + active->StartL(); + aClient.GetConfig(config, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Set the maximum log age + TInt oldAge = config.iMaxEventAge; + config.iMaxEventAge = 10; // 10 seconds! + + // Change the log engine config + active->StartL(); + aClient.ChangeConfig(config, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Check that the event can be retrieved + active->StartL(); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Wait for 15 seconds (just to be safe) + User::After(15000000); + + // Check that the event can be retrieved + active->StartL(); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Check that the event can still be retrieved + active->StartL(); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Check that the event can still be retrieved + active->StartL(); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + CLogViewEvent* view = CLogViewEvent::NewL(aClient); + CleanupStack::PushL(view); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + // Setup a view which should purge the event - hence no events in view! + TBool res = view->SetFilterL(*filter, active->iStatus); + TEST(!res); + + // Reset the config + config.iMaxEventAge = oldAge; + + // Change the log engine config + active->StartL(); + aClient.ChangeConfig(config, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + CleanupStack::PopAndDestroy(4); // filter, view, active, event + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0862 +@SYMTestCaseDesc Tests for purging on log engine +@SYMTestPriority High +@SYMTestActions Clear the events from the log,set the log engine age to maximum.Change the configuration,and test adding and retrieving the events. + Set up a purge which clears the log and reset the log configuration +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestPurgeOnSetup2L(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0862 ")); + CTestActive* active1 = new(ELeave)CTestActive(); + CleanupStack::PushL(active1); + + CTestActive* active2 = new(ELeave)CTestActive(); + CleanupStack::PushL(active2); + + User::After(0x100000); + + TTime now; + now.UniversalTime(); + + // Clear all the events + active1->StartL(); + aClient.ClearLog(now, active1->iStatus); + CActiveScheduler::Start(); + TEST2(active1->iStatus.Int(), KErrNone); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + event->SetEventType(KLogCallEventTypeUid); + + TLogConfig config; + + // Get log configuration + active1->StartL(); + aClient.GetConfig(config, active1->iStatus); + CActiveScheduler::Start(); + TEST2(active1->iStatus.Int(), KErrNone); + + // Set the maximum log age + TInt oldAge = config.iMaxEventAge; + config.iMaxEventAge = 10; // 10 seconds! + + // Change the log engine config + active1->StartL(); + aClient.ChangeConfig(config, active1->iStatus); + CActiveScheduler::Start(); + TEST2(active1->iStatus.Int(), KErrNone); + + active1->StartL(); + aClient.AddEvent(*event, active1->iStatus); + CActiveScheduler::Start(); + TEST2(active1->iStatus.Int(), KErrNone); + + // Check that the event can be retrieved + active1->StartL(); + aClient.GetEvent(*event, active1->iStatus); + CActiveScheduler::Start(); + TEST2(active1->iStatus.Int(), KErrNone); + + // Wait for 15 seconds (just to be safe) + User::After(15000000); + + // Check that the event can be retrieved + active1->StartL(); + aClient.GetEvent(*event, active1->iStatus); + CActiveScheduler::Start(); + TEST2(active1->iStatus.Int(), KErrNone); + + // Check that the event can still be retrieved + active1->StartL(); + aClient.GetEvent(*event, active1->iStatus); + CActiveScheduler::Start(); + TEST2(active1->iStatus.Int(), KErrNone); + + // Check that the event can still be retrieved + active1->StartL(); + aClient.GetEvent(*event, active1->iStatus); + CActiveScheduler::Start(); + TEST2(active1->iStatus.Int(), KErrNone); + + CLogViewEvent* view1 = CLogViewEvent::NewL(aClient); + CleanupStack::PushL(view1); + + CLogViewEvent* view2 = CLogViewEvent::NewL(aClient); + CleanupStack::PushL(view2); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + // Setup a view which should purge the event - hence no events in view! + TBool res = view1->SetFilterL(*filter, active1->iStatus); + TEST(!res); + res = view2->SetFilterL(*filter, active2->iStatus); + TEST(!res); + + // Reset the config + config.iMaxEventAge = oldAge; + + // Change the log engine config + active1->StartL(); + aClient.ChangeConfig(config, active1->iStatus); + CActiveScheduler::Start(); + TEST2(active1->iStatus.Int(), KErrNone); + + CleanupStack::PopAndDestroy(6); // filter, view1, view2, active1, active2, event + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0863 +@SYMTestCaseDesc Tests for purge on CLogViewRecent +@SYMTestPriority High +@SYMTestActions Set the log engine maximum log size and recent log size.Change the configuration and add events to the log + Tests the count to be less than or equal to recent logsize. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestViewPurgeL(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0863 ")); + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + TLogConfig config; + + aClient.GetConfig(config, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST2(config.iMaxLogSize, 1000); + TEST(config.iMaxRecentLogSize = 10); + + config.iMaxLogSize = 2000; + config.iMaxRecentLogSize = 20; + + aClient.ChangeConfig(config, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + CLogViewRecent* view = CLogViewRecent::NewL(aClient); + CleanupStack::PushL(view); + + // Incoming + TBuf buf; + aClient.GetString(buf, R_LOG_DIR_IN); + + event->SetEventType(KLogCallEventTypeUid); + event->SetDirection(buf); + + for(TInt count = 0; count < config.iMaxRecentLogSize * 2; count++) + { + event->SetContact(count); + + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TBool res = view->SetRecentListL(KLogNullRecentList, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST(view->CountL() <= config.iMaxRecentLogSize); + } + + CleanupStack::PopAndDestroy(3); // active, event, view + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0864 +@SYMTestCaseDesc Tests for the functionality of CLogViewDuplicate class +@SYMTestPriority High +@SYMTestActions Tests for clearing the duplicate events +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestClearDuplicatesL(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0864 ")); + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + aClient.ClearLog(KLogNullRecentList, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + CLogViewRecent* view = CLogViewRecent::NewL(aClient); + CleanupStack::PushL(view); + + CLogViewDuplicate* dView = CLogViewDuplicate::NewL(aClient); + CleanupStack::PushL(dView); + + TBool res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(!res); + + TBuf incoming; + aClient.GetString(incoming, R_LOG_DIR_IN); + + TBuf outgoing; + aClient.GetString(outgoing, R_LOG_DIR_OUT); + + TBuf missed; + aClient.GetString(missed, R_LOG_DIR_MISSED); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + event->SetEventType(KLogCallEventTypeUid); + + // Add 5 recent events to each list - with 5 duplicates each + + // Incoming + event->SetDirection(incoming); + TInt recent; + for(recent = 1; recent <= 5; recent++) + { + event->SetContact(recent); + for(TInt duplicate = 1; duplicate <= 6; duplicate++) + { + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + } + + // Outgoing + event->SetDirection(outgoing); + for(recent = 1; recent <= 5; recent++) + { + event->SetContact(recent); + for(TInt duplicate = 1; duplicate <= 6; duplicate++) + { + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + } + + // Missed + event->SetDirection(missed); + for(recent = 1; recent <= 5; recent++) + { + event->SetContact(recent); + for(TInt duplicate = 1; duplicate <= 6; duplicate++) + { + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + } + + // Check outgoing + res = view->SetRecentListL(KLogRecentOutgoingCalls, active->iStatus); + TEST(res); + TEST2(view->CountL(), 5); + + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + res = view->DuplicatesL(*dView, active->iStatus); + TEST(res); + TEST2(dView->CountL(), 5); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + while(view->NextL(active->iStatus)); + + // Check missed + res = view->SetRecentListL(KLogRecentMissedCalls, active->iStatus); + TEST(res); + TEST2(view->CountL(), 5); + + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + res = view->DuplicatesL(*dView, active->iStatus); + TEST(res); + TEST2(dView->CountL(), 5); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + while(view->NextL(active->iStatus)); + + // Check incoming + res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + TEST2(view->CountL(), 5); + + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + res = view->DuplicatesL(*dView, active->iStatus); + TEST(res); + TEST2(dView->CountL(), 5); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + while(view->NextL(active->iStatus)); + + // Clear duplicates for incoming + view->ClearDuplicatesL(); + TEST2(view->CountL(), 5); + + // Recent list should be unchanged + res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + TEST2(view->CountL(), 5); + + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // No duplicates should exist for this view now + res = view->DuplicatesL(*dView, active->iStatus); + TEST(!res); + TEST2(dView->CountL(), 0); + } + while(view->NextL(active->iStatus)); + + // Check outgoing is unchanged + res = view->SetRecentListL(KLogRecentOutgoingCalls, active->iStatus); + TEST(res); + TEST2(view->CountL(), 5); + + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + res = view->DuplicatesL(*dView, active->iStatus); + TEST(res); + TEST2(dView->CountL(), 5); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + while(view->NextL(active->iStatus)); + + // Check missed is unchanged + res = view->SetRecentListL(KLogRecentMissedCalls, active->iStatus); + TEST(res); + TEST2(view->CountL(), 5); + + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + res = view->DuplicatesL(*dView, active->iStatus); + TEST(res); + TEST2(dView->CountL(), 5); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + while(view->NextL(active->iStatus)); + + // Clear duplicates for missed + view->ClearDuplicatesL(); + TEST2(view->CountL(), 5); + + // Recent list should be unchanged + res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + TEST2(view->CountL(), 5); + + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // No duplicates should exist for this view now + res = view->DuplicatesL(*dView, active->iStatus); + TEST(!res); + TEST2(dView->CountL(), 0); + } + while(view->NextL(active->iStatus)); + + // Missed recent list should be unchanged + res = view->SetRecentListL(KLogRecentMissedCalls, active->iStatus); + TEST(res); + TEST2(view->CountL(), 5); + + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // No duplicates should exist for this view now + res = view->DuplicatesL(*dView, active->iStatus); + TEST(!res); + TEST2(dView->CountL(), 0); + } + while(view->NextL(active->iStatus)); + + // Check outgoing is unchanged + res = view->SetRecentListL(KLogRecentOutgoingCalls, active->iStatus); + TEST(res); + TEST2(view->CountL(), 5); + + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + res = view->DuplicatesL(*dView, active->iStatus); + TEST(res); + TEST2(dView->CountL(), 5); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + while(view->NextL(active->iStatus)); + + // Clear duplicates for outgoing + view->ClearDuplicatesL(); + TEST2(view->CountL(), 5); + + // Recent list should be unchanged + res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + TEST2(view->CountL(), 5); + + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // No duplicates should exist for this view now + res = view->DuplicatesL(*dView, active->iStatus); + TEST(!res); + TEST2(dView->CountL(), 0); + } + while(view->NextL(active->iStatus)); + + // Missed recent list should be unchanged + res = view->SetRecentListL(KLogRecentMissedCalls, active->iStatus); + TEST(res); + TEST2(view->CountL(), 5); + + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // No duplicates should exist for this view now + res = view->DuplicatesL(*dView, active->iStatus); + TEST(!res); + TEST2(dView->CountL(), 0); + } + while(view->NextL(active->iStatus)); + + // Check outgoing is unchanged + res = view->SetRecentListL(KLogRecentOutgoingCalls, active->iStatus); + TEST(res); + TEST2(view->CountL(), 5); + + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // No duplicates should exist for this view now + res = view->DuplicatesL(*dView, active->iStatus); + TEST(!res); + TEST2(dView->CountL(), 0); + } + while(view->NextL(active->iStatus)); + + CleanupStack::PopAndDestroy(4); // event, dView, view, active + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0865 +@SYMTestCaseDesc Test for the functionality of CLogViewEvent class +@SYMTestPriority High +@SYMTestActions Set an event with a number,add the event to the client.Tests for matching a number from the view +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestPhoneNumberMatchingL(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0865 ")); + TestUtils::DeleteDatabaseL(); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + event->SetEventType(KLogCallEventTypeUid); + TBuf missed; + aClient.GetString(missed, R_LOG_DIR_MISSED); + event->SetDirection(missed); + + TLogString number; + TInt i; + for(i = 0; i < 10; i++) + { + TBuf<1> digit; + digit.Num(i); + number.Insert(0, digit); + event->SetNumber(number); + + aClient.AddEvent(*event, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + CLogViewEvent* view = CLogViewEvent::NewL(aClient); + CleanupStack::PushL(view); + + TBool res = view->SetFilterL(*filter, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->CountL(), 10); + + number.Zero(); + for(i = 0; i < 10; i++) + { + TBuf<1> digit; + digit.Num(i); + number.Insert(0, digit); + filter->SetNumber(number); + + // This is testing phone number matching + res = view->SetFilterL(*filter, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Phone numbers with KTestLogNumberCharsToMatch characters or above can match with each other + TEST2(view->CountL(), (number.Length() < KTestLogNumberCharsToMatch) ? 1 : 11-KTestLogNumberCharsToMatch); + } + + CLogViewRecent* recent = CLogViewRecent::NewL(aClient); + CleanupStack::PushL(recent); + + CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(aClient); + CleanupStack::PushL(duplicate); + + res = recent->SetRecentListL(KLogRecentMissedCalls, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(recent->CountL(), KTestLogNumberCharsToMatch); + + res = recent->DuplicatesL(*duplicate, active->iStatus); + TEST(res); + TEST2(duplicate->CountL(), 10-KTestLogNumberCharsToMatch); + + // Check the first recent event has duplicates + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TPtrC number1(recent->Event().Number().Right(KTestLogNumberCharsToMatch)); + TPtrC number2(duplicate->Event().Number().Right(KTestLogNumberCharsToMatch)); + TEST(number1 == number2); + } + while(duplicate->NextL(active->iStatus)); + + // Check none of the others have duplicates + while(recent->NextL(active->iStatus)) + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + res = recent->DuplicatesL(*duplicate, active->iStatus); + TEST(!res); + } + + CleanupStack::PopAndDestroy(6); // duplicate, recent, view, filter, event, active + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-3472 +@SYMTestCaseDesc Tests duplicate number matching correctly compares and matches the last 9 digits +@SYMTestPriority High +@SYMTestActions Create and add several numbers to client, check that duplicates are correctly removed +@SYMTestExpectedResults Number with the same last 9 digits should get matched as duplicates +@SYMDEF INC105010 +*/ +LOCAL_C void INC105010L(CLogClient& aClient) +{ + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-3472 ")); + TestUtils::DeleteDatabaseL(); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + event->SetEventType(KLogCallEventTypeUid); + TBuf missed; + aClient.GetString(missed, R_LOG_DIR_MISSED); + event->SetDirection(missed); + + _LIT(KTestNumber1, "0401234567"); // unique + _LIT(KTestNumber2, "0421234567"); // unique + _LIT(KTestNumber3, "0521234567"); // unique + _LIT(KTestNumber4, "9521234567"); // duplicate + _LIT(KTestNumber5, "9521234567"); // duplicate + + TLogString number; + + // add events for the above numbers + event->SetNumber(KTestNumber1); + aClient.AddEvent(*event, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + event->SetNumber(KTestNumber2); + aClient.AddEvent(*event, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + event->SetNumber(KTestNumber3); + aClient.AddEvent(*event, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + event->SetNumber(KTestNumber4); + aClient.AddEvent(*event, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + event->SetNumber(KTestNumber5); + aClient.AddEvent(*event, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + CLogViewEvent* view = CLogViewEvent::NewL(aClient); + CleanupStack::PushL(view); + + // check 5 entries in log + TBool res = view->SetFilterL(*filter, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->CountL(), 5); + + CLogViewRecent* recent = CLogViewRecent::NewL(aClient); + CleanupStack::PushL(recent); + + CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(aClient); + CleanupStack::PushL(duplicate); + + // check only 3 entries in recent calls view + res = recent->SetRecentListL(KLogRecentMissedCalls, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TInt rrr = recent->CountL(); + TEST2(recent->CountL(), 3); + + // and that there are 2 duplicates + res = recent->DuplicatesL(*duplicate, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TInt ddd = duplicate->CountL(); + TEST2(duplicate->CountL(), 2); + + CleanupStack::PopAndDestroy(6); +} + + + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0866 +@SYMTestCaseDesc Tests for CLogViewEvent::SetFlagsL() function +@SYMTestPriority High +@SYMTestActions Add events to the log and set the flags.Check if all the flags are set. + Clear all the flags and set half view of the flags.Check if only all view of the flags are set. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestRecentFlagsL(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0866 ")); + TestUtils::DeleteDatabaseL(); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogViewRecent* view = CLogViewRecent::NewL(aClient); + CleanupStack::PushL(view); + + // Incoming + TBuf buf; + aClient.GetString(buf, R_LOG_DIR_IN); + + event->SetEventType(KLogCallEventTypeUid); + event->SetDirection(buf); + + TInt count; + for(count = 0; count < KTestEventNum; count++) + { + event->SetContact(count); + + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + + TEST2(view->CountL(), 0); + TBool res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->CountL(), KTestEventNum); + + // Set all flags in view + const TLogFlags KAllFlagsSet = 15; // (BIN) 1,1,1,1 + view->SetFlagsL(KAllFlagsSet); + + // Check we can move to the first record + res = view->FirstL(active->iStatus); + TEST(res); + + // Check all flags are now set + count = KTestEventNum; + do { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + // + TEST2(view->CountL(), KTestEventNum); + TEST2(view->RecentList(), KLogRecentIncomingCalls); + // + const TLogFlags flags = view->Event().Flags(); + TEST2(flags, KAllFlagsSet); + count--; + } + while(view->NextL(active->iStatus)); + + TEST2(count, 0); + TEST2(view->CountL(), KTestEventNum); + + // Clear all flags in view + const TLogFlags KAllFlagsCleared = 0; // (BIN) 0,0,0,0 + view->SetFlagsL(KAllFlagsCleared); + TEST2(view->CountL(), KTestEventNum); + + // Check we can move to the first record + res = view->FirstL(active->iStatus); + TEST(res); + + // Check all flags are now set + count = KTestEventNum; + do { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + // + TEST2(view->CountL(), KTestEventNum); + TEST2(view->RecentList(), KLogRecentIncomingCalls); + // + const TLogFlags flags = view->Event().Flags(); + TEST2(flags, KAllFlagsCleared); + count--; + } + while(view->NextL(active->iStatus)); + + TEST2(count, 0); + TEST2(view->CountL(), KTestEventNum); + + // Set lower half flags in view + const TLogFlags KLowerHalfFlagsSet = 3; // (BIN) 1,1,0,0 + view->SetFlagsL(KLowerHalfFlagsSet); + + // Check we can move to the first record + res = view->FirstL(active->iStatus); + TEST(res); + + // Check all flags are now set + count = KTestEventNum; + do { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + // + TEST2(view->CountL(), KTestEventNum); + TEST2(view->RecentList(), KLogRecentIncomingCalls); + // + const TLogFlags flags = view->Event().Flags(); + TEST2(flags, KLowerHalfFlagsSet); + count--; + } + while(view->NextL(active->iStatus)); + + TEST2(count, 0); + TEST2(view->CountL(), KTestEventNum); + + CleanupStack::PopAndDestroy(3, event); // view, active, event + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0867 +@SYMTestCaseDesc Tests for CLogViewEvent::SetFlagsL() function +@SYMTestPriority High +@SYMTestActions Add events to the log and set the flags.Check if flags for only the events in view are set. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestViewFlagsL(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0867 ")); + TestUtils::DeleteDatabaseL(); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogViewEvent* view = CLogViewEvent::NewL(aClient); + CleanupStack::PushL(view); + + // Incoming + TBuf buf; + aClient.GetString(buf, R_LOG_DIR_IN); + + event->SetEventType(KLogCallEventTypeUid); + event->SetDirection(buf); + + event->SetNumber(_L("123")); + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TLogId testId = event->Id(); + event->SetNumber(KNullDesC); + + TInt count; + for(count = 0; count < KTestEventNum; count++) + { + event->SetContact(count + 1); + + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + + TEST2(view->CountL(), 0); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + filter->SetNullFields(ELogNumberField); + + TEST2(view->CountL(), 0); + TBool res = view->SetFilterL(*filter, active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->CountL(), KTestEventNum); + + // Set all flags in view + const TLogFlags KAllFlagsSet = 15; // (BIN) 1,1,1,1 + view->SetFlagsL(KAllFlagsSet); + + // Check flags only set for events in the view + active->StartL(); + event->SetId(testId); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + if( TheMatchingIsEnabled) + { + TEST2(event->Flags(), KLogEventContactSearched); + } + else + { + TEST2(event->Flags(), 0); + } + + // Check we can move to the first record + res = view->FirstL(active->iStatus); + TEST(res); + + // Check all flags are now set + count = KTestEventNum; + do { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + // + TEST2(view->CountL(), KTestEventNum); + // + const TLogFlags flags = view->Event().Flags(); + TEST2(flags, KAllFlagsSet); + count--; + } + while(view->NextL(active->iStatus)); + + TEST2(count, 0); + TEST2(view->CountL(), KTestEventNum); + + // Clear all flags in view + const TLogFlags KAllFlagsCleared = 0; // (BIN) 0,0,0,0 + view->SetFlagsL(KAllFlagsCleared); + TEST2(view->CountL(), KTestEventNum); + + // Check flags only set for events in the view + active->StartL(); + event->SetId(testId); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + if( TheMatchingIsEnabled) + { + TEST2(event->Flags(), KLogEventContactSearched); + } + else + { + TEST2(event->Flags(), 0); + } + + // Check we can move to the first record + res = view->FirstL(active->iStatus); + TEST(res); + + // Check all flags are now set + count = KTestEventNum; + do { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + // + TEST2(view->CountL(), KTestEventNum); + // + const TLogFlags flags = view->Event().Flags(); + TEST2(flags, KAllFlagsCleared); + count--; + } + while(view->NextL(active->iStatus)); + + TEST2(count, 0); + TEST2(view->CountL(), KTestEventNum); + + // Set lower half flags in view + const TLogFlags KLowerHalfFlagsSet = 3; // (BIN) 1,1,0,0 + view->SetFlagsL(KLowerHalfFlagsSet); + + // Check flags only set for events in the view + active->StartL(); + event->SetId(testId); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + if( TheMatchingIsEnabled) + { + TEST2(event->Flags(), KLogEventContactSearched); + } + else + { + TEST2(event->Flags(), 0); + } + + // Check we can move to the first record + res = view->FirstL(active->iStatus); + TEST(res); + + // Check all flags are now set + count = KTestEventNum; + do { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + // + TEST2(view->CountL(), KTestEventNum); + // + const TLogFlags flags = view->Event().Flags(); + TEST2(flags, KLowerHalfFlagsSet); + count--; + } + while(view->NextL(active->iStatus)); + + TEST2(count, 0); + TEST2(view->CountL(), KTestEventNum); + + CleanupStack::PopAndDestroy(4, event); // filter, view, active, event + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0868 +@SYMTestCaseDesc Tests for CLogViewChangeObserver::HaveChanges(),Changes() functions +@SYMTestPriority High +@SYMTestActions Check for observing changes while adding and deleting events +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestViewChangeEvents1L(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0868 ")); + TestUtils::DeleteDatabaseL(); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + filter->SetContact(KTestContact); + filter->SetEventType(KLogPacketDataEventTypeUid); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogViewChangeObserver* changeObs = CLogViewChangeObserver::NewLC(); + changeObs->SetActive(); + + CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs); + CleanupStack::PushL(view); + + // Incoming + TBuf buf; + aClient.GetString(buf, R_LOG_DIR_IN); + + event->SetEventType(KLogPacketDataEventTypeUid); + event->SetDirection(buf); + event->SetContact(KTestContact); + + TInt i; + TInt count; + for(count = 0; count < KTestEventNum; count++) + { + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + User::After(1 * 1000000); + } + // + TEST2(view->CountL(), 0); + active->StartL(); + TBool res = view->SetFilterL(*filter, active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->CountL(), KTestEventNum); + // + count = KTestEventNum; + res = view->FirstL(active->iStatus); + TEST(res); + do { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + // + TEST2(view->CountL(), KTestEventNum); + const TLogId eventId = view->Event().Id(); + TLogId id = --count; + TEST2(eventId, id); + } + while(view->NextL(active->iStatus)); + + // Transients + TInt changeCount; + TLogId logId; + TInt viewIndex; + TLogDatabaseChangeType type; + CLogChangeDefinition* changes; + + // Add an event and check for changes + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + changes = changeObs->WaitForChangesLC(); + if (active->IsActive()) + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST2(count, KTestEventNum+1); + + changeCount = changes->Count(); + for(i=0; iAt(i, logId, viewIndex); + RDebug::Print(_L("Change Type: %d, logId: %d, viewIndex: %d\n"), type, logId, viewIndex); + } + + // Check the change was as expected + TEST2(changes->Count(), 1); + type = changes->At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventAdded); + TEST2(viewIndex, 0); // first (newest) event in the view + { + const TLogId expectedLogId = ((TLogId) KTestEventNum); + TEST2(logId, expectedLogId); + } + CleanupStack::PopAndDestroy(changes); + + // Check view navigation + i=0; + res = view->FirstL(active->iStatus); + TEST(res); + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + RDebug::Print(_L("View Entry[%d]: Id: %d\n"), i++, view->Event().Id()); + } + while(view->NextL(active->iStatus)); + RDebug::Print(_L("==\n")); + TEST2(i, count); + res = view->FirstL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Delete some events + TEST(KTestEventNum >= 10); + changeObs->StartCollectingChanges(); + for(i=1; iStartL(); + aClient.DeleteEvent(TLogId(i), active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + } + + // Check changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 5); // 1,3,5,7,9 + for(i=0; iChanges().At(i, logId, viewIndex) == ELogChangeTypeEventDeleted); + TEST(logId == TLogId(2*i + 1)); + TEST(viewIndex == 10 - ((2*i) + 1)); + } + + // Add a new event that shouldn't appear in the view + changeObs->StartCollectingChanges(); + event->SetContact(TLogContactItemId(0)); + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KTestEventNum + 1 - 5); + TEST(event->Id() == KTestEventNum + 1); + + // Check changes + TEST(!changeObs->HaveChanges()); + + // Check view navigation + i=0; + res = view->FirstL(active->iStatus); + TEST(res); + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + RDebug::Print(_L("View Entry[%d]: Id: %d\n"), i++, view->Event().Id()); + } + while(view->NextL(active->iStatus)); + RDebug::Print(_L("==\n")); + TEST2(i, count); + res = view->FirstL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Delete event which isn't in view + changeObs->StartCollectingChanges(); + active->StartL(); + aClient.DeleteEvent(event->Id(), active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KTestEventNum + 1 - 5); + + // Check changes + TEST(!changeObs->HaveChanges()); + + // Check view navigation + i=0; + res = view->FirstL(active->iStatus); + TEST(res); + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + RDebug::Print(_L("View Entry[%d]: Id: %d\n"), i++, view->Event().Id()); + } + while(view->NextL(active->iStatus)); + RDebug::Print(_L("==\n")); + TEST2(i, count); + res = view->FirstL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Add a new event again that shouldn't appear in the view + changeObs->StartCollectingChanges(); + event->SetContact(TLogContactItemId(0)); + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KTestEventNum + 1 - 5); + TEST(event->Id() == KTestEventNum + 2); + + // Check changes + TEST(!changeObs->HaveChanges()); + + // Check view navigation + i=0; + res = view->FirstL(active->iStatus); + TEST(res); + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + RDebug::Print(_L("View Entry[%d]: Id: %d\n"), i++, view->Event().Id()); + } + while(view->NextL(active->iStatus)); + RDebug::Print(_L("==\n")); + TEST2(i, count); + res = view->FirstL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Change event so that it appears in the view + changeObs->StartCollectingChanges(); + event->SetContact(KTestContact); + active->StartL(); + aClient.ChangeEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KTestEventNum + 2 - 5); + TEST(event->Id() == KTestEventNum + 2); // Shouldn't change + + // Check changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventAdded); + TEST(logId == KTestEventNum + 2); + TEST2(viewIndex, 0); + + // Check view navigation + i=0; + res = view->FirstL(active->iStatus); + TEST(res); + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + RDebug::Print(_L("View Entry[%d]: Id: %d\n"), i++, view->Event().Id()); + } + while(view->NextL(active->iStatus)); + RDebug::Print(_L("==\n")); + TEST2(i, count); + res = view->FirstL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Simply change an event in the view + changeObs->StartCollectingChanges(); + event->SetDescription(_L("Test")); + active->StartL(); + aClient.ChangeEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KTestEventNum + 2 - 5); // Shouldn't change + TEST(event->Id() == KTestEventNum + 2); // Shouldn't change + + // Check changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventChanged); + TEST(logId == KTestEventNum + 2); + TEST2(viewIndex, 0); + + // Change an event in the view so that it is deleted + changeObs->StartCollectingChanges(); + event->SetContact(0); + active->StartL(); + aClient.ChangeEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KTestEventNum + 2 - 5 - 1); // one less now + + // Check changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventDeleted); + TEST(logId == KTestEventNum + 2); + TEST2(viewIndex, 0); + + // Navigate part way through the view so we have + // a cursor position part way through... + i=0; + count = view->CountL(); + res = view->FirstL(active->iStatus); + TEST(res); + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + RDebug::Print(_L("View Entry[%d]: Id: %d\n"), i++, view->Event().Id()); + } + while(view->NextL(active->iStatus)); + RDebug::Print(_L("==\n")); + TEST2(i, count); + TEST(view->Event().Id() == TLogId(0)); + + // Save id + TLogId savedId = view->Event().Id(); + + // Go one back + res = view->PreviousL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Insert something + changeObs->StartCollectingChanges(); + event->SetContact(KTestContact); + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KTestEventNum + 2 - 5); // one more now + TEST(event->Id() == KTestEventNum + 3); + + // Check changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST(type == ELogChangeTypeEventAdded); + TEST(logId == KTestEventNum + 3); + TEST2(viewIndex, 0); + + // Check we can still go forward to the last record + res = view->NextL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), savedId); + + // Go one back + res = view->PreviousL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Delete current record + savedId = view->Event().Id(); + changeObs->StartCollectingChanges(); + active->StartL(); + aClient.DeleteEvent(savedId, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KTestEventNum + 2 - 5 - 1); // one less + + // Check changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventDeleted); + TEST2(logId, savedId); + TEST(viewIndex == KTestEventNum + 2 - 5 - 2); // last but one event + + // Check we're now at the end of the view + res = view->NextL(active->iStatus); + TEST(!res); + + // Go to the first record + res = view->FirstL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Delete the first record + savedId = view->Event().Id(); + changeObs->StartCollectingChanges(); + active->StartL(); + aClient.DeleteEvent(savedId, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KTestEventNum - 5); + + // Check changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventDeleted); + TEST2(logId, savedId); + TEST2(viewIndex, 0); // first item + + // Check 'next' navigation can be performed correctly + count = 0; + view->NextL(active->iStatus); + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + ++count; + } + while(view->NextL(active->iStatus)); + TEST(count == KTestEventNum - 5 - 1); + + // Check last record + savedId = view->Event().Id(); + res = view->LastL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST(savedId == view->Event().Id()); + + // Delete the last record + savedId = view->Event().Id(); + changeObs->StartCollectingChanges(); + active->StartL(); + aClient.DeleteEvent(savedId, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KTestEventNum - 6); + + // Check changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventDeleted); + TEST2(logId, savedId); + TEST2(viewIndex, count); // There's now one less item, and we deleted the last item of the previous view + + // Check we're still at the end of the view + res = view->NextL(active->iStatus); + TEST(!res); + + CleanupStack::PopAndDestroy(5, event); // view, changeObs, active, filter, event + } + +CBaBackupSessionWrapper* theBackup = NULL; + +LOCAL_C TBool IsLogOpenL() + { + return TestUtils::IsDatabaseOpenL(); + } + +LOCAL_C void TestLogOpenL() + { + test(IsLogOpenL()); + } + +LOCAL_C void TestLogClosedL() + { + test(!IsLogOpenL()); + } + +LOCAL_C void StartBackupL() + { + User::InfoPrint(_L("Backup")); + + TDriveUnit driveUnit(EDriveC); + TDriveName name = driveUnit.Name(); + + TParse parse; + LEAVE_IF_ERROR(parse.Set(KLogDatabaseName, &name, NULL)); + + delete theBackup; + theBackup = NULL; + theBackup = CBaBackupSessionWrapper::NewL(); + + theBackup->CloseFileL(parse.FullName(), MBackupObserver::EReleaseLockNoAccess); + User::After(1000000); + } + +LOCAL_C void EndBackupL() + { + delete theBackup; + theBackup = NULL; + User::After(1000000); + } + +LOCAL_C void DelayL(TInt aDelay) + { + CTestTimer* timer = CTestTimer::NewL(); + timer->After(aDelay); + CActiveScheduler::Start(); + delete timer; + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0869 +@SYMTestCaseDesc Tests for CLogViewChangeObserver::HaveChanges(),CLogViewChangeObserver::Changes() functions +@SYMTestPriority High +@SYMTestActions Check for observing changes while adding,deleting events.Check for observing changes after a backup. + Check for navigating the view.Test for KErrNone condition. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestViewChangeEvents1aL(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0869 ")); + TestUtils::DeleteDatabaseL(); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + filter->SetContact(KTestContact); + filter->SetEventType(KLogPacketDataEventTypeUid); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogViewChangeObserver* changeObs = CLogViewChangeObserver::NewLC(); + changeObs->SetActive(); + + CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs); + CleanupStack::PushL(view); + + // Incoming + TBuf buf; + aClient.GetString(buf, R_LOG_DIR_IN); + + event->SetEventType(KLogPacketDataEventTypeUid); + event->SetDirection(buf); + event->SetContact(KTestContact); + + TInt i; + TInt count; + for(count = 0; count < KTestEventNum; count++) + { + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + User::After(1 * 1000000); + } + // + test(view->CountL() == 0); + active->StartL(); + test(view->SetFilterL(*filter, active->iStatus)); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->CountL() == KTestEventNum); + // + count = KTestEventNum; + test(view->FirstL(active->iStatus)); + do { + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + // + test(view->CountL() == KTestEventNum); + const TLogId eventId = view->Event().Id(); + test(eventId == (TLogId)--count); + } + while(view->NextL(active->iStatus)); + + // Transients + TInt changeCount; + TLogId logId; + TInt viewIndex; + TLogDatabaseChangeType type; + CLogChangeDefinition* changes; + + // Add an event and check for changes + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + changes = changeObs->WaitForChangesLC(); + if (active->IsActive()) + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KTestEventNum+1); + + changeCount = changes->Count(); + for(i=0; iAt(i, logId, viewIndex); + RDebug::Print(_L("Change Type: %d, logId: %d, viewIndex: %d"), type, logId, viewIndex); + } + + // Check the change was as expected + test(changes->Count() == 1); + type = changes->At(0, logId, viewIndex); + test(type == ELogChangeTypeEventAdded); + test(viewIndex == 0); // first (newest) event in the view + { + const TLogId expectedLogId = ((TLogId) KTestEventNum); + test(logId == expectedLogId); + } + CleanupStack::PopAndDestroy(changes); + + // Check view navigation + i=0; + test(view->FirstL(active->iStatus)); + do + { + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + RDebug::Print(_L("View Entry[%d]: Id: %d"), i++, view->Event().Id()); + } + while(view->NextL(active->iStatus)); + RDebug::Print(_L("==\n")); + test(i == count); + test(view->FirstL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + + // Check that changes work after a backup + DelayL(1000000); + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + // Delete some events + test(KTestEventNum >= 10); + changeObs->StartCollectingChanges(); + for(i=1; iStartL(); + aClient.DeleteEvent(TLogId(i), active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + } + + // Check changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 5); // 1,3,5,7,9 + for(i=0; iChanges().At(i, logId, viewIndex) == ELogChangeTypeEventDeleted); + test(logId == TLogId(2*i + 1)); + test(viewIndex == 10 - ((2*i) + 1)); + } + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + // Add a new event that shouldn't appear in the view + changeObs->StartCollectingChanges(); + event->SetContact(TLogContactItemId(0)); + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KTestEventNum + 1 - 5); + test(event->Id() == KTestEventNum + 1); + + // Check changes + test(!changeObs->HaveChanges()); + + // Check view navigation + i=0; + test(view->FirstL(active->iStatus)); + do + { + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + RDebug::Print(_L("View Entry[%d]: Id: %d"), i++, view->Event().Id()); + } + while(view->NextL(active->iStatus)); + RDebug::Print(_L("==\n")); + test(i == count); + test(view->FirstL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + // Delete event which isn't in view + changeObs->StartCollectingChanges(); + active->StartL(); + aClient.DeleteEvent(event->Id(), active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KTestEventNum + 1 - 5); + + // Check changes + test(!changeObs->HaveChanges()); + + // Check view navigation + i=0; + test(view->FirstL(active->iStatus)); + do + { + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + RDebug::Print(_L("View Entry[%d]: Id: %d"), i++, view->Event().Id()); + } + while(view->NextL(active->iStatus)); + RDebug::Print(_L("==\n")); + test(i == count); + test(view->FirstL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + // Add a new event again that shouldn't appear in the view + changeObs->StartCollectingChanges(); + event->SetContact(TLogContactItemId(0)); + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KTestEventNum + 1 - 5); + test(event->Id() == KTestEventNum + 2); + + // Check changes + test(!changeObs->HaveChanges()); + + // Check view navigation + i=0; + test(view->FirstL(active->iStatus)); + do + { + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + RDebug::Print(_L("View Entry[%d]: Id: %d"), i++, view->Event().Id()); + } + while(view->NextL(active->iStatus)); + RDebug::Print(_L("==\n")); + test(i == count); + test(view->FirstL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + // Change event so that it appears in the view + changeObs->StartCollectingChanges(); + event->SetContact(KTestContact); + active->StartL(); + aClient.ChangeEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KTestEventNum + 2 - 5); + test(event->Id() == KTestEventNum + 2); // Shouldn't change + + // Check changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventAdded); + test(logId == KTestEventNum + 2); + test(viewIndex == 0); + + // Check view navigation + i=0; + test(view->FirstL(active->iStatus)); + do + { + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + RDebug::Print(_L("View Entry[%d]: Id: %d"), i++, view->Event().Id()); + } + while(view->NextL(active->iStatus)); + RDebug::Print(_L("==\n")); + test(i == count); + test(view->FirstL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + // Simply change an event in the view + changeObs->StartCollectingChanges(); + event->SetDescription(_L("Test")); + active->StartL(); + aClient.ChangeEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KTestEventNum + 2 - 5); // Shouldn't change + test(event->Id() == KTestEventNum + 2); // Shouldn't change + + // Check changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventChanged); + test(logId == KTestEventNum + 2); + test(viewIndex == 0); + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + // Change an event in the view so that it is deleted + changeObs->StartCollectingChanges(); + event->SetContact(0); + active->StartL(); + aClient.ChangeEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KTestEventNum + 2 - 5 - 1); // one less now + + // Check changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventDeleted); + test(logId == KTestEventNum + 2); + test(viewIndex == 0); + + // Navigate part way through the view so we have + // a cursor position part way through... + i=0; + count = view->CountL(); + test(view->FirstL(active->iStatus)); + do + { + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + RDebug::Print(_L("View Entry[%d]: Id: %d"), i++, view->Event().Id()); + } + while(view->NextL(active->iStatus)); + RDebug::Print(_L("==\n")); + test(i == count); + test(view->Event().Id() == TLogId(0)); + + // Save id + TLogId savedId = view->Event().Id(); + + // Go one back + test(view->PreviousL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + // Insert something + changeObs->StartCollectingChanges(); + event->SetContact(KTestContact); + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KTestEventNum + 2 - 5); // one more now + test(event->Id() == KTestEventNum + 3); + + // Check changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventAdded); + test(logId == KTestEventNum + 3); + test(viewIndex == 0); + + // Check we can still go forward to the last record + test(view->NextL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == savedId); + + // Go one back + test(view->PreviousL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + // Delete current record + savedId = view->Event().Id(); + changeObs->StartCollectingChanges(); + active->StartL(); + aClient.DeleteEvent(savedId, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KTestEventNum + 2 - 5 - 1); // one less + + // Check changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventDeleted); + test(logId == savedId); + test(viewIndex == KTestEventNum + 2 - 5 - 2); // last but one event + + // Check we're now at the end of the view + test(!view->NextL(active->iStatus)); + + // Go to the first record + test(view->FirstL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + // Delete the first record + savedId = view->Event().Id(); + changeObs->StartCollectingChanges(); + active->StartL(); + aClient.DeleteEvent(savedId, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KTestEventNum - 5); + + // Check changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventDeleted); + test(logId == savedId); + test(viewIndex == 0); // first item + + // Check 'next' navigation can be performed correctly + count = 0; + view->NextL(active->iStatus); + do + { + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + ++count; + } + while(view->NextL(active->iStatus)); + test(count == KTestEventNum - 5 - 1); + + // Check last record + savedId = view->Event().Id(); + test(view->LastL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(savedId == view->Event().Id()); + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + // Delete the last record + savedId = view->Event().Id(); + changeObs->StartCollectingChanges(); + active->StartL(); + aClient.DeleteEvent(savedId, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KTestEventNum - 6); + + // Check changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventDeleted); + test(logId == savedId); + test(viewIndex == count); // There's now one less item, and we deleted the last item of the previous view + + // Check we're still at the end of the view + test(!view->NextL(active->iStatus)); + + CleanupStack::PopAndDestroy(5, event); // view, changeObs, active, filter, event + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0870 +@SYMTestCaseDesc Tests for CLogViewChangeObserver::HaveChanges(),Changes() functions +@SYMTestPriority High +@SYMTestActions Check for observing changes while adding,deleting events.Check for observing changes after a backup. + Check for observing changes while traversing through the events in the view. + Delete everything in the view and make sure we can't navigate anymore. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestViewChangeEvents2L(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0870 ")); + // Transients + TInt i=0; + TInt count; + TBuf<1> description; description.SetLength(1); + TInt changeCount; + TLogId logId; + TInt viewIndex; + TLogDatabaseChangeType type; + TLogId runningNewId = 0; + // + const TInt KChangeEventTest2NumberOfEventsInView = 7; + TestUtils::DeleteDatabaseL(); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + filter->SetContact(KTestContact); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogViewChangeObserver* changeObs = CLogViewChangeObserver::NewLC(); + changeObs->SetActive(); + + CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs); + CleanupStack::PushL(view); + + // Add seed events + TBuf buf; + aClient.GetString(buf, R_LOG_DIR_IN); + + event->SetEventType(KLogPacketDataEventTypeUid); + event->SetDirection(buf); + // + for(count = 0; count < KChangeEventTest2NumberOfEventsInView; count++) + { + // Have to create one event which isn't in the view by default, but + // when it 'appears' will be part way through + if (count == 3 && description[0] != TUint16('Z')) + { + description[0] = TUint16('Z'); + event->SetContact(0); + + // Go back and do this one again but with a real view entry this time, i.e. 'D' + --count; + } + else + { + description[0] = TUint16('A' + KChangeEventTest2NumberOfEventsInView - count); + event->SetContact(KTestContact); + } + event->SetDescription(description); + // + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST(event->Id() == runningNewId++); + User::After(1 * 1000000); + } + // + TEST2(view->CountL(), 0); + active->StartL(); + TBool res =view->SetFilterL(*filter, active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST2(count, KChangeEventTest2NumberOfEventsInView); + + res = view->FirstL(active->iStatus); + TEST(res); + do + { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + RDebug::Print(_L("View Entry[%d]: Id: %d\n"), i++, view->Event().Id()); + } + while(view->NextL(active->iStatus)); + + // Check addition change events + res = view->FirstL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); // [7], 6, 5, 4, 2, 1, 0 + TEST2(view->Event().Id(), 7); + + // Add a new entry - should appear as the first item in the view + description[0] = TUint16('X'); + event->SetDescription(description); + // + changeObs->StartCollectingChanges(); + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST(event->Id() == runningNewId++); + + // Check changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventAdded); + TEST(logId == runningNewId-1); + TEST2(viewIndex, 0); // 8, [7], 6, 5, 4, 2, 1, 0 + + // Check we can go forward + res = view->NextL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(6)); // 8, 7, [6], 5, 4, 2, 1, 0 + + // Check we can now go back (new first entry) + res = view->PreviousL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); // 8, [7], 6, 5, 4, 2, 1, 0 + TEST2(view->Event().Id(), 7); + res = view->PreviousL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); // [8], 7, 6, 5, 4, 2, 1, 0 + TEST(view->Event().Id() == TLogId(KChangeEventTest2NumberOfEventsInView+1)); + + // Delete added event + changeObs->ResetChanges(); + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 0); + active->StartL(); + aClient.DeleteEvent(view->Event().Id(), active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); // [7], 6, 5, 4, 2, 1, 0 + + // Check deletion changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventDeleted); + TEST(logId == runningNewId-1); + TEST2(viewIndex, 0); + + // Go to end of view + res = view->LastL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST(view->Event().Id() == TLogId(0)); // 7, 6, 5, 4, 2, 1, [0] + + // Add new event + description[0] = TUint16('X'); + event->SetDescription(description); + // + changeObs->StartCollectingChanges(); + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST(event->Id() == runningNewId++); + + // Check changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventAdded); + TEST(logId == runningNewId-1); + TEST2(viewIndex, 0); // 9, 7, 6, 5, 4, 2, 1, [0] + + // Check we can't go forward + res = view->NextL(active->iStatus); + TEST(!res); + + // Go back to the first record + res = view->FirstL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST(view->Event().Id() == TLogId(runningNewId-1)); // 9, 7, 6, 5, 4, 2, 1, [0] + + // Delete added event + changeObs->ResetChanges(); + active->StartL(); + aClient.DeleteEvent(view->Event().Id(), active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); // [7], 6, 5, 4, 2, 1, 0 + + // Check deletion changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventDeleted); + TEST(logId == runningNewId-1); + TEST2(viewIndex, 0); + + // Go part way through view + res = view->NextL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(6)); // 7, [6], 5, 4, 2, 1, 0 + res = view->NextL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(5)); // 7, 6, [5], 4, 2, 1, 0 + + // Add new event + description[0] = TUint16('X'); + event->SetDescription(description); + // + changeObs->StartCollectingChanges(); + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST(event->Id() == runningNewId++); + + // Check changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventAdded); + TEST2(logId, runningNewId-1); + TEST2(viewIndex, 0); // 10, 7, 6, [5], 4, 2, 1, 0 + changeObs->ResetChanges(); + + // Work back to beginning + res = view->PreviousL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(6)); // 10, 7, [6], 5, 4, 2, 1, 0 + res = view->PreviousL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(7)); // 10, [7], 6, 5, 4, 2, 1, 0 + res = view->PreviousL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), runningNewId-1); // [10], 7, 6, 5, 4, 2, 1, 0 + + // Delete added event + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 0); + active->StartL(); + aClient.DeleteEvent(view->Event().Id(), active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); // [7], 6, 5, 4, 2, 1, 0 + + // Check deletion changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventDeleted); + TEST2(logId, runningNewId-1); + TEST2(viewIndex, 0); + changeObs->ResetChanges(); + + // Go back to the first record + res = view->FirstL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(7)); // [7], 6, 5, 4, 2, 1, 0 + + // Move one record forward + res = view->NextL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(6)); // 7, [6], 5, 4, 2, 1, 0 + + // Change 'Z' event so that it now appears in the view + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 0); + active->StartL(); + event->SetId(TLogId(3)); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + // + event->SetContact(KTestContact); + active->StartL(); + changeObs->StartCollectingChanges(); + aClient.ChangeEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KChangeEventTest2NumberOfEventsInView+1); + + // Check changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventAdded); // Change resulted in an addition to the view + TEST2(logId, TLogId(3)); + TEST2(viewIndex, 4); // 7, [6], 5, 4, 3, 2, 1, 0 + changeObs->ResetChanges(); + + // Move forwards and check + res = view->NextL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(5)); // 7, 6, [5], 4, 3, 2, 1, 0 + res = view->NextL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(4)); // 7, 6, 5, [4], 3, 2, 1, 0 + res = view->NextL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(3)); // 7, 6, 5, 4, [3], 2, 1, 0 + + // Change 'Z' event so that its now missing from the view again + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 0); + active->StartL(); + event->SetId(TLogId(3)); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + // + event->SetContact(0); + active->StartL(); + changeObs->StartCollectingChanges(); + aClient.ChangeEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST2(count, KChangeEventTest2NumberOfEventsInView); + + // Check changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + TEST2(logId, TLogId(3)); + TEST2(viewIndex, 4); // 7, 6, 5, 4, [2], 1, 0 + changeObs->ResetChanges(); + + // Move forwards and check + res = view->NextL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(1)); // 7, 6, 5, 4, 2, [1], 0 + res = view->NextL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(0)); // 7, 6, 5, 4, 2, 1, [0] + + // Move back one + res = view->PreviousL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(1)); // 7, 6, 5, 4, 2, [1], 0 + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 0); + + // Change 'Z' event so that it now appears in the view + active->StartL(); + event->SetId(TLogId(3)); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + // + event->SetContact(KTestContact); + active->StartL(); + changeObs->StartCollectingChanges(); + aClient.ChangeEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST2(count, KChangeEventTest2NumberOfEventsInView+1); + + // Check changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventAdded); // Change resulted in an addition to the view + TEST2(logId, TLogId(3)); + TEST2(viewIndex, 4); // 7, 6, 5, 4, 3, 2, [1], 0 + changeObs->ResetChanges(); + + // Check can only move forward one more record + res = view->NextL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(0)); // 7, 6, 5, 4, 3, 2, 1, [0] + + // Move back until we are before the inserted record + res = view->PreviousL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(1)); // 7, 6, 5, 4, 3, 2, [1], 0 + res = view->PreviousL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(2)); // 7, 6, 5, 4, 3, [2], 1, 0 + res = view->PreviousL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(3)); // 7, 6, 5, 4, [3], 2, 1, 0 + res = view->PreviousL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(4)); // 7, 6, 5, [4], 3, 2, 1, 0 + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 0); + + // Change 'Z' event so that its now missing from the view again + active->StartL(); + event->SetId(TLogId(3)); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + // + event->SetContact(0); + active->StartL(); + changeObs->StartCollectingChanges(); + aClient.ChangeEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST2(count, KChangeEventTest2NumberOfEventsInView); + + // Check changes + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + TEST2(logId, TLogId(3)); + TEST2(viewIndex, 4); // 7, 6, 5, [4], 2, 1, 0 + changeObs->ResetChanges(); + + // Check navigating to the end of the view + res = view->NextL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(2)); // 7, 6, 5, 4, [2], 1, 0 + res = view->NextL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(1)); // 7, 6, 5, 4, 2, [1], 0 + res = view->NextL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(0)); // 7, 6, 5, 4, 2, 1, [0] + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 0); + res = view->NextL(active->iStatus); + TEST(!res); + + // Delete everything in the view and make sure we can't navigate anymore. + active->StartL(); + aClient.DeleteEvent(TLogId(4), active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KChangeEventTest2NumberOfEventsInView - 1); + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + TEST2(logId, TLogId(4)); + TEST2(viewIndex, 3); // 7, 6, 5, 2, 1, [0] + changeObs->ResetChanges(); + // + active->StartL(); + aClient.DeleteEvent(TLogId(7), active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KChangeEventTest2NumberOfEventsInView - 2); + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + TEST2(logId, TLogId(7)); + TEST2(viewIndex, 0); // 6, 5, 2, 1, [0] + changeObs->ResetChanges(); + // + active->StartL(); + aClient.DeleteEvent(TLogId(0), active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KChangeEventTest2NumberOfEventsInView - 3); + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + TEST2(logId, TLogId(0)); + TEST2(viewIndex, 4); // 6, 5, 2, [1] + changeObs->ResetChanges(); + // + active->StartL(); + aClient.DeleteEvent(TLogId(5), active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KChangeEventTest2NumberOfEventsInView - 4); + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + TEST2(logId, TLogId(5)); + TEST2(viewIndex, 1); // 6, 2, [1] + changeObs->ResetChanges(); + // + active->StartL(); + aClient.DeleteEvent(TLogId(2), active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KChangeEventTest2NumberOfEventsInView - 5); + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + TEST2(logId, TLogId(2)); + TEST2(viewIndex, 1); // 6, [1] + changeObs->ResetChanges(); + // + active->StartL(); + aClient.DeleteEvent(TLogId(6), active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KChangeEventTest2NumberOfEventsInView - 6); + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + TEST2(logId, TLogId(6)); + TEST2(viewIndex, 0); // [1] + changeObs->ResetChanges(); + + // Check we can't go backwards or forwards + res = view->NextL(active->iStatus); + TEST(!res); + res = view->PreviousL(active->iStatus); + TEST(!res); + res = view->FirstL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(1)); // [1] + res = view->LastL(active->iStatus); + TEST(res); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->Event().Id(), TLogId(1)); // [1] + + // Delete last event in view + active->StartL(); + aClient.DeleteEvent(TLogId(1), active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST(count == KChangeEventTest2NumberOfEventsInView - 7); + changeCount = changeObs->Changes().Count(); + TEST2(changeCount, 1); + type = changeObs->Changes().At(0, logId, viewIndex); + TEST2(type, ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + TEST2(logId, TLogId(1)); + TEST2(viewIndex, 0); // *Empty* + changeObs->ResetChanges(); + + // Check we can't navigate + res = view->NextL(active->iStatus); + TEST(!res); + res = view->PreviousL(active->iStatus); + TEST(!res); + res = view->FirstL(active->iStatus); + TEST(!res); + res = view->LastL(active->iStatus); + TEST(!res); + + CleanupStack::PopAndDestroy(5, event); // view, changeObs, active, filter, event + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0871 +@SYMTestCaseDesc Tests for CLogViewChangeObserver::HaveChanges(),Changes() functions +@SYMTestPriority High +@SYMTestActions Check for observing changes while adding,deleting events.Check for observing changes after a backup. + Check for observing changes while traversing through the events in the view. + Delete everything in the view and make sure we can't navigate anymore. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestViewChangeEvents2aL(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0871 ")); + // Transients + TInt i=0; + TInt count; + TBuf<1> description; description.SetLength(1); + TInt changeCount; + TLogId logId; + TInt viewIndex; + TLogDatabaseChangeType type; + TLogId runningNewId = 0; + // + const TInt KChangeEventTest2NumberOfEventsInView = 7; + TestUtils::DeleteDatabaseL(); + + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + filter->SetContact(KTestContact); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogViewChangeObserver* changeObs = CLogViewChangeObserver::NewLC(); + changeObs->SetActive(); + + CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs); + CleanupStack::PushL(view); + + // Add seed events + TBuf buf; + aClient.GetString(buf, R_LOG_DIR_IN); + + event->SetEventType(KLogPacketDataEventTypeUid); + event->SetDirection(buf); + // + for(count = 0; count < KChangeEventTest2NumberOfEventsInView; count++) + { + // Have to create one event which isn't in the view by default, but + // when it 'appears' will be part way through + if (count == 3 && description[0] != TUint16('Z')) + { + description[0] = TUint16('Z'); + event->SetContact(0); + + // Go back and do this one again but with a real view entry this time, i.e. 'D' + --count; + } + else + { + description[0] = TUint16('A' + KChangeEventTest2NumberOfEventsInView - count); + event->SetContact(KTestContact); + } + event->SetDescription(description); + // + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(event->Id() == runningNewId++); + User::After(1 * 1000000); + } + // + test(view->CountL() == 0); + active->StartL(); + test(view->SetFilterL(*filter, active->iStatus)); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KChangeEventTest2NumberOfEventsInView); + + + test(view->FirstL(active->iStatus)); + do + { + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + RDebug::Print(_L("View Entry[%d]: Id: %d"), i++, view->Event().Id()); + } + while(view->NextL(active->iStatus)); + + // Check addition change events + test(view->FirstL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); // [7], 6, 5, 4, 2, 1, 0 + test(view->Event().Id() == 7); + + // Add a new entry - should appear as the first item in the view + description[0] = TUint16('X'); + event->SetDescription(description); + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + // + changeObs->StartCollectingChanges(); + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(event->Id() == runningNewId++); + + // Check changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventAdded); + test(logId == runningNewId-1); + test(viewIndex == 0); // 8, [7], 6, 5, 4, 2, 1, 0 + + // Check we can go forward + test(view->NextL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(6)); // 8, 7, [6], 5, 4, 2, 1, 0 + + // Check we can now go back (new first entry) + test(view->PreviousL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); // 8, [7], 6, 5, 4, 2, 1, 0 + test(view->Event().Id() == 7); + test(view->PreviousL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); // [8], 7, 6, 5, 4, 2, 1, 0 + test(view->Event().Id() == TLogId(KChangeEventTest2NumberOfEventsInView+1)); + + // Delete added event + changeObs->ResetChanges(); + changeCount = changeObs->Changes().Count(); + test(changeCount == 0); + active->StartL(); + aClient.DeleteEvent(view->Event().Id(), active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); // [7], 6, 5, 4, 2, 1, 0 + + // Check deletion changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventDeleted); + test(logId == runningNewId-1); + test(viewIndex == 0); + + // Go to end of view + test(view->LastL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(0)); // 7, 6, 5, 4, 2, 1, [0] + + // Add new event + description[0] = TUint16('X'); + event->SetDescription(description); + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + // + changeObs->StartCollectingChanges(); + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(event->Id() == runningNewId++); + + // Check changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventAdded); + test(logId == runningNewId-1); + test(viewIndex == 0); // 9, 7, 6, 5, 4, 2, 1, [0] + + // Check we can't go forward + test(!view->NextL(active->iStatus)); + + // Go back to the first record + test(view->FirstL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(runningNewId-1)); // 9, 7, 6, 5, 4, 2, 1, [0] + + // Delete added event + changeObs->ResetChanges(); + active->StartL(); + aClient.DeleteEvent(view->Event().Id(), active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); // [7], 6, 5, 4, 2, 1, 0 + + // Check deletion changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventDeleted); + test(logId == runningNewId-1); + test(viewIndex == 0); + + // Go part way through view + test(view->NextL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(6)); // 7, [6], 5, 4, 2, 1, 0 + test(view->NextL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(5)); // 7, 6, [5], 4, 2, 1, 0 + + // Add new event + description[0] = TUint16('X'); + event->SetDescription(description); + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + // + changeObs->StartCollectingChanges(); + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(event->Id() == runningNewId++); + + // Check changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventAdded); + test(logId == runningNewId-1); + test(viewIndex == 0); // 10, 7, 6, [5], 4, 2, 1, 0 + changeObs->ResetChanges(); + + // Work back to beginning + test(view->PreviousL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(6)); // 10, 7, [6], 5, 4, 2, 1, 0 + test(view->PreviousL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(7)); // 10, [7], 6, 5, 4, 2, 1, 0 + test(view->PreviousL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == runningNewId-1); // [10], 7, 6, 5, 4, 2, 1, 0 + + // Delete added event + changeCount = changeObs->Changes().Count(); + test(changeCount == 0); + active->StartL(); + aClient.DeleteEvent(view->Event().Id(), active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); // [7], 6, 5, 4, 2, 1, 0 + + // Check deletion changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventDeleted); + test(logId == runningNewId-1); + test(viewIndex == 0); + changeObs->ResetChanges(); + + // Go back to the first record + test(view->FirstL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(7)); // [7], 6, 5, 4, 2, 1, 0 + + // Move one record forward + test(view->NextL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(6)); // 7, [6], 5, 4, 2, 1, 0 + + // Change 'Z' event so that it now appears in the view + changeCount = changeObs->Changes().Count(); + test(changeCount == 0); + active->StartL(); + event->SetId(TLogId(3)); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + // + event->SetContact(KTestContact); + active->StartL(); + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + changeObs->StartCollectingChanges(); + aClient.ChangeEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KChangeEventTest2NumberOfEventsInView+1); + + // Check changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventAdded); // Change resulted in an addition to the view + test(logId == TLogId(3)); + test(viewIndex == 4); // 7, [6], 5, 4, 3, 2, 1, 0 + changeObs->ResetChanges(); + + // Move forwards and check + test(view->NextL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(5)); // 7, 6, [5], 4, 3, 2, 1, 0 + test(view->NextL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(4)); // 7, 6, 5, [4], 3, 2, 1, 0 + test(view->NextL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(3)); // 7, 6, 5, 4, [3], 2, 1, 0 + + // Change 'Z' event so that its now missing from the view again + changeCount = changeObs->Changes().Count(); + test(changeCount == 0); + active->StartL(); + event->SetId(TLogId(3)); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + // + event->SetContact(0); + active->StartL(); + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + changeObs->StartCollectingChanges(); + aClient.ChangeEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KChangeEventTest2NumberOfEventsInView); + + // Check changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + test(logId == TLogId(3)); + test(viewIndex == 4); // 7, 6, 5, 4, [2], 1, 0 + changeObs->ResetChanges(); + + // Move forwards and check + test(view->NextL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(1)); // 7, 6, 5, 4, 2, [1], 0 + test(view->NextL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(0)); // 7, 6, 5, 4, 2, 1, [0] + + // Move back one + test(view->PreviousL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(1)); // 7, 6, 5, 4, 2, [1], 0 + changeCount = changeObs->Changes().Count(); + test(changeCount == 0); + + // Change 'Z' event so that it now appears in the view + active->StartL(); + event->SetId(TLogId(3)); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + // + event->SetContact(KTestContact); + active->StartL(); + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + changeObs->StartCollectingChanges(); + aClient.ChangeEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KChangeEventTest2NumberOfEventsInView+1); + + // Check changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventAdded); // Change resulted in an addition to the view + test(logId == TLogId(3)); + test(viewIndex == 4); // 7, 6, 5, 4, 3, 2, [1], 0 + changeObs->ResetChanges(); + + // Check can only move forward one more record + test(view->NextL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(0)); // 7, 6, 5, 4, 3, 2, 1, [0] + + // Move back until we are before the inserted record + test(view->PreviousL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(1)); // 7, 6, 5, 4, 3, 2, [1], 0 + test(view->PreviousL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(2)); // 7, 6, 5, 4, 3, [2], 1, 0 + test(view->PreviousL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(3)); // 7, 6, 5, 4, [3], 2, 1, 0 + test(view->PreviousL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(4)); // 7, 6, 5, [4], 3, 2, 1, 0 + changeCount = changeObs->Changes().Count(); + test(changeCount == 0); + + // Change 'Z' event so that its now missing from the view again + active->StartL(); + event->SetId(TLogId(3)); + aClient.GetEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + // + event->SetContact(0); + active->StartL(); + + // Check that changes work after a backup + StartBackupL(); + DelayL(1000000); + TestLogClosedL(); + EndBackupL(); + TestLogOpenL(); + + changeObs->StartCollectingChanges(); + aClient.ChangeEvent(*event, active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KChangeEventTest2NumberOfEventsInView); + + // Check changes + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + test(logId == TLogId(3)); + test(viewIndex == 4); // 7, 6, 5, [4], 2, 1, 0 + changeObs->ResetChanges(); + + // Check navigating to the end of the view + test(view->NextL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(2)); // 7, 6, 5, 4, [2], 1, 0 + test(view->NextL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(1)); // 7, 6, 5, 4, 2, [1], 0 + test(view->NextL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(0)); // 7, 6, 5, 4, 2, 1, [0] + changeCount = changeObs->Changes().Count(); + test(changeCount == 0); + test(!view->NextL(active->iStatus)); + + // Delete everything in the view and make sure we can't navigate anymore. + active->StartL(); + aClient.DeleteEvent(TLogId(4), active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KChangeEventTest2NumberOfEventsInView - 1); + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + test(logId == TLogId(4)); + test(viewIndex == 3); // 7, 6, 5, 2, 1, [0] + changeObs->ResetChanges(); + // + active->StartL(); + aClient.DeleteEvent(TLogId(7), active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KChangeEventTest2NumberOfEventsInView - 2); + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + test(logId == TLogId(7)); + test(viewIndex == 0); // 6, 5, 2, 1, [0] + changeObs->ResetChanges(); + // + active->StartL(); + aClient.DeleteEvent(TLogId(0), active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KChangeEventTest2NumberOfEventsInView - 3); + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + test(logId == TLogId(0)); + test(viewIndex == 4); // 6, 5, 2, [1] + changeObs->ResetChanges(); + // + active->StartL(); + aClient.DeleteEvent(TLogId(5), active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KChangeEventTest2NumberOfEventsInView - 4); + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + test(logId == TLogId(5)); + test(viewIndex == 1); // 6, 2, [1] + changeObs->ResetChanges(); + // + active->StartL(); + aClient.DeleteEvent(TLogId(2), active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KChangeEventTest2NumberOfEventsInView - 5); + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + test(logId == TLogId(2)); + test(viewIndex == 1); // 6, [1] + changeObs->ResetChanges(); + // + active->StartL(); + aClient.DeleteEvent(TLogId(6), active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KChangeEventTest2NumberOfEventsInView - 6); + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + test(logId == TLogId(6)); + test(viewIndex == 0); // [1] + changeObs->ResetChanges(); + + // Check we can't go backwards or forwards + test(!view->NextL(active->iStatus)); + test(!view->PreviousL(active->iStatus)); + test(view->FirstL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(1)); // [1] + test(view->LastL(active->iStatus)); + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + test(view->Event().Id() == TLogId(1)); // [1] + + // Delete last event in view + active->StartL(); + aClient.DeleteEvent(TLogId(1), active->iStatus); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone); + count = view->CountL(); + test(count == KChangeEventTest2NumberOfEventsInView - 7); + changeCount = changeObs->Changes().Count(); + test(changeCount == 1); + type = changeObs->Changes().At(0, logId, viewIndex); + test(type == ELogChangeTypeEventDeleted); // Change resulted in a removal from the view + test(logId == TLogId(1)); + test(viewIndex == 0); // *Empty* + changeObs->ResetChanges(); + + // Check we can't navigate + test(!view->NextL(active->iStatus)); + test(!view->PreviousL(active->iStatus)); + test(!view->FirstL(active->iStatus)); + test(!view->LastL(active->iStatus)); + + CleanupStack::PopAndDestroy(5, event); // view, changeObs, active, filter, event + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0872 +@SYMTestCaseDesc Filtering log view test +@SYMTestPriority High +@SYMTestActions Add the Voice call,FAX,SMS event types to the log client. + Set all the event types to filter list.Check for the correct event types and no errors +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestViewFilteringDefect1L(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0872 ")); + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + CTestActive* active = new(ELeave) CTestActive(); + CleanupStack::PushL(active); + + // VOICE CALL + event->SetEventType(KLogCallEventTypeUid); + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + const TLogId event1 = event->Id(); + + // FAX + event->SetEventType(KLogFaxEventTypeUid); + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + const TLogId event2 = event->Id(); + (void) event2; + + // SMS, CONTACT SEARCHED + event->SetEventType(KLogShortMessageEventTypeUid); + event->SetFlags(KLogEventContactSearched); + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + const TLogId event3 = event->Id(); + + CLogViewChangeObserver* changeObs = CLogViewChangeObserver::NewLC(); + changeObs->SetActive(); + + CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs); + CleanupStack::PushL(view); + + CLogFilterList* filterList = new(ELeave) CLogFilterList(); + CleanupStack::PushL(filterList); + + CLogFilter* filter1 = CLogFilter::NewL(); + CleanupStack::PushL(filter1); + filter1->SetEventType(KLogCallEventTypeUid); // ALL VOICE CALL EVENTS + filterList->AppendL(filter1); + + CLogFilter* filter2 = CLogFilter::NewL(); + CleanupStack::PushL(filter2); + filter2->SetEventType(KLogShortMessageEventTypeUid); // ALL SMS's WHERE CONTACTS SEARCH FLAG IS SET + filter2->SetFlags(KLogEventContactSearched); + filterList->AppendL(filter2); + + TInt count = view->CountL(); + TEST2(count, 0); + TBool res = view->SetFilterParseFilterByFilterL(*filterList, active->iStatus); + TEST(res); + CleanupStack::PopAndDestroy(3, filterList); + + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + count = view->CountL(); + TEST2(count, 2); + + // Check correct events + TLogId eventId; + // + active->StartL(); + res = view->FirstL(active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + eventId = view->Event().Id(); + TEST2(eventId, event3); + // + active->StartL(); + res = view->NextL(active->iStatus); + TEST(res); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + eventId = view->Event().Id(); + TEST2(eventId, event1); + + CleanupStack::PopAndDestroy(4, event); + } + +// +// +// +static TInt TestDeletingViewWithinObserverCallbackL_CallbackFn(TAny* aView) + { + CLogViewEvent* view = reinterpret_cast(aView); + delete view; + return KErrNone; + } + +// +// +// +static void TestDeletingViewWithinObserverCallbackL_ThreadFunctionL() + { + RFs fsSession; + LEAVE_IF_ERROR(fsSession.Connect()); + CleanupClosePushL(fsSession); + // + CLogClient* client = CLogClient::NewL(fsSession); + CleanupStack::PushL(client); + // + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + event->SetEventType(KLogCallEventTypeUid); + // + CTestActive* active = new(ELeave) CTestActive(); + CleanupStack::PushL(active); + + // Wait for main test code thread + RSemaphore semaphore; + const TInt error = semaphore.OpenGlobal(KThreadSemaphoreName); + LEAVE_IF_ERROR(error); + + // Add 5 recent events to the list + TBuf incoming; + client->GetString(incoming, R_LOG_DIR_IN); + event->SetDirection(incoming); + + // Incoming + for(TInt recent = 1; recent <= 5; recent++) + { + event->SetContact(recent); + for(TInt duplicate = 1; duplicate <= 6; duplicate++) + { + active->StartL(); + client->AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + __ASSERT_ALWAYS(active->iStatus == KErrNone, User::Panic(_L("ThreadPanic"), 1)); + } + } + + // Wait now until the main thread says we can delete all events + semaphore.Signal(); + User::After(5 * 1000000); + semaphore.Wait(); + + // Clear the duplicates which should result in a batch of changes + // in the other thread + CLogViewRecent* view = CLogViewRecent::NewL(*client); + CleanupStack::PushL(view); + // + __ASSERT_ALWAYS(view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus), User::Panic(_L("ThreadPanic"), 2)); + __ASSERT_ALWAYS(view->CountL() == 5, User::Panic(_L("ThreadPanic"), 3)); + active->StartL(); + CActiveScheduler::Start(); + __ASSERT_ALWAYS(active->iStatus == KErrNone, User::Panic(_L("ThreadPanic"), 4)); + + // Now do the clear + view->ClearDuplicatesL(); + __ASSERT_ALWAYS(view->CountL() == 5, User::Panic(_L("ThreadPanic"), 5)); + + // Cleanup + CleanupStack::PopAndDestroy(view); + semaphore.Close(); + CleanupStack::PopAndDestroy(4, &fsSession); // active, event, client, fsSession + } + +// +// +// +static TInt TestDeletingViewWithinObserverCallbackL_ThreadFunction(TAny* /*aData*/) + { + CTrapCleanup* cleanup = CTrapCleanup::New(); + if (!cleanup) + return KErrNoMemory; + CActiveScheduler* scheduler = new CActiveScheduler(); + if (!scheduler) + return KErrNoMemory; + CActiveScheduler::Install(scheduler); + // + TRAPD(err, TestDeletingViewWithinObserverCallbackL_ThreadFunctionL()); + UNUSED_VAR(err); + // + delete scheduler; + delete cleanup; + // + return KErrNone; + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-0873 +@SYMTestCaseDesc Tests for observing changes within a callback +@SYMTestPriority High +@SYMTestActions Check for observing changes within a callback +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestDeletingViewWithinObserverCallbackL(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0873 ")); + TestUtils::DeleteDatabaseL(); + + TInt error = 0; + // + CTestActive* active = new(ELeave) CTestActive(); + CleanupStack::PushL(active); + + CLogViewChangeObserver* changeObs = CLogViewChangeObserver::NewLC(); + + CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs); + CleanupStack::PushL(view); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + filter->SetEventType(KLogCallEventTypeUid); + TBool res = view->SetFilterL(*filter, active->iStatus); + TEST(!res); + CleanupStack::PopAndDestroy(filter); + + // Create semaphore so we can control other thread + RSemaphore semaphore; + error = semaphore.CreateGlobal(KThreadSemaphoreName, 0); + LEAVE_IF_ERROR(error); + CleanupClosePushL(semaphore); + + // Create thread which adds two events + RThread thread; + error = thread.Create(_L("T_VIEW1_OBS_EVENT_CREATION_THREAD"), TestDeletingViewWithinObserverCallbackL_ThreadFunction, 10 * 1024, 5 * 1024, 20 * 1024, NULL); + LEAVE_IF_ERROR(error); + CleanupClosePushL(thread); + + // Start the worker thread going + thread.Resume(); + User::After(1 * 100000); + semaphore.Wait(); + + // Wait for changes + CLogChangeDefinition* changes = changeObs->WaitForChangesLC(TCallBack(TestDeletingViewWithinObserverCallbackL_CallbackFn, view), CLogViewChangeObserver::EStopOnChanges); + + // Check the changes + TEST2(changes->Count(), 1); + TEST2(changes->At(0), ELogChangeTypeEventAdded); + + TLogId logId = -1; + TLogDatabaseChangeType dbChangeType = changes->At(0, logId); + TEST2(dbChangeType, ELogChangeTypeEventAdded); + TEST2(logId, 0); + TInt viewIndex = -1; + dbChangeType = changes->At(0, logId, viewIndex); + TEST2(logId, 0); + TEST2(viewIndex, 0); + //Find a change position by the log id + TInt pos = changes->Find(logId); + TEST2(pos, 0); + pos = changes->Find(8125347); + TEST2(pos, KErrNotFound); + //Find a change position by the log id and the change type + pos = changes->Find(logId, dbChangeType); + TEST2(pos, 0); + pos = changes->Find(432837, ELogChangeTypeEventChanged); + TEST2(pos, KErrNotFound); + //Find a view position by the view index + pos = changes->FindByViewIndex(viewIndex); + TEST2(pos, 0); + pos = changes->FindByViewIndex(33939); + TEST2(pos, KErrNotFound); + //Stream out the changes to a buffer + TBuf8<100> strmBuf; + RDesWriteStream strmOut(strmBuf); + changes->ExternalizeL(strmOut); + strmOut.CommitL(); + + CleanupStack::PopAndDestroy(changes); + + //Re-create changes from the buffer + RDesReadStream strmIn(strmBuf); + changes = CLogChangeDefinition::NewL(strmIn); + dbChangeType = changes->At(0, logId); + TEST2(dbChangeType, ELogChangeTypeEventAdded); + TEST2(logId, 0); + delete changes; + + // The view should be deleted... + CleanupStack::PopAndDestroy(&thread); + CleanupStack::PopAndDestroy(&semaphore); + + CleanupStack::Pop(); // view + CleanupStack::PopAndDestroy(2, active); // changeObs, active + } + + + +// +// +// +struct TThreadData + { + inline TThreadData() : iArray(NULL), iStopThread(EFalse) { } + // + RArray* iArray; + TBool iStopThread; + }; + +// Slave Thread for the TestNavigationWhilstBusyL() test. +// This runs continuously while aThreadData.iStopThread is False. +static void TestNavigationWhilstBusyL_ThreadFunctionL(TThreadData& aThreadData) + { + enum TNextOp + { + EAdd = 0, + EDelete, + EClear, + }; + + const static TNextOp KOpTable[] = + { + EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, + EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, + EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, + EAdd, EAdd, EAdd, EAdd, EAdd, EDelete, EAdd, EAdd, EAdd, EAdd, + EAdd, EAdd, EAdd, EDelete, EDelete, EDelete, EAdd, EAdd, EAdd, EAdd, + EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, + EAdd, EAdd, EAdd, EDelete, EDelete, EDelete, EAdd, EAdd, EAdd, EAdd, + EDelete, EDelete, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, + EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, + EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, + EAdd, EAdd, EAdd, EDelete, EDelete, EDelete, EAdd, EAdd, EAdd, EAdd, + EDelete, EDelete, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, + EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, + EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, + EAdd, EAdd, EAdd, EAdd, EAdd, EDelete, EAdd, EAdd, EAdd, EAdd, + EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, + EAdd, EDelete, EAdd, EDelete, EAdd, EDelete, EAdd, EDelete, EAdd, EDelete, + EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, + EAdd, EDelete, EAdd, EDelete, EAdd, EDelete, EAdd, EDelete, EAdd, EDelete, + EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, + EAdd, EDelete, EAdd, EDelete, EAdd, EDelete, EAdd, EDelete, EAdd, EDelete, + EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, + EAdd, EDelete, EAdd, EDelete, EAdd, EDelete, EAdd, EDelete, EAdd, EDelete, + EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, + EAdd, EDelete, EAdd, EDelete, EAdd, EDelete, EAdd, EDelete, EAdd, EDelete, + EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, EAdd, + }; + const static TInt KIndexTable[] = + { + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, + -1, -1, -1, 0, 4, 20, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 0, 1, 0, -1, -1, -1, -1, + 25, 8, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, 2, 4, 15, -1, -1, -1, -1, + 0, 0, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 0, -1, 30, -1, 0, -1, 31, -1, 14, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 10, -1, 2, -1, 0, -1, 24, -1, 11, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 0, -1, 10, -1, 0, -1, 12, -1, 5, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 15, -1, 9, -1, 0, -1, 19, -1, 25, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, 0, -1, 1, -1, 0, -1, 7, -1, 31, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + }; + const static TInt KDelayTable[] = + { + 0001, 0001, 0001, 0001, 0001, 0001, 0001, 0001, 0001, 0001, + 0001, 0001, 0001, 0001, 0001, 0001, 0001, 0001, 0001, 0001, + 0001, 0001, 0001, 0001, 0001, 0001, 0001, 0001, 0001, 0001, + 0001, 0001, 0001, 0001, 0001, 0001, 0002, 0002, 0002, 0002, + 0002, 0002, 0002, 0001, 0001, 0001, 0002, 0002, 0002, 0002, + 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, + 0002, 0002, 0002, 0001, 0002, 0001, 0002, 0002, 0002, 0002, + 2500, 8000, 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, + 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, + 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, + 0002, 0002, 0002, 2000, 4000000, 1500, 0002, 0002, 0002, 0002, + 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, + 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, + 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, 0002, + 0002, 0002, 0002, 0002, 0002, 0001, 0002, 0002, 0002, 0002, + 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, + 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, + 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, + 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, + 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, + 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, + 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, + 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, + 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, + 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, + 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, 0000, + }; + const TInt KOpCount = sizeof(KOpTable) / sizeof(TNextOp); + + TInt TotalAdds = 0; + TInt TotalDeletes = 0; + + RFs fsSession; + LEAVE_IF_ERROR(fsSession.Connect()); + CleanupClosePushL(fsSession); + // + CLogClient* client = CLogClient::NewL(fsSession); + CleanupStack::PushL(client); + // + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + event->SetEventType(TEST_LOG_UID); + // + CTestActive* active = new(ELeave) CTestActive(); + CleanupStack::PushL(active); + + // Add 5 recent events to the list + TBuf incoming; + client->GetString(incoming, R_LOG_DIR_IN); + event->SetDirection(incoming); + + CLogSchedulerTimer* timer = CLogSchedulerTimer::NewLC(); + TInt count = 0; + TInt i=0; + TInt Repeat =0; + // + while(!(aThreadData.iStopThread)) + { + const TInt op = KOpTable[i]; + // + switch(op) + { + case EAdd: + { + event->SetContact(i); + active->StartL(); + client->AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + __ASSERT_ALWAYS(active->iStatus == KErrNone, User::Panic(_L("ThreadPanic"), 1)); + ++count; + LEAVE_IF_ERROR(aThreadData.iArray->Append(event->Id())); + // RDebug::Print(_L("EAdd: i:%d count:%d, id:%d\n"), i, aThreadData.iArray->Count(), event->Id()); + + // Have to wait for a minimum of 1 ms here because otherwise DMBS sorts records (by time) + // in an arbitrary manor + // If this occurs this test will fail the logId == arrayId test below, as the order + // will be different between the logeng and arrayOfIds[]. + const TInt timeToWait = KDelayTable[i]; + if (timeToWait) + timer->Wait(timeToWait); + + timer->Wait(500000); + + TotalAdds++; + break; + } + case EDelete: + { + const TInt index = KIndexTable[i]; + const TLogId logId = (*aThreadData.iArray)[index]; + RDebug::Print(_L("EDelete index[%i]=%d id:%d\n"),i, index, logId); + active->StartL(); + client->DeleteEvent(logId, active->iStatus); + CActiveScheduler::Start(); + if (active->iStatus != KErrNone) + { + /* This happens if the LogID is not present in the log, + so the LogEngine cannot find the event to delete. + This can happen if the log is full, as it will start + deleting the old events itself */ + RDebug::Print(_L("Delete failed error:%d\n"), active->iStatus.Int()); + __ASSERT_ALWAYS(active->iStatus == KErrNone, User::Panic(_L("ThreadPanic"), 2)); + } + aThreadData.iArray->Remove(index); + --count; + TotalDeletes++; + break; + } + case EClear: + { + TTime now; + now.UniversalTime(); + now += TTimeIntervalDays(1); + + // Clear log + active->StartL(); + client->ClearLog(now, active->iStatus); + CActiveScheduler::Start(); + __ASSERT_ALWAYS(active->iStatus == KErrNone, User::Panic(_L("ThreadPanic"), 3)); + aThreadData.iArray->Reset(); + count = 0; + RDebug::Print(_L("TEST CODE: Log cleared\n")); + break; + } + } + + if (++i >= KOpCount) + { + i = 0; + Repeat++; + } + } + + RDebug::Print(_L("Repeats:%d TotalAdds:%d TotalDeletes:%d = %d\n"),Repeat,TotalAdds, TotalDeletes, count); + + CleanupStack::PopAndDestroy(timer); + + // Tidy up + CleanupStack::PopAndDestroy(4, &fsSession); + } + +// Slave Thread for the TestNavigationWhilstBusyL() test. +// +static TInt TestNavigationWhilstBusyL_ThreadFunction(TAny* aData) + { + TThreadData* threadData = reinterpret_cast(aData); + // + CTrapCleanup* cleanup = CTrapCleanup::New(); + if (!cleanup) + return KErrNoMemory; + CActiveScheduler* scheduler = new CActiveScheduler(); + if (!scheduler) + return KErrNoMemory; + CActiveScheduler::Install(scheduler); + // + TRAPD(err, TestNavigationWhilstBusyL_ThreadFunctionL(*threadData)); + UNUSED_VAR(err); + // + delete scheduler; + delete cleanup; + // + return KErrNone; + } + +/** +This tests using the Logeng while it is busy. It starts a new thread which adds and deletes events +using the data in KOpTable[] and KIndexTable[]. It then checks the database while the new thread is +running. + +@SYMTestCaseID SYSLIB-LOGENG-CT-0874 +@SYMTestCaseDesc Tests for navigation while Log engine is busy. +@SYMTestPriority High +@SYMTestActions Start a new thread which adds and deletes events + using the data in defined tables.It then checks the database while the new thread is running. +@SYMTestExpectedResults Test must not fail +@SYMREQ REQ0000 +*/ +LOCAL_C void TestNavigationWhilstBusyL(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0874 ")); + TestUtils::DeleteDatabaseL(); + + TInt error = 0; + TInt count = 0; + // + CTestActive* active = new(ELeave) CTestActive(); + CleanupStack::PushL(active); + + CLogViewChangeObserver* changeObs = CLogViewChangeObserver::NewLC(); + + // Create a test event type - TEST_LOG_UID + CLogEventType* type = CLogEventType::NewL(); + CleanupStack::PushL(type); + + type->SetUid(TEST_LOG_UID); + type->SetDescription(KTestEventDesc); + type->SetLoggingEnabled(ETrue); + RDebug::Print(_L("\nTest event type added %x\n"),TEST_LOG_UID ); + + // Register the event type + active->StartL(); + aClient.AddEventType(*type, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + CleanupStack::PopAndDestroy(); // type + + CLogViewEvent* view = CLogViewEvent::NewL(aClient, *changeObs); + CleanupStack::PushL(view); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + filter->SetEventType(TEST_LOG_UID); + TBool res = view->SetFilterL(*filter, active->iStatus); + test(!res); + + // increase the default log size + TLogConfig Config; + const TInt kMaxLogSize = 2000; + Config.iMaxLogSize = kMaxLogSize; + aClient.ChangeConfig( Config, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + // Shared data between this and the worker thread + RArray arrayOfIds(100); + CleanupClosePushL(arrayOfIds); + TThreadData threadData; + threadData.iArray = &arrayOfIds; + + // Create thread which adds two events + RThread thread; + RHeap& heap = User::Heap(); + error = thread.Create(_L("T_VIEW1_OBS_EVENT_CREATION_THREAD2"), TestNavigationWhilstBusyL_ThreadFunction, 10 * 1024, &heap, &threadData); + LEAVE_IF_ERROR(error); + CleanupClosePushL(thread); + + // Start the worker thread going + thread.Resume(); + + // Suspend this thread + RDebug::Print(_L("TEST CODE: Suspending thread for 2 seconds\n")); + CLogSchedulerTimer* timer = CLogSchedulerTimer::NewLC(); + timer->Wait(10 * 1000000); + + // Apply the filter now there are some records + RDebug::Print(_L("TEST CODE: Setting filter again - should be some records now\n")); + res = view->SetFilterL(*filter, active->iStatus); + test(res); + active->StartL(); + CActiveScheduler::Start(); + 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 + count = view->CountL(); + test(count > 0); + + // Navigate around (up and down) whilst events are being created + count = view->CountL(); + res = view->FirstL(active->iStatus); + test(res); + do { + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone || active->iStatus == KErrCancel); + count--; + if (active->iStatus == KErrNone) + test(view->Event().Id() != KLogNullId); + } + while(view->NextL(active->iStatus)); + + timer->Wait(5 * 1000000); + count = view->CountL(); + res = view->FirstL(active->iStatus); + test(res); + do { + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone || active->iStatus == KErrCancel); + count--; + if (active->iStatus == KErrNone) + test(view->Event().Id() != KLogNullId); + } + while(view->NextL(active->iStatus)); + + timer->Wait(5 * 1000000); + count = view->CountL(); + res = view->LastL(active->iStatus); + test(res); + do { + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone || active->iStatus == KErrCancel); + count--; + if (active->iStatus == KErrNone) + test(view->Event().Id() != KLogNullId); + } + while(view->PreviousL(active->iStatus)); + + timer->Wait(5 * 1000000); + count = view->CountL(); + res = view->FirstL(active->iStatus); + test(res); + do { + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone || active->iStatus == KErrCancel); + count--; + if (active->iStatus == KErrNone) + test(view->Event().Id() != KLogNullId); + } + while(view->NextL(active->iStatus)); + + timer->Wait(5 * 1000000); + count = view->CountL(); + res = view->LastL(active->iStatus); + test(res); + do { + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone || active->iStatus == KErrCancel); + count--; + if (active->iStatus == KErrNone) + test(view->Event().Id() != KLogNullId); + } + while(view->PreviousL(active->iStatus)); + + timer->Wait(5 * 1000000); + count = view->CountL(); + res = view->LastL(active->iStatus); + test(res); + do { + active->StartL(); + CActiveScheduler::Start(); + test(active->iStatus == KErrNone || active->iStatus == KErrCancel); + count--; + if (active->iStatus == KErrNone) + test(view->Event().Id() != KLogNullId); + } + while(view->PreviousL(active->iStatus)); + + // STOP THE WORKER THREAD + threadData.iStopThread = ETrue; + RDebug::Print(_L("Stopping worker thread\n")); + timer->Wait(30 * 1000000); + + // do some checks on the log + TLogConfig logConfig; + aClient.GetConfig( logConfig, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + RDebug::Print(_L("MaxLogSize:%ld MaxRecentLogSize:%d\n"), + logConfig.iMaxLogSize, logConfig.iMaxRecentLogSize ); + test(logConfig.iMaxLogSize > logConfig.iMaxRecentLogSize); + + /* Check the log has not overflowed. + If this fails either increase the log size or reduce the time the + worker thread has been running + */ + test (arrayOfIds.Count() < kMaxLogSize); + + // Loop though the logevents created by the worker thread and compare against the + // data stored in arrayOfIds. + res = view->LastL(active->iStatus); + test(res); + count = 0; + do { + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + const TLogId logId = view->Event().Id(); + const TLogId arrayId = arrayOfIds[count]; + if (logId != arrayId) + RDebug::Print(_L("Events[%d] - array:%5d, id:%5d ****\n"), count, arrayId, logId); + // Note: If this test fails the fist thing to check is the time delay after EAdd. + // If several events get the same time stamp, the order is arbitrary and the test fails here. + test(logId == arrayId); + count++; + } + while(view->PreviousL(active->iStatus)); + + CleanupStack::PopAndDestroy(timer); + CleanupStack::PopAndDestroy(&thread); + CleanupStack::PopAndDestroy(&arrayOfIds); + CleanupStack::PopAndDestroy(filter); + CleanupStack::PopAndDestroy(view); + CleanupStack::PopAndDestroy(2, active); // changeObs, active + } + +/** +@SYMTestCaseID SYSLIB-LOGENG-CT-4014 +@SYMTestCaseDesc Tests CLogView::CountL works correctly after SetFilterL returns no event. +@SYMTestPriority High +@SYMTestActions 1. ClearLog. + 2. SetFilterL. + 3. Add events and check count. + 4. Step through the added events. +@SYMTestExpectedResults 2 - SetFilterL indicates no event in view. + 3. CountL method returns correct number of events. + 4. Can step through the added events. + +@SYMDEF INC123066 +*/ +LOCAL_C void INC123066L(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-4014 ")); + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + event->SetEventType(KLogCallEventTypeUid); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + // deliberately not using CLogViewChangeObserver + + CLogViewEvent* view = CLogViewEvent::NewL(aClient); + CleanupStack::PushL(view); + + CLogFilter* filter = CLogFilter::NewL(); + CleanupStack::PushL(filter); + + // Clear all the events + TTime now; + now.UniversalTime(); + now += TTimeIntervalDays(1); + active->StartL(); + aClient.ClearLog(now, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TBool res = view->SetFilterL(*filter, active->iStatus); + TEST2(res, 0); + + TInt count; + for(count = 0; count < KTestEventNum; count++) + { + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TEST2(view->CountL(), count+1); + } + + // save the most recent logId for checking. + TLogId lastLogId = event->Id(); + + // Can iterate over the added events + for (count = 0; count < KTestEventNum; count++) + { + active->StartL(); + TEST( view->NextL(active->iStatus) ); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + TLogId id = view->Event().Id(); + // Most recent event is first. Oldest event is last. + TEST2((lastLogId - count), id); + } + + CleanupStack::PopAndDestroy(4, event); // filter, view, active, event + + // See same test using CLogViewRecent in TestRecentView1L. + } + +/** +@SYMTestCaseID PDS-LOGENG-CT-4017 +@SYMTestCaseDesc Tests Handling of CLogViewRecent::SetRecentListL when + Remote Party string contains single quote character +@SYMTestPriority High +@SYMTestActions 1. Create 10 Incoming call events from 3 different + Remote Parties using single quotes in strings + 2. Call CLogViewRecent::SetRecentListL. + 3. Check that duplicate entries have been deleted and only + 3 events are showm + +@SYMTestExpectedResults SetRecentListL indicates 3 events in view +@SYMDEF INC136334 +*/ +LOCAL_C void INC136334L(CLogClient& aClient) + { + test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-CT-4017 ")); + CLogEvent* event = CLogEvent::NewL(); + CleanupStack::PushL(event); + + CTestActive* active = new(ELeave)CTestActive(); + CleanupStack::PushL(active); + + CLogViewRecent* view = CLogViewRecent::NewL(aClient); + CleanupStack::PushL(view); + + // Incoming + TBuf buf; + aClient.GetString(buf, R_LOG_DIR_IN); + + event->SetEventType(KLogCallEventTypeUid); + event->SetDirection(buf); + + TInt count; + //Add 10 missed calls from 3 different contacts + //These should result in only 3 entries int he log as + //duplicates should be deleted. + for(count = 0; count < KTestEventNum; count++) + { + //Use a string with a single quote + event->SetRemoteParty(_L("Sam's Wife")); + + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + //Use a string with multiple single quotes + event->SetRemoteParty(_L("'Sam's W'i'f'e'''''''")); + + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + //Use a string with no single quotes + event->SetRemoteParty(_L("Sams Wife")); + + active->StartL(); + aClient.AddEvent(*event, active->iStatus); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + } + + TEST2(view->CountL(), 0); + TBool res = view->SetRecentListL(KLogRecentIncomingCalls, active->iStatus); + TEST(res); + + //All of the duplicate entries should be deleted and there should + //only be 3 events in the log + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + TEST2(view->CountL(), 3); + + //Clear the log for he next test + aClient.ClearLog(KLogRecentIncomingCalls, active->iStatus); + active->StartL(); + CActiveScheduler::Start(); + TEST2(active->iStatus.Int(), KErrNone); + + count = view->CountL(); + TEST2(count, 0); + + CleanupStack::PopAndDestroy(3); // view, active, event + + } +// +// +// +void doTestsL() + { + TheMatchingIsEnabled = TestUtils::MatchingEnabledL(); + + TestUtils::Initialize(_L("T_LOGVIEW1")); + TestUtils::DeleteDatabaseL(); + + CLogClient* client = CLogClient::NewL(theFs); + CleanupStack::PushL(client); + + CLogChangeNotifier* notifier = CLogChangeNotifier::NewL(); + CleanupStack::PushL(notifier); + + test.Start(_L("Event View With No Filter")); + + TestEventViewL(*client); + theLog.Write(_L8("Test 1 OK\n")); + + test.Next(_L("Event View Filter alternative")); + TestViewFilteringDefect1L(*client); + theLog.Write(_L8("Test 2 OK\n")); + test.Next(_L("Event View With Filter")); + TestEventViewFilter1L(*client); + TestEventViewFilter2L(*client); + test.Next(_L("INC123066 - LogView not updated if SetFilterL found no event")); + INC123066L(*client); + theLog.Write(_L8("Test 3 OK\n")); + + test.Next(_L("Recent View")); + TestRecentView1L(*client); + TestRecentView2L(*client); + theLog.Write(_L8("Test 4 OK\n")); + + test.Next(_L("Removing recent events")); + TestRecentRemove1L(*client); + TestRecentRemove2L(*client); + theLog.Write(_L8("Test 5 OK\n")); + + test.Next(_L("Duplicate View")); + TestDuplicateViewL(*client); + theLog.Write(_L8("Test 6 OK\n")); + + test.Next(_L("Removing duplicate events")); + TestDuplicateRemoveL(*client); + theLog.Write(_L8("Test 7 OK\n")); + + test.Next(_L("Check purge performed on view setup")); + TestPurgeOnSetup1L(*client); + TestPurgeOnSetup2L(*client); + theLog.Write(_L8("Test 8 OK\n")); + + test.Next(_L("View Purging")); + TestViewPurgeL(*client); + theLog.Write(_L8("Test 9 OK\n")); + + test.Next(_L("Clearing duplicate lists")); + TestClearDuplicatesL(*client); + theLog.Write(_L8("Test 10 OK\n")); + + test.Next(_L("Phone number matching")); + TestPhoneNumberMatchingL(*client); + theLog.Write(_L8("Test 11 OK\n")); + + test.Next(_L("view flags setting/clearing")); + TestViewFlagsL(*client); + theLog.Write(_L8("Test 12 OK\n")); + + test.Next(_L("Recent view flags setting/clearing")); + TestRecentFlagsL(*client); + theLog.Write(_L8("Test 13 OK\n")); + + test.Next(_L("View change tests 1")); + TestViewChangeEvents1L(*client); + TestViewChangeEvents1aL(*client); + theLog.Write(_L8("Test 14 OK\n")); + + test.Next(_L("View change tests 2")); + TestViewChangeEvents2L(*client); + TestViewChangeEvents2aL(*client); + theLog.Write(_L8("Test 15 OK\n")); + + test.Next(_L("View deletion from within callback")); + TestDeletingViewWithinObserverCallbackL(*client); + theLog.Write(_L8("Test 16 OK\n")); + + test.Next(_L("Test navigation whilst events are added")); + TestNavigationWhilstBusyL(*client); + theLog.Write(_L8("Test 17 OK\n")); + + test.Next(_L("Defect INC105010 - phone number matching")); + INC105010L(*client); + theLog.Write(_L8("Test 18 OK\n")); + + test.Next(_L("INC136334 - The miss call log won't show if you have ' in your contact")); + INC136334L(*client); + theLog.Write(_L8("Test 19 OK\n")); + + CleanupStack::PopAndDestroy(2); // notifier, client; + }