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