// Copyright (c) 2009-2010 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 "t_logutil2.h"
#include "LogServSqlStrings.h"

RTest TheTest(_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();
	
	TheTest.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)
			{
			TheTest.Printf(_L("%d\r"), i);
			}
		}
	TheTest.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);
	TheTest.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);
	
	TheTest.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);
	
	TheTest.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);
	
	TheTest.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);
	
	TheTest.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();
	TheTest.Printf(_L("===Events count: %d\n"), count);
	TTime end_time;
	end_time.UniversalTime();
	TTimeIntervalMicroSeconds us = end_time.MicroSecondsFrom(st_time);
	TheTest.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);
	TheTest.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()
    {
    TheTest.Printf(_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::Initialize(_L("t_logapi2"));
	TestUtils::DeleteDatabaseL();
	//
	TheTest.Start(_L("Preparation. Adding 200 events..."));
	DoAddEventsL();
	TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4029: AddEvent() server side OOM test when logged events count is max (200)"));
	AddEventOomTestL(ELogOpAddEvent, KErrNone);
	TheTest.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);
	TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4030: AddEvent() server side OOM test when logged events count is max (200). Logging disabled."));
	AddEventOomTestL(ELogOpAddEventLoggingDisabled, KErrNotSupported);
	TheTest.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);
	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."));
	ChangeEventOomTestL(EFalse);
	TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4032: GetEvent() server side OOM test when logged events count is max (200)."));
	GetEventOomTestL(ELogOpGetEvent, KErrNone);
	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."));
	GetEventOomTestL(ELogOpGetEventNotExists, KErrNotFound);
	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."));
	GetEventOomTestL(ELogOpGetEventZeroId, KErrNotFound);
	TheTest.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);
	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."));
	DeleteEventOomTestL(EFalse);
	TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4033: Attempt to change one of the standard event types."));
	ChangeStandardEventTypeTestL();
	TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4042: \"Cancel Operation\" test"));
	CancelOperationTest();
	TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4034: Complex filter set test."));
	ComplexFilterSetTestL();
	TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4047: Check for updated configuration values"));
	DoCheckUpdateConfigL();
#ifdef SYSLIBS_TEST
	TheTest.Next(_L(" @SYMTestCaseID:PDS-LOGENG-UT-4035: Complex recent list test."));
	ComplexRecentListTestL();
#endif
	//
	TestUtils::DeleteDatabaseL();
	}