--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/loggingservices/eventlogger/test/src/t_logapi2.cpp Fri Jan 22 11:06:30 2010 +0200
@@ -0,0 +1,1059 @@
+// Copyright (c) 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:
+// t_logapi2.cpp - LogEng API tests
+//
+//
+#include <s32file.h>
+#include <s32mem.h>
+#include <e32math.h>
+#include <bautils.h>
+#include <logview.h>
+#include "TEST.H"
+#include "LogServSqlStrings.h"
+
+#undef test //there is a "test" macro which hides "RTest test" declaration.
+
+RTest test(_L("t_logapi2"));
+
+_LIT(KTestRemoteParty1, "Remote Party");
+_LIT(KTestDirection1, "Direction");
+_LIT(KTestStatus1, "Status");
+_LIT(KTestSubject1, "Subject");
+const TUid KTestEventUid = {0x10005393};
+const TLogDurationType KTestDurationType1 = 1;
+const TLogDuration KTestDuration1 = 0x1234;
+const TLogContactItemId KTestContact1 = 0x1234;
+const TLogLink KTestLink1 = 0x1234;
+_LIT8(KTestData1, "ABCDEFGH");
+const TLogFlags KTestFlags1 = 0x5;
+_LIT(KEvNumber1, "11119999");
+_LIT(KEvNumber2, "22226666");
+const TLogDurationType KEvDurationType1 = 1;
+const TLogDurationType KEvDurationType2 = 2;
+const TLogContactItemId KEvContact1 = 1010;
+const TLogLink KEvLink1 = 2000;
+_LIT(KEvDesc1, "Event Type Description 1");
+
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+const TSimId KEvSimId1 = 3000000910U;//Bigger than KMaxTInt, to check that SQL statement formatting works as expected
+const TSimId KEvSimId2 = 2911;
+#endif
+
+const TInt KDiffEvCount = 10;
+
+//KEvDirection2 used together with KEvTypeUid guarantees that the properties of the event being changed
+//match the conditions of one the LogEng server recent lists and thus the "recent list" related functionality
+//on the server side will be used.
+_LIT(KEvDirection2, "Incoming");
+
+const TUid KEvTypeUid = {KLogCallEventType};
+const TUid KEvTypeUidLoggingDisabled = {0x447422};
+
+enum TLogAddEventOps {ELogOpAddEvent, ELogOpAddEventInvalidType, ELogOpAddEventLoggingDisabled};
+enum TLogGetEventOps {ELogOpGetEvent, ELogOpGetEventZeroId, ELogOpGetEventNotExists};
+
+TLogId TheEvId = -1;
+TInt TheAddedEventCount = -1;
+TInt TheMaxLogSize = -1;
+
+//The default max log size is 1000. But the test timeouts on hardware with max log size of 1000.
+const TInt KMaxLogSize = 200;
+const TInt KMaxRecentLogSize = 10; // Default recent log size is 20
+const TInt KMaxPlusEvCount = 100; //Added events count on top of the max log size
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+//Add a new event type with "logging disabled"
+void DoAddEventTypeL(CLogClient& aClient, CTestActive& aActive)
+ {
+ CLogEventType* type = CLogEventType::NewL();
+ CleanupStack::PushL(type);
+
+ type->SetUid(KEvTypeUidLoggingDisabled);
+ type->SetDescription(_L("110111011011"));
+ type->SetLoggingEnabled(EFalse);
+
+ aClient.AddEventType(*type, aActive.iStatus);
+ aActive.StartL();
+ CActiveScheduler::Start();
+ TEST2(aActive.iStatus.Int(), KErrNone);
+
+ CleanupStack::PopAndDestroy(type);
+ }
+
+void DoSetNewMaxLogSizeL(CLogClient& aClient, CTestActive& aActive)
+ {
+ //Check what is the max log size.
+ TLogConfig config;
+ aActive.StartL();
+ aClient.GetConfig(config, aActive.iStatus);
+ CActiveScheduler::Start();
+ TEST2(aActive.iStatus.Int(), KErrNone);
+ //Set new max log size
+ config.iMaxLogSize = KMaxLogSize;
+ aActive.StartL();
+ aClient.ChangeConfig(config, aActive.iStatus);
+ CActiveScheduler::Start();
+ TEST2(aActive.iStatus.Int(), KErrNone);
+ //Test the new max log size
+ aActive.StartL();
+ aClient.GetConfig(config, aActive.iStatus);
+ CActiveScheduler::Start();
+ TEST2(aActive.iStatus.Int(), KErrNone);
+ TEST2(config.iMaxLogSize, KMaxLogSize);
+ //
+ TheMaxLogSize = config.iMaxLogSize;
+ TheAddedEventCount = config.iMaxLogSize + KMaxPlusEvCount;
+ }
+
+void DoAddEventsL()
+ {
+ CLogClient* client = CLogClient::NewL(theFs);
+ CleanupStack::PushL(client);
+ CTestActive* active = new(ELeave)CTestActive();
+ CleanupStack::PushL(active);
+
+ //Set new max log size
+ DoSetNewMaxLogSizeL(*client, *active);
+
+ //Add TheAddedEventCount events. Some of them with SimId, some - not.
+ //This certainly will involve some log purging operations when the log size reaches the max.
+ CLogEvent* event = CLogEvent::NewL();
+ CleanupStack::PushL(event);
+ event->SetEventType(KLogCallEventTypeUid);
+ event->SetRemoteParty(KTestRemoteParty1);
+ event->SetDirection(KTestDirection1);
+ event->SetDurationType(KEvDurationType1);
+ event->SetDuration(KTestDuration1);
+ event->SetStatus(KTestStatus1);
+ event->SetSubject(KTestSubject1);
+ event->SetNumber(KEvNumber1);
+ event->SetContact(KEvContact1);
+ event->SetLink(KEvLink1);
+ event->SetDescription(KEvDesc1);
+ event->SetFlags(KTestFlags1);
+ event->SetDataL(KTestData1);
+
+ TTime st_time;
+ st_time.UniversalTime();
+
+ test.Printf(_L("Added events:\n"));
+ TInt diffEvCount = KDiffEvCount;
+ for(TInt i=0;i<TheAddedEventCount;++i)
+ {
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+ event->SetSimId(KLogNullSimId);
+#endif
+ event->SetDurationType(KEvDurationType1);
+ event->SetNumber(KEvNumber1);
+ if((i %2) == 0)
+ {
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+ event->SetSimId(KEvSimId1);
+#endif
+ if((i > TheMaxLogSize / 2 + 1) && (i % 10) == 0 && --diffEvCount >= 0)
+ {//Add after the second half because when the log grows above the max log size, the first events will be deleted
+ event->SetDurationType(KEvDurationType2);
+ event->SetNumber(KEvNumber2);
+ }
+ }
+ active->StartL();
+ client->AddEvent(*event, active->iStatus);
+ CActiveScheduler::Start();
+ TEST(!active->IsActive());
+ TEST2(active->iStatus.Int(), KErrNone);
+ if((i % 50) == 0 && i > 0)
+ {
+ test.Printf(_L("%d\r"), i);
+ }
+ }
+ test.Printf(_L("%d\n"), TheAddedEventCount);
+
+ TTime end_time;
+ end_time.UniversalTime();
+
+ CleanupStack::PopAndDestroy(event);
+
+ CleanupStack::PopAndDestroy(active);
+ CleanupStack::PopAndDestroy(client);
+
+ TTimeIntervalMicroSeconds us = end_time.MicroSecondsFrom(st_time);
+ test.Printf(_L("%d events added. Time: %ld milliseconds\n"), TheAddedEventCount, us.Int64() / 1000);
+ }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/**
+@SYMTestCaseID PDS-LOGENG-UT-4042
+@SYMTestCaseDesc "Cancel operation" test.
+ The test uses RLogTestSession to establish a connection with the EventViewer server.
+ The the test initializes an "Add Event" opertaion.
+ But instead of completing the operation the test cancels it.
+@SYMTestActions "Cancel operation" test.
+@SYMTestExpectedResults Test must not fail
+@SYMTestPriority Medium
+@SYMREQ REQ12747
+*/
+void CancelOperationTest()
+ {
+ RLogTestSession sess;
+ TInt err = sess.Connect();
+ TEST2(err, KErrNone);
+
+ CLogEvent* event = NULL;
+ TRAP(err, event = CLogEvent::NewL());
+ TEST2(err, KErrNone);
+ event->SetEventType(KTestEventUid);
+ event->SetRemoteParty(KTestRemoteParty1);
+ event->SetDirection(KTestDirection1);
+ event->SetDurationType(KTestDurationType1);
+ event->SetDuration(KTestDuration1);
+ event->SetStatus(KTestStatus1);
+ event->SetSubject(KTestSubject1);
+ event->SetContact(KTestContact1);
+ event->SetLink(KTestLink1);
+ TRAP(err, event->SetDataL(KTestData1));
+ TEST2(err, KErrNone);
+ event->SetFlags(KTestFlags1);
+
+ TBuf8<1024> buf;
+ RDesWriteStream strm(buf);
+ TRAP(err, event->ExternalizeL(strm));
+ TEST2(err, KErrNone);
+ TRAP(err, strm.CommitL());
+ TEST2(err, KErrNone);
+
+ TPckgBuf<TLogClientServerData> data;
+ data().iOperationType = ELogOperationEventAdd;
+ data().iOperationId = KLogNullOperationId;
+
+ TRequestStatus stat;
+ TIpcArgs args1(&data, &buf);
+ sess.Send(ELogOperationInitiate, args1, stat);
+ TEST2(stat.Int(), KRequestPending);
+ TIpcArgs args2(&data);
+ err = sess.Send(ELogOperationCancel, args2);
+ TEST2(err, KErrCancel);
+ User::WaitForRequest(stat);
+ err = stat.Int();
+ TEST2(err, KErrCancel);
+
+ strm.Close();
+ delete event;
+ sess.Close();
+ }
+
+/**
+@SYMTestCaseID PDS-LOGENG-UT-4029
+@SYMTestCaseDesc AddEvent() server side OOM test.
+ This test uses the results from the previous test cases that
+ the LogEng database contains TheMaxLogSize events.
+ This ensures that the "purge main" functionality on the server side
+ will be used.
+ The properties of the event being added are such (KEvDirection1 and KEvTypeUid) that
+ one of the LogServ recent lists will be used. This ensures that the "purge recent"
+ LogEng server functionality will be used.
+ The test, as any other of the LogEng server OOM tests, does not fully cover the used on the
+ server side functions, because:
+ 1) CLogAddEvent will set the iEventAdded flag right after adding the event to the database.
+ After that, any OOM failure that occurs for example in "purge recent" related calls, will be
+ ignored.
+ 2) CLogEvent will use the CLogDuplicate active object for the "purge recent" action.
+ When CLogDuplicate fails with KErrNoMemory in DoRunL(), the error is ignored and not reported
+ back.
+@SYMTestActions AddEvent() server side OOM test.
+@SYMTestExpectedResults Test must not fail
+@SYMTestPriority Medium
+@SYMREQ REQ12746
+*/
+void AddEventOomTestL(TLogAddEventOps aLogAddEventOp, TInt aExpectedError)
+ {
+ CLogClient* client = CLogClient::NewL(theFs);
+ CleanupStack::PushL(client);
+ CTestActive* active = new(ELeave)CTestActive();
+ CleanupStack::PushL(active);
+ CLogEvent* event = CLogEvent::NewL();
+ CleanupStack::PushL(event);
+
+ if(aLogAddEventOp == ELogOpAddEventLoggingDisabled)
+ {
+ DoAddEventTypeL(*client, *active);
+ }
+
+ TTime now;
+ now.UniversalTime();
+
+ TUid eventType = KEvTypeUid;
+ if(aLogAddEventOp == ELogOpAddEventInvalidType)
+ {
+ eventType = TUid::Uid(0x445972);
+ }
+ else if(aLogAddEventOp == ELogOpAddEventLoggingDisabled)
+ {
+ eventType = KEvTypeUidLoggingDisabled;
+ }
+
+ event->SetEventType(eventType);
+ event->SetRemoteParty(KTestRemoteParty1);
+ event->SetDirection(KTestDirection1);
+ event->SetDurationType(KEvDurationType1);
+ event->SetDuration(KTestDuration1);
+ event->SetStatus(KTestStatus1);
+ event->SetSubject(KTestSubject1);
+ event->SetNumber(KEvNumber1);
+ event->SetContact(KEvContact1);
+ event->SetLink(KEvLink1);
+ event->SetDescription(KEvDesc1);
+ event->SetFlags(KTestFlags1);
+ event->SetDataL(KTestData1);
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+ event->SetSimId(KEvSimId1);
+#endif
+
+ TInt failCount = 0;
+ TBool finished = EFalse;
+
+ while(!finished)
+ {
+ __LOGSERV_UHEAP_FAILNEXT(++failCount);
+ client->AddEvent(*event, active->iStatus);
+ active->StartL();
+ CActiveScheduler::Start();
+
+ if(active->iStatus.Int() == aExpectedError)
+ {
+ finished = ETrue;
+ }
+
+ __LOGSERV_UHEAP_RESET;
+
+ if(active->iStatus.Int() != aExpectedError)
+ {
+ TEST2(active->iStatus.Int(), KErrNoMemory);
+ }
+ }
+
+ TEST2(active->iStatus.Int(), aExpectedError);
+ if(aLogAddEventOp == ELogOpAddEvent)
+ {
+ TEST(event->Time() >= now);
+ active->StartL();
+ client->GetEvent(*event, active->iStatus);
+ CActiveScheduler::Start();
+ TEST2(active->iStatus.Int(), KErrNone);
+ TheEvId = event->Id();
+ TEST(TheEvId > 0);
+ }
+
+ CleanupStack::PopAndDestroy(event);
+ CleanupStack::PopAndDestroy(active);
+ CleanupStack::PopAndDestroy(client);
+
+ test.Printf(_L("===CLogClient::AddEvent() server side OOM test succeeded at iteration %d\n"), failCount);
+ }
+
+/**
+@SYMTestCaseID PDS-LOGENG-UT-4030
+@SYMTestCaseDesc ChangeEvent() server side OOM test.
+ This test uses the results from the previous test cases that
+ the LogEng database contains TheMaxLogSize events.
+ This ensures that the "purge main" functionality on the server side
+ will be used.
+ The properties of the event being changed are such (KEvDirection2 and KEvTypeUid) that
+ one of the LogServ recent lists will be used. This ensures that the "purge recent"
+ LogEng server functionality will be used.
+@SYMTestActions ChangeEvent() server side OOM test.
+@SYMTestExpectedResults Test must not fail
+@SYMTestPriority Medium
+@SYMREQ REQ12746
+*/
+void ChangeEventOomTestL(TBool aEventExists)
+ {
+ CLogClient* client = CLogClient::NewL(theFs);
+ CleanupStack::PushL(client);
+ CTestActive* active = new(ELeave)CTestActive();
+ CleanupStack::PushL(active);
+ CLogEvent* event = CLogEvent::NewL();
+ CleanupStack::PushL(event);
+
+ event->SetId(TheEvId);
+ active->StartL();
+ client->GetEvent(*event, active->iStatus);
+ CActiveScheduler::Start();
+ TEST2(active->iStatus.Int(), KErrNone);
+ TEST2(TheEvId, event->Id());
+ event->SetDirection(KEvDirection2);
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+ event->SetSimId(KEvSimId2);
+#endif
+
+ TInt failCount = 0;
+ TBool finished = EFalse;
+
+ if(!aEventExists)
+ {//Search for a non-existing event in the OOM loop
+ event->SetId(TheEvId + 5678);
+ }
+
+ while(!finished)
+ {
+ __LOGSERV_UHEAP_FAILNEXT(++failCount);
+ client->ChangeEvent(*event, active->iStatus);
+ active->StartL();
+ CActiveScheduler::Start();
+
+ TInt err = active->iStatus.Int();
+ if(err == (aEventExists ? KErrNone : KErrNotFound))
+ {
+ finished = ETrue;
+ }
+
+ __LOGSERV_UHEAP_RESET;
+
+ if(err != (aEventExists ? KErrNone : KErrNotFound))
+ {
+ TEST2(err, KErrNoMemory);
+ }
+ }
+
+ active->StartL();
+ client->GetEvent(*event, active->iStatus);
+ CActiveScheduler::Start();
+ if(aEventExists)
+ {
+ TEST2(active->iStatus.Int(), KErrNone);
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+ TEST2(event->SimId(), KEvSimId2);
+#endif
+ }
+ else
+ {
+ TEST2(active->iStatus.Int(), KErrNotFound);
+ }
+
+ CleanupStack::PopAndDestroy(event);
+ CleanupStack::PopAndDestroy(active);
+ CleanupStack::PopAndDestroy(client);
+
+ test.Printf(_L("===CLogClient::ChangeEvent() server side OOM test succeeded at iteration %d\n"), failCount);
+ }
+
+/**
+@SYMTestCaseID PDS-LOGENG-UT-4031
+@SYMTestCaseDesc DeleteEvent() server side OOM test.
+ This test uses the results from the previous test cases that
+ the LogEng database contains TheMaxLogSize events.
+ This ensures that the "purge main" functionality on the server side
+ will be used.
+@SYMTestActions DeleteEvent() server side OOM test.
+@SYMTestExpectedResults Test must not fail
+@SYMTestPriority Medium
+@SYMREQ REQ12746
+*/
+void DeleteEventOomTestL(TBool aEventExists)
+ {
+ CLogClient* client = CLogClient::NewL(theFs);
+ CleanupStack::PushL(client);
+ CTestActive* active = new(ELeave)CTestActive();
+ CleanupStack::PushL(active);
+
+ TInt failCount = 0;
+ TBool finished = EFalse;
+
+ while(!finished)
+ {
+ __LOGSERV_UHEAP_FAILNEXT(++failCount);
+ client->DeleteEvent(TheEvId, active->iStatus);
+ active->StartL();
+ CActiveScheduler::Start();
+
+ TInt err = active->iStatus.Int();
+ if(err == (aEventExists ? KErrNone : KErrNotFound))
+ {
+ finished = ETrue;
+ }
+
+ __LOGSERV_UHEAP_RESET;
+
+ if(err != (aEventExists ? KErrNone : KErrNotFound))
+ {
+ TEST2(err, KErrNoMemory);
+ }
+ }
+
+ CLogEvent* event = CLogEvent::NewL();
+ CleanupStack::PushL(event);
+ event->SetId(TheEvId);
+ active->StartL();
+ client->GetEvent(*event, active->iStatus);
+ CActiveScheduler::Start();
+ TEST2(active->iStatus.Int(), KErrNotFound);
+ CleanupStack::PopAndDestroy(event);
+
+ CleanupStack::PopAndDestroy(active);
+ CleanupStack::PopAndDestroy(client);
+
+ test.Printf(_L("===CLogClient::DeleteEvent() server side OOM test succeeded at iteration %d\n"), failCount);
+ }
+
+/**
+@SYMTestCaseID PDS-LOGENG-UT-4032
+@SYMTestCaseDesc GetEvent() server side OOM test.
+ This test uses the results from the previous test cases that
+ the LogEng database contains TheMaxLogSize events.
+ GetEvent() is executed in OOM loop.
+@SYMTestActions GetEvent() server side OOM test.
+@SYMTestExpectedResults Test must not fail
+@SYMTestPriority Medium
+@SYMREQ REQ12746
+*/
+void GetEventOomTestL(TLogGetEventOps aGetEventOp, TInt aExpectedError)
+ {
+ CLogClient* client = CLogClient::NewL(theFs);
+ CleanupStack::PushL(client);
+ CTestActive* active = new(ELeave)CTestActive();
+ CleanupStack::PushL(active);
+ CLogEvent* event = CLogEvent::NewL();
+ CleanupStack::PushL(event);
+
+ event->SetId(aGetEventOp == ELogOpGetEvent ? TheEvId : (aGetEventOp == ELogOpGetEventNotExists ? 0x932271F : 0x0));
+
+ TInt failCount = 0;
+ TBool finished = EFalse;
+
+ while(!finished)
+ {
+ __LOGSERV_UHEAP_FAILNEXT(++failCount);
+ client->GetEvent(*event, active->iStatus);
+ active->StartL();
+ CActiveScheduler::Start();
+
+ if(active->iStatus.Int() == aExpectedError)
+ {
+ finished = ETrue;
+ }
+
+ __LOGSERV_UHEAP_RESET;
+
+ if(active->iStatus.Int() != aExpectedError)
+ {
+ TEST2(active->iStatus.Int(), KErrNoMemory);
+ }
+ }
+
+ TEST2(active->iStatus.Int(), aExpectedError);
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+ if(aGetEventOp == ELogOpGetEvent)
+ {
+ TEST2(event->SimId(), KEvSimId2);
+ }
+#endif
+
+ CleanupStack::PopAndDestroy(event);
+ CleanupStack::PopAndDestroy(active);
+ CleanupStack::PopAndDestroy(client);
+
+ test.Printf(_L("===CLogClient::GetEvent() server side OOM test succeeded at iteration %d\n"), failCount);
+ }
+
+/**
+@SYMTestCaseID PDS-LOGENG-UT-4033
+@SYMTestCaseDesc Change Event Type test.
+ The test attempts to change the type of an existing event.
+ The attempt must fails with KErrPermissionDenied error.
+@SYMTestActions Change Event Type test.
+@SYMTestExpectedResults Test must not fail
+@SYMTestPriority Medium
+@SYMREQ REQ12746
+*/
+void ChangeStandardEventTypeTestL()
+ {
+ CLogClient* client = CLogClient::NewL(theFs);
+ CleanupStack::PushL(client);
+ CTestActive* active = new(ELeave)CTestActive();
+ CleanupStack::PushL(active);
+
+ CLogEventType* evType = CLogEventType::NewL();
+ CleanupStack::PushL(evType);
+ TUid uid = {KLogCallEventType};
+ evType->SetUid(uid);
+ evType->SetDescription(_L("aaaaaaaa"));
+
+ active->StartL();
+ client->ChangeEventType(*evType, active->iStatus);
+ CActiveScheduler::Start();
+ TEST2(active->iStatus.Int(), KErrPermissionDenied);
+
+ CleanupStack::PopAndDestroy(evType);
+
+ CleanupStack::PopAndDestroy(active);
+ CleanupStack::PopAndDestroy(client);
+ }
+
+CLogFilter* DoCreateFilter1LC()
+ {
+ CLogFilter* filter = CLogFilter::NewL();
+ CleanupStack::PushL(filter);
+
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+ filter->SetSimId(KEvSimId2);
+#endif
+ filter->SetDurationType(KEvDurationType2);
+ filter->SetNumber(KEvNumber2);
+ filter->SetStatus(KTestStatus1);
+ filter->SetDirection(KTestDirection1);
+
+ return filter;
+ }
+
+CLogFilter* DoCreateFilter2LC()
+ {
+ CLogFilter* filter = CLogFilter::NewL();
+ CleanupStack::PushL(filter);
+
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+ filter->SetSimId(KEvSimId1);
+#endif
+ filter->SetDurationType(KEvDurationType1);
+ filter->SetNumber(KEvNumber1);
+ filter->SetStatus(KTestStatus1);
+ filter->SetDirection(KTestDirection1);
+ filter->SetEventType(KEvTypeUid);
+ filter->SetRemoteParty(KTestRemoteParty1);
+ filter->SetNullFields(ELogFlagsField);
+
+ return filter;
+ }
+
+CLogFilter* DoCreateFilter3LC()
+ {
+ CLogFilter* filter = CLogFilter::NewL();
+ CleanupStack::PushL(filter);
+
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+ filter->SetSimId(KEvSimId1);
+#endif
+ filter->SetDurationType(KEvDurationType1);
+ filter->SetNumber(KEvNumber1);
+ filter->SetStatus(KTestStatus1);
+ filter->SetDirection(KTestDirection1);
+ filter->SetEventType(KEvTypeUid);
+ filter->SetRemoteParty(KTestRemoteParty1);
+ filter->SetContact(KEvContact1);
+ filter->SetNullFields(ELogFlagsField);
+
+ return filter;
+ }
+
+/**
+@SYMTestCaseID PDS-LOGENG-UT-4034
+@SYMTestCaseDesc Complex view filter set test.
+ The test creates a set of filters using all event properties and duplicating some of them
+ in the filters. Then sets the set of filters to a view and iterates over the view's events.
+ The idea is to test as much as possible the server side filter processing in TLogFilterExprBuilder
+ class implementation.
+@SYMTestActions Complex view filter set test.
+@SYMTestExpectedResults Test must not fail
+@SYMTestPriority Medium
+@SYMREQ REQ12746
+*/
+void ComplexFilterSetTestL()
+ {
+ CLogClient* client = CLogClient::NewL(theFs);
+ CleanupStack::PushL(client);
+ CTestActive* active = new(ELeave)CTestActive();
+ CleanupStack::PushL(active);
+ CLogViewEvent* view = CLogViewEvent::NewL(*client);
+ CleanupStack::PushL(view);
+ CLogFilter* filter1 = DoCreateFilter1LC();
+ CLogFilter* filter2 = DoCreateFilter2LC();
+ CLogFilter* filter3 = DoCreateFilter3LC();
+ CLogFilterList* filterList = new(ELeave)CLogFilterList;
+ CleanupStack::PushL(filterList);
+ filterList->AppendL(filter1);
+ filterList->AppendL(filter2);
+ filterList->AppendL(filter3);
+
+ //Check the "copy filter list" operations
+ CLogFilterList* filterList2 = filterList->CopyL();
+ TEST2(filterList2->Count(), filterList->Count());
+ delete filterList2;
+ CLogFilterList* filterList3 = filterList->CopyLC();
+ TEST2(filterList3->Count(), filterList->Count());
+ CleanupStack::PopAndDestroy(filterList3);
+
+ TTime st_time;
+ st_time.UniversalTime();
+ TBool res = view->SetFilterL(*filterList, active->iStatus);
+ TEST(res);
+ active->StartL();
+ CActiveScheduler::Start();
+ TEST2(active->iStatus.Int(), KErrNone);
+ TInt count = view->CountL();
+ test.Printf(_L("===Events count: %d\n"), count);
+ TTime end_time;
+ end_time.UniversalTime();
+ TTimeIntervalMicroSeconds us = end_time.MicroSecondsFrom(st_time);
+ test.Printf(_L("SetFilter(). Time: %ld milliseconds\n"), us.Int64() / 1000);
+
+ st_time.UniversalTime();
+ if(view->FirstL(active->iStatus))
+ {
+ count = 0;
+ do
+ {
+ active->StartL();
+ CActiveScheduler::Start();
+ TEST2(active->iStatus.Int(), KErrNone);
+ ++count;
+ }
+ while(view->NextL(active->iStatus));
+ }
+ end_time.UniversalTime();
+ us = end_time.MicroSecondsFrom(st_time);
+ test.Printf(_L("Event view walk completed. Events count: %d. Time: %ld milliseconds\n"), count, us.Int64() / 1000);
+
+ CleanupStack::PopAndDestroy(filterList);
+ CleanupStack::PopAndDestroy(filter3);
+ CleanupStack::PopAndDestroy(filter2);
+ CleanupStack::PopAndDestroy(filter1);
+ CleanupStack::PopAndDestroy(view);
+ CleanupStack::PopAndDestroy(active);
+ CleanupStack::PopAndDestroy(client);
+ }
+
+#ifdef _DEBUG
+static void StopLogServerL()
+ {
+ static RLogTestSession logServSession;
+ //this function doesn't have any effect on UREL builds as LogEng server doesn't
+ //support the transient mode in UREL builds
+ //Used for LogEng server side heap failure testing.
+ TInt error = KErrNone;
+
+ if(!logServSession.Handle())
+ {
+ error = logServSession.Connect();
+ }
+
+ // Is the server running?
+ if(error == KErrNotFound)
+ {
+ return;
+ }
+ LEAVE_IF_ERROR(error);
+
+ // Make the server transient
+ TInt p0 = 1;
+ TIpcArgs ipcArgs(p0);
+ LEAVE_IF_ERROR(logServSession.Send(ELogMakeTransient, ipcArgs));
+
+ logServSession.Close();
+
+ User::After(6 * 1000000); // Enough time for the server to exit
+ }
+#else//_DEBUG
+static void StopLogServerL()
+ {
+ RDebug::Print(_L("StopLogServerL(): the LogEng server cannot be stopped in release mode. ELogMakeTransient is a debug message.\n"));
+ }
+#endif//_DEBUG
+
+/**
+@SYMTestCaseID PDS-LOGENG-UT-4047
+@SYMTestCaseDesc Configuration value update test.
+ The test changes the configuration values & thne stops the log server. Start the
+ server again & check if the configuration values are updated.
+ Again restores the original value back.
+@SYMTestActions Configuration value update test.
+@SYMTestExpectedResults Test must not fail
+@SYMTestPriority Medium
+@SYMREQ DEF142142
+*/
+void DoCheckUpdateConfigL()
+ {
+
+ CLogClient* client = CLogClient::NewL(theFs);
+ CleanupStack::PushL(client);
+ CTestActive* active = new(ELeave)CTestActive();
+ CleanupStack::PushL(active);
+
+ //Check for updated configurations.
+ TLogConfig config;
+ active->StartL();
+ client->GetConfig(config, active->iStatus);
+ CActiveScheduler::Start();
+ TEST2(active->iStatus.Int(), KErrNone);
+
+ //Set new max log size
+ TLogSize tmpMaxLogSize = config.iMaxLogSize;
+ config.iMaxLogSize = KMaxLogSize;
+ config.iMaxRecentLogSize = KMaxRecentLogSize;
+ active->StartL();
+ client->ChangeConfig(config, active->iStatus);
+ CActiveScheduler::Start();
+ TEST2(active->iStatus.Int(), KErrNone);
+
+ //Stop the Server
+ StopLogServerL();
+
+ //Test the new max log size
+ active->StartL();
+ client->GetConfig(config, active->iStatus);
+ CActiveScheduler::Start();
+ TEST2(active->iStatus.Int(), KErrNone);
+ TEST2(config.iMaxLogSize, KMaxLogSize);
+
+ //Set original max log size
+ config.iMaxLogSize = tmpMaxLogSize;
+ active->StartL();
+ client->ChangeConfig(config, active->iStatus);
+ CActiveScheduler::Start();
+ TEST2(active->iStatus.Int(), KErrNone);
+
+ CleanupStack::PopAndDestroy(active);
+ CleanupStack::PopAndDestroy(client);
+ }
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////
+#ifdef SYSLIBS_TEST
+
+TLogId DoAddEvent2TestRecentListL(CLogClient& aClient, CTestActive& aActive)
+ {
+ CLogEvent* event = CLogEvent::NewL();
+ CleanupStack::PushL(event);
+
+ event->SetEventType(KLogCallEventTypeUid);
+ event->SetRemoteParty(KLogRctTListRemoteParty);
+ event->SetDirection(KLogRctTListDirection);
+ event->SetDurationType(KLogRctTListDurationType);
+ event->SetDuration(KTestDuration1);
+ event->SetStatus(KLogRctTListStatus);
+ event->SetSubject(KTestSubject1);
+ event->SetNumber(KLogRctTListNumber);
+ event->SetContact(KEvContact1);
+ event->SetLink(KEvLink1);
+ event->SetDescription(KEvDesc1);
+ event->SetFlags(KLogRctTListFlags);
+ event->SetDataL(KTestData1);
+#ifdef SYMBIAN_ENABLE_EVENTLOGGER_DUALSIM
+ event->SetSimId(KLogRctTListSimId);
+#endif
+
+ aActive.StartL();
+ aClient.AddEvent(*event, aActive.iStatus);
+ CActiveScheduler::Start();
+ TEST(!aActive.IsActive());
+ TEST2(aActive.iStatus.Int(), KErrNone);
+ TLogId logId = event->Id();
+
+ //Get the just added event
+ aActive.StartL();
+ aClient.GetEvent(*event, aActive.iStatus);
+ CActiveScheduler::Start();
+ TEST2(aActive.iStatus.Int(), KErrNone);
+
+ CleanupStack::PopAndDestroy(event);
+
+ return logId;
+ }
+
+TLogId DoAddEvent2TestRecentListL()
+ {
+ CLogClient* client = CLogClient::NewL(theFs);
+ CleanupStack::PushL(client);
+ CTestActive* active = new(ELeave)CTestActive();
+ CleanupStack::PushL(active);
+
+ TLogId logId = DoAddEvent2TestRecentListL(*client, *active);
+
+ CleanupStack::PopAndDestroy(active);
+ CleanupStack::PopAndDestroy(client);
+
+ return logId;
+ }
+
+struct TLogViewTestObserver : public MLogViewChangeObserver
+ {
+ TLogViewTestObserver() :
+ iIdAdded(-1),
+ iIdChanged(-1),
+ iIdDeleted(-1)
+ {
+ }
+ virtual void HandleLogViewChangeEventAddedL(TLogId aId, TInt, TInt, TInt)
+ {
+ iIdAdded = aId;
+ }
+ virtual void HandleLogViewChangeEventChangedL(TLogId aId, TInt, TInt, TInt)
+ {
+ iIdChanged = aId;
+ }
+ virtual void HandleLogViewChangeEventDeletedL(TLogId aId, TInt, TInt, TInt)
+ {
+ iIdDeleted = aId;
+ }
+ TLogId iIdAdded;
+ TLogId iIdChanged;
+ TLogId iIdDeleted;
+ };
+
+void DoViewEventFromTestRecentListL(TLogId aId1, TLogId aId2)
+ {
+ CLogClient* client = CLogClient::NewL(theFs);
+ CleanupStack::PushL(client);
+ CTestActive* active = new(ELeave)CTestActive();
+ CleanupStack::PushL(active);
+ CLogViewRecent* view = CLogViewRecent::NewL(*client);
+ CleanupStack::PushL(view);
+ TLogViewTestObserver observer;
+ CLogViewDuplicate* duplicate = CLogViewDuplicate::NewL(*client, observer);
+ CleanupStack::PushL(duplicate);
+
+ TBool rc = view->SetRecentListL(KLogRctTListId, active->iStatus);
+ active->StartL();
+ CActiveScheduler::Start();
+ TEST2(active->iStatus.Int(), KErrNone);
+
+ TInt count = 0;
+ if(view->FirstL(active->iStatus))
+ {
+ do
+ {
+ active->StartL();
+ CActiveScheduler::Start();
+ TEST2(active->iStatus.Int(), KErrNone);
+ const CLogEvent& e = view->Event();
+ TEST2(aId2, e.Id());
+ ++count;
+ }
+ while(view->NextL(active->iStatus));
+ }
+ TEST2(count, 1);//The second event is a duplicate => not in the list
+
+ //Check duplicates
+ active->StartL();
+ rc = view->DuplicatesL(*duplicate, active->iStatus);
+ TEST(rc);
+ CActiveScheduler::Start();
+ TEST2(active->iStatus.Int(), KErrNone);
+ TEST2(duplicate->CountL(), 1);
+
+ //Test the duplicated event
+ rc = duplicate->FirstL(active->iStatus);
+ TEST(rc);
+ active->StartL();
+ CActiveScheduler::Start();
+ TEST2(active->iStatus.Int(), KErrNone);
+ const CLogEvent& e2 = duplicate->Event();
+ TEST2(aId1, e2.Id());
+
+ //Get the event
+ CLogEvent* event = CLogEvent::NewL();
+ CleanupStack::PushL(event);
+ event->SetId(aId1);
+ active->StartL();
+ client->GetEvent(*event, active->iStatus);
+ CActiveScheduler::Start();
+ TEST2(active->iStatus.Int(), KErrNone);
+
+ //Change the event. The observer should register the change.
+ event->SetDataL(_L8("123444555"));
+ client->ChangeEvent(*event, active->iStatus);
+ active->StartL();
+ CActiveScheduler::Start();
+ TEST2(active->iStatus.Int(), KErrNone);
+ TEST2(observer.iIdChanged, event->Id());
+
+ //Add a new event to the recent list. This operation should be detected as a "delete" one by the observer
+ //and the existing event should be cleared from the recent list.
+ TLogId logId = DoAddEvent2TestRecentListL(*client, *active);
+ TEST2(observer.iIdDeleted, aId1);
+ TEST(logId != observer.iIdDeleted);
+ //No added events detected by the observer
+ TEST2(observer.iIdAdded, -1);
+
+ //Cleanup
+ CleanupStack::PopAndDestroy(event);
+ CleanupStack::PopAndDestroy(duplicate);
+ CleanupStack::PopAndDestroy(view);
+ CleanupStack::PopAndDestroy(active);
+ CleanupStack::PopAndDestroy(client);
+ }
+
+/**
+@SYMTestCaseID PDS-LOGENG-UT-4035
+@SYMTestCaseDesc Complex recent list test.
+ The test works only if SYSLIBS_TEST macro is defined, in which case the server side will
+ create a recent list with a lot of fields.
+ The test case will add 2 events with the same properties, such that both will be added
+ to that test recent list. Because the second event is a match of the first one and matches
+ the recent list "duplicates" mask, the second event will be marked as a duplicate of the
+ first one. After adding the events a view is used to check for their presence.
+@SYMTestActions Complex recent list test.
+@SYMTestExpectedResults Test must not fail
+@SYMTestPriority Medium
+@SYMREQ REQ12747
+*/
+void ComplexRecentListTestL()
+ {
+ TLogId logId1 = DoAddEvent2TestRecentListL();
+ TLogId logId2 = DoAddEvent2TestRecentListL();
+ DoViewEventFromTestRecentListL(logId1, logId2);
+ }
+
+#endif//SYSLIBS_TEST
+//////////////////////////////////////////////////////////////////////////////////////////////////////
+
+void doTestsL()
+ {
+ TestUtils::DeleteDatabaseL();
+ //
+ test.Start(_L("Preparation. Adding 200 events..."));
+ DoAddEventsL();
+ test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4029: AddEvent() server side OOM test when logged events count is max (200)"));
+ AddEventOomTestL(ELogOpAddEvent, KErrNone);
+ test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4029: AddEvent() server side OOM test when logged events count is max (200). Invalid event type."));
+ AddEventOomTestL(ELogOpAddEventInvalidType, KErrNotFound);
+ test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4030: AddEvent() server side OOM test when logged events count is max (200). Logging disabled."));
+ AddEventOomTestL(ELogOpAddEventLoggingDisabled, KErrNotSupported);
+ test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4030: ChangeEvent() server side OOM test when logged events count is max (200). The event does exist."));
+ ChangeEventOomTestL(ETrue);
+ test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4030: ChangeEvent() server side OOM test when logged events count is max (200). The event does not exist."));
+ ChangeEventOomTestL(EFalse);
+ test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4032: GetEvent() server side OOM test when logged events count is max (200)."));
+ GetEventOomTestL(ELogOpGetEvent, KErrNone);
+ test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4032: GetEvent() server side OOM test when logged events count is max (200). The event does not exist."));
+ GetEventOomTestL(ELogOpGetEventNotExists, KErrNotFound);
+ test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4032: GetEvent() server side OOM test when logged events count is max (200). The event id is 0."));
+ GetEventOomTestL(ELogOpGetEventZeroId, KErrNotFound);
+ test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4031: DeleteEvent() server side OOM test when logged events count is max (200). The event does exist."));
+ DeleteEventOomTestL(ETrue);
+ test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4031: DeleteEvent() server side OOM test when logged events count is max (200). The event does not exist."));
+ DeleteEventOomTestL(EFalse);
+ test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4033: Attempt to change one of the standard event types."));
+ ChangeStandardEventTypeTestL();
+ test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4042: \"Cancel Operation\" test"));
+ CancelOperationTest();
+ test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4034: Complex filter set test."));
+ ComplexFilterSetTestL();
+ test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4047: Check for updated configuration values"));
+ DoCheckUpdateConfigL();
+#ifdef SYSLIBS_TEST
+ test.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4035: Complex recent list test."));
+ ComplexRecentListTestL();
+#endif
+ //
+ TestUtils::DeleteDatabaseL();
+ }