// Copyright (c) 2005-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:

//

#include <s32file.h>

#include <logcntdef.h>

#include "t_logutil2.h"

#include <logview.h>

//LOWCAP defined in t_loglowcapability.mmp file.

#ifdef LOWCAP

    TBool TheHiCapability = EFalse;

    RTest TheTest(_L("t_loglowcapability"));

    _LIT(KTestTitle, "t_loglowcapability");

#else

    TBool TheHiCapability = ETrue;

    RTest TheTest(_L("t_loghicapability"));

    _LIT(KTestTitle, "t_loghicapability");

#endif

const TUid KTestEventUid = {0x10005393};

_LIT(KTestEventDesc1, "Event Type Description");

_LIT(KTestEventDesc2, "Changed Event Description");

_LIT(KTestRemoteParty1, "Remote Party");

_LIT(KTestDirection1, "Direction");

const TLogDurationType KTestDurationType1 = 1;

const TLogDuration KTestDuration1 = 0x1234;

_LIT(KTestStatus1, "Status");

_LIT(KTestSubject1, "Subject");

_LIT(KTestNumber1, "Number");

const TLogContactItemId KTestContact1 = 0x1234;

const TLogContactItemId KTestContact2 = 0x1234567;

const TLogLink KTestLink1 = 0x1234;

_LIT8(KTestData1, "ABCDEFGH");

const TLogSize KTestMaxLogSize = 0xFFF;

const TLogRecentSize KTestMaxRecentLogSize = 0xF;

const TLogAge KTestMaxEventAge = 0xFFFFFFF;

/**

@SYMTestCaseID SYSLIB-LOGENG-CT-0118

@SYMTestCaseDesc The test aims to ensure that the log server starts in reponse 

to a client request.

@SYMTestPriority High

@SYMTestActions The test asks the server for details of a built in event type.

A successful server start-up is essential for the completion of subsequent tests.

@SYMTestExpectedResults Success. (active->iStatus == 0) Regardless of the capability 

of the process running this test, it should always succeed because the GetEventType 

is not policed by platform security.

@SYMREQ REQ3431

*/

LOCAL_C void TestStartupL()

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0118 "));

	CLogClient* client = CLogClient::NewL(theFs);

	CleanupStack::PushL(client);

	CTestActive* active = new(ELeave)CTestActive();

	CleanupStack::PushL(active);

	CLogEventType *type = CLogEventType::NewL();

	CleanupStack::PushL(type);

	type->SetUid(KLogCallEventTypeUid);

	active->StartL();

	client->GetEventType(*type, active->iStatus);

	CActiveScheduler::Start();

	TEST2(active->iStatus.Int(), KErrNone);

	CleanupStack::PopAndDestroy(3); // client, active, type

	}

/**

@SYMTestCaseID SYSLIB-LOGENG-CT-0119

@SYMTestCaseDesc Tests AddEvent, GetEvent, ChangeEvent and DeleteEvent.

@SYMTestPriority High

@SYMTestActions See the description and expected results.

@SYMTestExpectedResults 

1. a client with sufficient capability succeed in all cases would expect the following...

AddEvent - KErrNone

GetEvent - KErrNone

ChangeEvent - KErrNone

DeleteEvent - KErrNone

2. a client with insufficient capability would expect the following results...

AddEvent - KErrPermissionDenied

GetEvent - KErrNone

ChangeEvent - KErrPermissionDenied

DeleteEvent - KErrPermissionDenied

@SYMREQ REQ3431

*/

