// 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