// Copyright (c) 2002-2009 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 <e32math.h>

#include <logview.h>

#include <s32mem.h> 

#include "TEST.H"

#define UNUSED_VAR(a) a = a

#undef test  //there is a "test" macro which hides "RTest test" declaration.

const TLogContactItemId KTestContact = 0x1234;

const TInt KTestEventNum = 10;

RTest test(_L("Log Client Basic API Test Harness"));

const TUid KTestEventUid = {0x10005393};

_LIT(KTestEventDesc1, "Event Type Description");

_LIT(KTestEventDesc2, "Changed Event Description");

_LIT(KTestRemoteParty1, "Remote Party");

_LIT(KTestRemoteParty2, "Changed Remote Party");

_LIT(KTestDirection1, "Direction");

_LIT(KTestDirection2, "Changed Direction");

const TLogDurationType KTestDurationType1 = 1;

const TLogDurationType KTestDurationType2 = 2;

const TLogDuration KTestDuration1 = 0x1234;

const TLogDuration KTestDuration2 = 0x1234567;

_LIT(KTestStatus1, "Status");

_LIT(KTestStatus2, "Changed Status");

_LIT(KTestSubject1, "Subject");

_LIT(KTestSubject2, "Changed Subject");

_LIT(KTestNumber1, "TheNumber");

_LIT(KTestNumber2, "Changed Number");

const TLogContactItemId KTestContact1 = 0x1234;

const TLogContactItemId KTestContact2 = 0x1234567;

const TLogLink KTestLink1 = 0x1234;

const TLogLink KTestLink2 = 0x1234567;

_LIT8(KTestData1, "ABCDEFGH");

_LIT8(KTestData2, "IJKLMNOPQRSTUVWXYZ");

const TLogFlags KTestFlags1 = 0x5;

const TLogFlags KTestFlags2 = 0xA;

const TLogSize KTestMaxLogSize = 0xFFF;

const TLogRecentSize KTestMaxRecentLogSize = 0xF;

const TLogAge KTestMaxEventAge = 0xFFFFFFF;

TInt gTheId;

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////  Thread panic macros   ////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

static void ThrCheck1(TInt aValue, TInt aLine)

	{

	if(!aValue)

		{

		RDebug::Print(_L("*** Line %d. Boolean expression evaluated to false!\r\n"), aLine);

		User::Panic(_L("ThrChk1"), 1);

		}

	}

static void ThrCheck2(TInt aValue, TInt aExpected, TInt aLine)

	{

	if(aValue != aExpected)

		{

		RDebug::Print(_L("*** Line %d. Expected error: %d, got: %d\r\n"), aLine, aExpected, aValue);

		User::Panic(_L("ThrChk2"), 2);

		}

	}

#define TTEST(arg) ThrCheck1((arg), __LINE__)

#define TTEST2(aValue, aExpected) ThrCheck2(aValue, aExpected, __LINE__)

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

class TClientObserverTestReceiver : public MLogClientChangeObserver

	{

public:

	TClientObserverTestReceiver(TBool& aFlag) : iCallCount(0), iFlag(aFlag) { }

public:

	void HandleLogClientChangeEventL(TUid aChangeType, TInt /*aChangeParam1*/, TInt /*aChangeParam2*/, TInt /*aChangeParam3*/)

		{

		++iCallCount;

		iFlag = (aChangeType == KLogClientChangeEventLogCleared);

		}

	inline TInt CallCount() const { return iCallCount; }

	inline void Reset() { iCallCount = 0; iFlag = EFalse; }

private:

	TInt iCallCount;

	TBool& iFlag;

	};

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0833

@SYMTestCaseDesc	    Client observer mechanism test

@SYMTestPriority 	    High