LOCAL_C void TestBasicL(CLogClient& aClient)

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0119 "));

	CTestActive* active = new(ELeave)CTestActive();

	CleanupStack::PushL(active);

	CLogEvent* event = CLogEvent::NewL();

	CleanupStack::PushL(event);

	TTime now;

	now.UniversalTime();

	event->SetEventType(KLogCallEventTypeUid);

	active->StartL();

	aClient.AddEvent(*event, active->iStatus);

	CActiveScheduler::Start();

	TEST2(active->iStatus.Int(), TheHiCapability ? KErrNone : KErrPermissionDenied);

	if(!TheHiCapability)

		{

		TInt eventId = TestUtils::AddEventL();

		TEST(eventId >= 0);

		event->SetId(eventId);

		}

	TEST(event->EventType() == KLogCallEventTypeUid);

	now = event->Time();

	TLogId id = event->Id();

	event->SetRemoteParty(KTestRemoteParty1);

	event->SetDirection(KTestDirection1);

	event->SetDurationType(KTestDurationType1);

	event->SetDuration(KTestDuration1);

	event->SetStatus(KTestStatus1);

	event->SetSubject(KTestSubject1);

	event->SetNumber(KTestNumber1);

	event->SetContact(KTestContact1);

	event->SetLink(KTestLink1);

	event->SetDataL(KTestData1);

	active->StartL();

	aClient.ChangeEvent(*event, active->iStatus);

	CActiveScheduler::Start();

    TheTest.Printf(_L("TestBasicL(), TheHiCapability=%d, event id=%d\r\n"), TheHiCapability, id);

	TEST2(active->iStatus.Int(), TheHiCapability ? KErrNone : KErrPermissionDenied);

	TEST(event->Id() == id );

	TEST(event->EventType() == KLogCallEventTypeUid);

	if(TheHiCapability)

		{

		TEST(event->Description().Length() > 0);

		TEST(event->Time() == now);

		TEST(event->RemoteParty() == KTestRemoteParty1);

		TEST(event->Direction() == KTestDirection1);

		TEST(event->DurationType() == KTestDurationType1);

		TEST(event->Duration() == KTestDuration1);

		TEST(event->Status() == KTestStatus1);

		TEST(event->Subject() == KTestSubject1);

		TEST(event->Number() == KTestNumber1);

		TEST(event->Contact() == KTestContact1);

		TEST(event->Link() == KTestLink1);

		TEST(event->Data() == KTestData1);

		}

	CleanupStack::PopAndDestroy(); // event;

	event = CLogEvent::NewL();

	CleanupStack::PushL(event);

	event->SetId(id);

	active->StartL();

	aClient.GetEvent(*event, active->iStatus);

	CActiveScheduler::Start();

	TEST2(active->iStatus.Int(), TheHiCapability ? KErrNone : KErrPermissionDenied);

	if(TheHiCapability)

		{

		TEST(event->Id() == id);

		TEST(event->EventType() == KLogCallEventTypeUid);

		TEST(event->Description().Length() > 0);

		TEST(event->Time() == now);

		TEST(event->RemoteParty() == KTestRemoteParty1);

		TEST(event->Direction() == KTestDirection1);

		TEST(event->DurationType() == KTestDurationType1);

		TEST(event->Duration() == KTestDuration1);

		TEST(event->Status() == KTestStatus1);

		TEST(event->Subject() == KTestSubject1);

		TEST(event->Number() == KTestNumber1);

		TEST(event->Contact() == KTestContact1);

		TEST(event->Link() == KTestLink1);

		TEST(event->Data() == KTestData1);

		}

	active->StartL();

	aClient.DeleteEvent(id, active->iStatus);

	CActiveScheduler::Start();

	TEST2(active->iStatus.Int(), TheHiCapability ? KErrNone : KErrPermissionDenied);

	active->StartL();

	aClient.GetEvent(*event, active->iStatus);

	CActiveScheduler::Start();

	TEST2(active->iStatus.Int(), TheHiCapability ? KErrNotFound : KErrPermissionDenied);

	// try to delete a non-existent event...

	active->StartL();

	aClient.DeleteEvent(123, active->iStatus);

	CActiveScheduler::Start();

	TEST2(active->iStatus.Int(), KErrNotFound);

	CleanupStack::PopAndDestroy(2); // event, active

	}

/**

@SYMTestCaseID SYSLIB-LOGENG-CT-0120

@SYMTestCaseDesc Test AddEventType for high and low capability clients

@SYMTestPriority High

@SYMTestActions 

1.  For a clients of all capabilities...

	a. Add a new event type

	b. Fill a CLogEventType object with details of the new type

	c. Try to add the new event type for a second time 

@SYMTestExpectedResults 

1.  For a client with sufficient capability...

	Test a. - KErrNone - the new event type was added OK

	Test b. - KErrNone - the new event type is fully visible

	Test c. - KErrAlreadyExists - it was already added by test a. !

2.  For a client with insufficient capability...

	Test a. - KErrPermissionDenied - not allowed !

	Test b. - KErrNotFound - allowed, but it isn't there because test a. failed.

	Test c. - KErrPermissionDenied - exactly the same as test a.

@SYMREQ REQ3431

*/

