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