@SYMTestActions  	    Set the change observer,add an event type,clear the log and test for the status.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestClientObserverMechanismL(CLogClient& aClient)

	{	

	//

	TBool logClearedFlag = EFalse;

	TClientObserverTestReceiver testReceiver(logClearedFlag);

	//

	aClient.SetGlobalChangeObserverL(&testReceiver);

	TTime now;

	now.UniversalTime();

	TTime clearLogThreshold(now);

	clearLogThreshold -= TTimeIntervalDays(1);

	TTime past(now);

	past -= TTimeIntervalDays(2);

	// Make some events

	CLogEvent* event = CLogEvent::NewL();

	CleanupStack::PushL(event);

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

	CleanupStack::PushL(active);

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

		{

		event->SetEventType(KLogCallEventTypeUid);

		event->SetRemoteParty(KTestRemoteParty1);

		event->SetDirection(KTestDirection1);

		event->SetDurationType(KTestDurationType1);

		event->SetDuration(KTestDuration1);

		event->SetStatus(KTestStatus1);

		event->SetSubject(KTestSubject1);

		event->SetNumber(KTestNumber1);

		event->SetContact((TLogContactItemId) i+1);

		event->SetLink(KTestLink1);

		event->SetDataL(KTestData1);

		event->SetFlags(KTestFlags1);

		// Add event

		active->StartL();

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

		CActiveScheduler::Start();

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

		// Make it in the past

		event->SetTime(past);

		active->StartL();

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

		CActiveScheduler::Start();

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

		}

	TEST2(testReceiver.CallCount(), 0);

	// Clear the log

	active->StartL();

	aClient.ClearLog(clearLogThreshold, active->iStatus);

	CActiveScheduler::Start();

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

	// Have to wait a while, since the change observer active object

	// won't run until shortly after completing the 'clear log' operation

	// request status.

	CTestTimer* timer = CTestTimer::NewL();

	CleanupStack::PushL(timer);

	timer->After(5 * 1000000);

	CActiveScheduler::Start();

	CleanupStack::PopAndDestroy(timer);

	//

	TEST2(testReceiver.CallCount(), 1);

	TEST(logClearedFlag);

	// Start again

	testReceiver.Reset();

	// Test removing observer

	aClient.SetGlobalChangeObserverL(NULL);

	// Add an event again

	active->StartL();

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

	CActiveScheduler::Start();

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

	TEST2(testReceiver.CallCount(), 0);

	// Make it in the past

	event->SetTime(past);

	active->StartL(); 

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

	CActiveScheduler::Start();

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

	// Clear the log again

	active->StartL();

	aClient.ClearLog(clearLogThreshold, active->iStatus);

	CActiveScheduler::Start();

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

	TEST2(testReceiver.CallCount(), 0);

	TEST(logClearedFlag == EFalse);

	aClient.SetGlobalChangeObserverL(&testReceiver);

	// Tidy up

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

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0834

@SYMTestCaseDesc	    Adding an event to the log engine test.

@SYMTestPriority 	    High

@SYMTestActions  	    Create a new event type and add that to the log engine.

                        Start an active scheduler and check for the  error status.

                        Add the event once again and check for the already exits condition.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestAddEventTypeL(CLogClient& aClient)

//

//

//

	{

	LOGTEXT("TestAddEventTypeL()");	

	CLogEventType* type = CLogEventType::NewL();

	CleanupStack::PushL(type);

	type->SetUid(KTestEventUid);

	type->SetDescription(KTestEventDesc1);

	type->SetLoggingEnabled(ETrue);

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

	CleanupStack::PushL(active);

	active->StartL();

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

	aClient.Cancel();

	CActiveScheduler::Start();

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

	active->StartL();

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

	CActiveScheduler::Start();

	aClient.Cancel();

	TEST((active->iStatus == KErrNone)||(active->iStatus == KErrAlreadyExists));

	active->StartL();

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

	CActiveScheduler::Start();

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

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

	LOGTEXT("TestAddEventTypeL() - end");

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0835

@SYMTestCaseDesc	    Retrieving the event type information test.

                        Tests for CLogClient::GetEventType() function.

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for the retrieved information of event type. 

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestGetEventTypeL(CLogClient& aClient)

//

//

//

	{

	LOGTEXT("TestGetEventTypeL()");	

	CLogEventType* type = CLogEventType::NewL();

	CleanupStack::PushL(type);

	type->SetUid(KTestEventUid);

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

	CleanupStack::PushL(active);

	active->StartL();

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

	aClient.Cancel();

	CActiveScheduler::Start();

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

	active->StartL();

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

	CActiveScheduler::Start();

	aClient.Cancel();

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

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

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

	TEST(type->LoggingEnabled());

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

	LOGTEXT("TestGetEventTypeL() - end");

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0836

@SYMTestCaseDesc	    Changing the event type test.

                        Tests for CLogClient::ChangeEventType test

@SYMTestPriority 	    High

@SYMTestActions  	    Create a new event type,change the event type and check for any errors

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestChangeEventTypeL(CLogClient& aClient)

//

//

//

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0836 "));

	LOGTEXT("TestChangeEventTypeL()");	

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

	CleanupStack::PushL(active);

	CLogEventType* type = CLogEventType::NewL();

	CleanupStack::PushL(type);

	type->SetUid(KTestEventUid);

	type->SetDescription(KTestEventDesc2);

	type->SetLoggingEnabled(EFalse);

	active->StartL();

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

	aClient.Cancel();

	CActiveScheduler::Start();

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

	active->StartL();

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

	CActiveScheduler::Start();

	aClient.Cancel();

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

	CleanupStack::PopAndDestroy(); // type

	type = CLogEventType::NewL();

	CleanupStack::PushL(type);

	type->SetUid(KTestEventUid);

	active->StartL();

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

	CActiveScheduler::Start();

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

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

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

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

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

	LOGTEXT("TestChangeEventTypeL() - end");

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0837

@SYMTestCaseDesc	    Deleting an event type test.

                        Tests for CLogClient::DeleteEventType() test

@SYMTestPriority 	    High

@SYMTestActions  	    Delete an event type from log database and test for no errors found

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestDeleteEventTypeL(CLogClient& aClient)

//

//

//

	{

    test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0837 "));

	LOGTEXT("TestChangeEventTypeL()");	

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

	CleanupStack::PushL(active);

	active->StartL();

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

	aClient.Cancel();

	CActiveScheduler::Start();

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

	active->StartL();

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

	CActiveScheduler::Start();

	aClient.Cancel();

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

	CLogEventType* type = CLogEventType::NewL();

	CleanupStack::PushL(type);

	type->SetUid(KTestEventUid);

	active->StartL();

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

	CActiveScheduler::Start();

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

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

	LOGTEXT("TestChangeEventTypeL() - end");

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-1329

@SYMTestCaseDesc	    Adding an event type test.

                        Tests for CLogClient::AddEventType() function

@SYMTestPriority 	    High

@SYMTestActions  	    Add an event type to the log database and test for no errors found

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestAddEventL(CLogClient& aClient)

//

//

//

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-1329 "));	

	CLogEventType* type = CLogEventType::NewL();

	CleanupStack::PushL(type);

	type->SetUid(KTestEventUid);

	type->SetDescription(KTestEventDesc1);

	type->SetLoggingEnabled(ETrue);

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

	CleanupStack::PushL(active);

	active->StartL();

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

	CActiveScheduler::Start();

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

	CLogEvent* event = CLogEvent::NewL();

	CleanupStack::PushL(event);

	// Reset

	gTheId = KLogNullId;

	//

	TTime now;

	now.UniversalTime();

	event->SetEventType(KTestEventUid);

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

	event->SetFlags(KTestFlags1);

	//

	active->StartL();

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

	aClient.Cancel();

	CActiveScheduler::Start();

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

	//

	active->StartL();

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

	CActiveScheduler::Start();

	TEST(!active->IsActive());

	aClient.Cancel();

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

	//

	gTheId=event->Id();

	//

	TEST(gTheId != KLogNullId);

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

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

	//

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

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0838

@SYMTestCaseDesc	    Client failure test

@SYMTestPriority 	    High

@SYMTestActions  	    Checks for status after client is deleted,checks for Cancel error flag

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestClientFailL()

	{

	test.Next(_L(" @SYMTestCaseID:SYSLIB-LOGENG-CT-0838 "));	

	CLogEvent* event = CLogEvent::NewL();

	CleanupStack::PushL(event);

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

	CleanupStack::PushL(active);

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

	CleanupStack::PushL(client);

	event->SetId(gTheId);

	active->StartL();

	client->GetEvent(*event, active->iStatus);

	CleanupStack::Pop(); // client

	delete client;	

	CActiveScheduler::Start();

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

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

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0839

@SYMTestCaseDesc	    Tests for CLogClient::GetEvent() function

@SYMTestPriority 	    High

@SYMTestActions  	    Retrieve the event type and test for the integrity of the event type information

                        Check for no errors

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestGetEventL(CLogClient& aClient)

//