LOCAL_C void TestAddEventTypeL(CLogClient& aClient)

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0120 "));

	CLogEventType* type = CLogEventType::NewL();

	CleanupStack::PushL(type);

	type->SetUid(KTestEventUid);

	type->SetDescription(KTestEventDesc1);

	type->SetLoggingEnabled(ETrue);

	CTestActive* active = new(ELeave)CTestActive();

	CleanupStack::PushL(active);

	aClient.AddEventType(*type, active->iStatus);

	active->StartL();

	CActiveScheduler::Start();

	TEST2(active->iStatus.Int(), TheHiCapability ? KErrNone : KErrPermissionDenied);

	active->StartL();

	aClient.GetEventType(*type, active->iStatus);

	CActiveScheduler::Start();

	TEST2(active->iStatus.Int(), TheHiCapability ? KErrNone : KErrNotFound);

	active->StartL();

	aClient.AddEventType(*type, active->iStatus);

	CActiveScheduler::Start();

	TEST2(active->iStatus.Int(), TheHiCapability ? KErrAlreadyExists : KErrPermissionDenied);

	CleanupStack::PopAndDestroy(2); // active, type

	}

/**

@SYMTestCaseID SYSLIB-LOGENG-CT-0121

@SYMTestCaseDesc Try to populate an CLogEventType object with details of a 

non built-in event type.

@SYMTestPriority High

@SYMTestActions Calls GetEventType(...)

@SYMTestExpectedResults Always succeeds - all clients should be able to do this as

the GetEventType operation is not policed by platform security.

@SYMREQ REQ3431

*/

LOCAL_C void TestGetEventTypeL(CLogClient& aClient)

	//

	// This test should succeed, regardless of capability

	// GetEventType is not policed.

	//

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0121 "));

	CLogEventType* type = CLogEventType::NewL();

	CleanupStack::PushL(type);

	type->SetUid(KTestEventUid);

	CTestActive* active = new(ELeave)CTestActive();

	CleanupStack::PushL(active);

	aClient.GetEventType(*type, active->iStatus);

	active->StartL();

	CActiveScheduler::Start();

	TEST2(active->iStatus.Int(), KErrNone);

	TEST(type->Uid() == KTestEventUid);

	TEST(type->Description() == KTestEventDesc1);

	TEST(type->LoggingEnabled());

	CleanupStack::PopAndDestroy(2); // active, type

	}

/**

@SYMTestCaseID SYSLIB-LOGENG-CT-0122

@SYMTestCaseDesc Tries to change existing event types.

@SYMTestActions See the description and expected results.

@SYMTestPriority High

@SYMTestExpectedResults Should always succeed

@SYMREQ REQ3431

*/

LOCAL_C void TestChangeEventTypeL(CLogClient& aClient)

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0122 "));

	CTestActive* active = new(ELeave)CTestActive();

	CleanupStack::PushL(active);

	CLogEventType* type = CLogEventType::NewL();

	CleanupStack::PushL(type);

	type->SetUid(KTestEventUid);

	type->SetDescription(KTestEventDesc1);

	type->SetDescription(KTestEventDesc2);

#ifdef _DEBUG

	TInt failCount = 0;

#endif

	TBool finished = EFalse;

	TInt error;

	while(!finished)

		{

		error = KErrNone;

		type->SetDescription(KTestEventDesc2);

		type->SetLoggingEnabled(EFalse);

		__UHEAP_FAILNEXT(failCount++);

		aClient.ChangeEventType(*type, active->iStatus);

		active->StartL();

		CActiveScheduler::Start();

		if (active->iStatus == KErrNone)

			finished = ETrue;

		else

			error = active->iStatus.Int();

		__UHEAP_RESET;

		if (error == KErrNoMemory)

			{

			active->StartL();

			aClient.GetEventType(*type, active->iStatus);

			CActiveScheduler::Start();

			TEST2(active->iStatus.Int(), KErrNone);

			TEST(type->Description() == KTestEventDesc1);

			TEST(type->LoggingEnabled());

			}

		else

			{

			TEST2(error, TheHiCapability ? KErrNone : KErrPermissionDenied);

			if(!TheHiCapability)

				finished = TRUE;

			}

		}

	type->SetUid(KTestEventUid);

	active->StartL();

	aClient.GetEventType(*type, active->iStatus);

	CActiveScheduler::Start();

	TEST2(active->iStatus.Int(), KErrNone);

	if(TheHiCapability)

		{

		TEST(type->Uid() == KTestEventUid);

		TEST(type->Description() == KTestEventDesc2);

		TEST(type->LoggingEnabled() == EFalse);

		}

	else

		{

		TEST(type->Uid() == KTestEventUid);

		TEST(type->Description() == KTestEventDesc1);

		TEST(type->LoggingEnabled());

		}

	CleanupStack::PopAndDestroy(2); // type, active

	}

/**

@SYMTestCaseID SYSLIB-LOGENG-CT-0123

@SYMTestCaseDesc Delete event types

@SYMTestActions See the description and expected results.

@SYMTestPriority High

@SYMTestExpectedResults Should always succeed

@SYMREQ REQ3431

*/

LOCAL_C void TestDeleteEventTypeL(CLogClient& aClient)

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0123 "));

	CTestActive* active = new(ELeave)CTestActive();

	CleanupStack::PushL(active);

	CLogEventType* type = CLogEventType::NewL();

	CleanupStack::PushL(type);

	type->SetUid(KTestEventUid);

#ifdef _DEBUG

	TInt failCount = 0;

#endif

	TBool finished = EFalse;

	TInt error;

	while(!finished)

		{

		error = KErrNone;

		__UHEAP_FAILNEXT(failCount++);

		aClient.DeleteEventType(KTestEventUid, active->iStatus);

		active->StartL();

		CActiveScheduler::Start();

		if (active->iStatus == KErrNone)

			finished = ETrue;

		else

			error = active->iStatus.Int();

		__UHEAP_RESET;

		if (error == KErrNoMemory)

			{

			active->StartL();

			aClient.GetEventType(*type, active->iStatus);

			CActiveScheduler::Start();

			TEST2(active->iStatus.Int(), KErrNone);

			}

		else

			{

			TEST2(error, TheHiCapability ? KErrNone : KErrPermissionDenied);

			if(!TheHiCapability)

				finished = TRUE;

			}

		}

	active->StartL();

	aClient.GetEventType(*type, active->iStatus);

	CActiveScheduler::Start();

	TEST2(active->iStatus.Int(), TheHiCapability ? KErrNotFound : KErrNone);

	CleanupStack::PopAndDestroy(2); // type, active

	}

/**

@SYMTestCaseID SYSLIB-LOGENG-CT-0124

@SYMTestCaseDesc Try to delete built in event types

@SYMTestPriority High

@SYMTestActions No one is allowed to delete built in event types !

@SYMTestExpectedResults Should always succeed

@SYMREQ REQ3431

*/

LOCAL_C void TestDeleteBuiltInEventTypeL(CLogClient& aClient)

	{

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0124 "));

	CTestActive* active = new(ELeave)CTestActive();

	CleanupStack::PushL(active);

	CLogEventType* type = CLogEventType::NewL();

	CleanupStack::PushL(type);

	TUid someBuiltInTypes [] = 

		{

		KLogCallEventTypeUid, 

		KLogDataEventTypeUid, 

		KLogFaxEventTypeUid

		};

	for (TInt i=0; i < 3; i++)

		{

		aClient.DeleteEventType(someBuiltInTypes [i], active->iStatus);

		active->StartL();

		CActiveScheduler::Start();

		TEST2(active->iStatus.Int(), KErrPermissionDenied);

		type->SetUid(someBuiltInTypes [i]);

		active->StartL();

		aClient.GetEventType(*type, active->iStatus);

		CActiveScheduler::Start();

		TEST2(active->iStatus.Int(), KErrNone);