// 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 <babackup.h>

#include "TEST.H"

#include <logview.h>

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

RTest test(_L("Log Backup Test Harness"));

CBaBackupSessionWrapper* theBackup = NULL;

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

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

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

#ifdef __WINS__

_LIT(KTestEventDesc, "Event Type Description");

_LIT(KTestRemoteParty, "Remote Party");

_LIT(KTestDirection, "Direction");

const TLogDurationType KTestDurationType = 1;

const TLogDuration KTestDuration = 0x1234;

_LIT(KTestStatus, "Status");

_LIT(KTestSubject, "Subject");

_LIT(KTestNumber, "Number");

const TLogContactItemId KTestContact = 0x1234;

const TLogLink KTestLink = 0x1234;

_LIT8(KTestData, "ABCDEFGH");

_LIT(KTestNumber1, "TheNumber");

_LIT(KTestNumber2, "Changed Number");

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

		}

	inline TInt CallCount() const { return iCallCount; }

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

private:

	TInt iCallCount;

	TBool& iFlag;

	};

LOCAL_C TBool IsLogOpenL()

	{

	return TestUtils::IsDatabaseOpenL();

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0993

@SYMTestCaseDesc	    Tests for a file open

@SYMTestPriority 	    High

@SYMTestActions  	    Check for errors while testing for file open 

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestLogOpenL()

	{

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

	TEST(IsLogOpenL());

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0994

@SYMTestCaseDesc	    Tests for file close

@SYMTestPriority 	    High

@SYMTestActions  	    Check for errors while testing for file close

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestLogClosedL()

	{

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

	TEST(!IsLogOpenL());

	}

LOCAL_C void StartBackupL()

	{

	User::InfoPrint(_L("Backup"));

	TDriveUnit driveUnit(EDriveC);

	TDriveName name = driveUnit.Name();

	TParse parse;

	LEAVE_IF_ERROR(parse.Set(KLogDatabaseName, &name, NULL));

	delete theBackup;

	theBackup = NULL;

	theBackup = CBaBackupSessionWrapper::NewL();

	theBackup->CloseFileL(parse.FullName(), MBackupObserver::EReleaseLockNoAccess);

	User::After(1000000);

	}

LOCAL_C void DeleteLogDatabaseL()

	{

	User::InfoPrint(_L("delete"));

	TestUtils::DeleteDatabaseL(EFalse);

	}

LOCAL_C void EndBackupL()

	{

	delete theBackup;

	theBackup = NULL;

	User::After(1000000);

	}

LOCAL_C void DelayL(TInt aDelay)

	{

	CTestTimer* timer = CTestTimer::NewL();

	timer->After(aDelay);

	CActiveScheduler::Start();

	delete timer;

	}

const TUid KTestEventUid = {0x10005393};

_LIT(KTestEventDesc1, "Event Type Description");

_LIT(KTestEventDesc2, "Changed Event Description");

LOCAL_C void ForceClientImplInstL(CLogClient& aClient)

	{

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

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

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0995

@SYMTestCaseDesc	    Tests for starting and ending the backup session 

@SYMTestPriority 	    High

@SYMTestActions  	    Test for file open and close,start and end of the backup session

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestLockingL()

	{

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

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

	CleanupStack::PushL(client);

	ForceClientImplInstL(*client);

	DelayL(1000000);

	TestLogOpenL();

	StartBackupL();

	DelayL(1000000);

	TestLogClosedL();

	EndBackupL();

	TestLogOpenL();

	CleanupStack::PopAndDestroy(); // client

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0996

@SYMTestCaseDesc	    Tests for deleting the file when its locked

@SYMTestPriority 	    High

@SYMTestActions  	    Attempt for deleting the file when its locked

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestDeleteWhileLockedL()

	{

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

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

	CleanupStack::PushL(client);

	ForceClientImplInstL(*client);

	TestLogOpenL();

	StartBackupL();

	DelayL(1000000);

	TestLogClosedL();

	CleanupStack::PopAndDestroy(); // client

	TestLogClosedL();

	client = CLogClient::NewL(theFs);

	CleanupStack::PushL(client);

	ForceClientImplInstL(*client);

	EndBackupL();

	TestLogOpenL();

	StartBackupL();

	DelayL(1000000);

	TestLogClosedL();

	EndBackupL();

	TestLogOpenL();

	CleanupStack::PopAndDestroy(); // client

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0997

@SYMTestCaseDesc	    Tests for deleting the view while its locked

@SYMTestPriority 	    High

@SYMTestActions  	    Delete the view when its locked

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestDeleteViewWhileLockedL()

	{

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

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

	CleanupStack::PushL(client);

	ForceClientImplInstL(*client);

	CLogFilter* filter = CLogFilter::NewL();

	CleanupStack::PushL(filter);

	CLogViewEvent* view = CLogViewEvent::NewL(*client);

	CleanupStack::PushL(view);

	TestLogOpenL();

	StartBackupL();

	DelayL(1000000);

	TestLogClosedL();

	CleanupStack::PopAndDestroy(3); // view, filter, client

	TestLogClosedL();

	client = CLogClient::NewL(theFs);

	CleanupStack::PushL(client);

	ForceClientImplInstL(*client);

	filter = CLogFilter::NewL();

	CleanupStack::PushL(filter);

	view = CLogViewEvent::NewL(*client);

	CleanupStack::PushL(view);

	EndBackupL();

	TestLogOpenL();

	StartBackupL();

	DelayL(1000000);

	TestLogClosedL();

	EndBackupL();

	TestLogOpenL();

	CleanupStack::PopAndDestroy(3); // view, filter, client

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0998

@SYMTestCaseDesc	    Multiple client logging test

@SYMTestPriority 	    High

@SYMTestActions  	    Open multiple clients and test for starting and ending the backup 

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestMultipleClientLockingL()

	{

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

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

	CleanupStack::PushL(client1);

	ForceClientImplInstL(*client1);

	TestLogOpenL();

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

	CleanupStack::PushL(client2);

	ForceClientImplInstL(*client2);

	TestLogOpenL();

	StartBackupL();

	EndBackupL();

	TestLogOpenL();

	StartBackupL();

	TestLogClosedL();

	EndBackupL();

	TestLogOpenL();

	CleanupStack::PopAndDestroy(2); // client1, client2

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-0999

@SYMTestCaseDesc	    Multiple view locking test

@SYMTestPriority 	    High

@SYMTestActions  	    Open multiple views and test for starting and ending of backup

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestMultipleViewLockingL()

	{

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

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

	CleanupStack::PushL(client);

	ForceClientImplInstL(*client);

	CLogFilter* filter = CLogFilter::NewL();

	CleanupStack::PushL(filter);

	CLogViewEvent* view1 = CLogViewEvent::NewL(*client);

	CleanupStack::PushL(view1);

	CLogViewEvent* view2 = CLogViewEvent::NewL(*client);

	CleanupStack::PushL(view2);

	TestLogOpenL();

	StartBackupL();

	TestLogClosedL();

	EndBackupL();

	TestLogOpenL();

	CleanupStack::PopAndDestroy(4); // view2, view1, filter, client

	}

LOCAL_C void DoTestLogL(CLogBase& aClient, TInt aError)

	{

	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(), aError);

	if (aError == KErrNone)

		{

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

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

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

		now = event->Time();

		}

	else

		{

		// User a dummy id to prevent assertion

		event->SetId(123);

		}

	TLogId id = event->Id();

	event->SetRemoteParty(KTestRemoteParty);

	event->SetDirection(KTestDirection);

	event->SetDurationType(KTestDurationType);

	event->SetDuration(KTestDuration);

	event->SetStatus(KTestStatus);

	event->SetSubject(KTestSubject);

	event->SetNumber(KTestNumber);

	event->SetContact(KTestContact);

	event->SetLink(KTestLink);

	event->SetDataL(KTestData);

	active->StartL();

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

	CActiveScheduler::Start();

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

	if (aError == KErrNone)

		{

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		}

	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(), aError);

	if (aError == KErrNone)

		{

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		}

	active->StartL();

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

	CActiveScheduler::Start();

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

	active->StartL();

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

	CActiveScheduler::Start();

	RDebug::Print(_L("*** active->iStatus.Int()=%d\n"), active->iStatus.Int());

	TEST(active->iStatus.Int() == aError || active->iStatus.Int() == KErrNotFound);

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

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-1000

@SYMTestCaseDesc	    Client requests test

@SYMTestPriority 	    High

@SYMTestActions  	    Tests for client requests when the file is opened and check for no errors

						Tests for client requests when the file is closed and check for access denied errors

						Re-test for client requests when file is opened and check for no errors

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestClientRequestsL()

	{

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

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

	CleanupStack::PushL(client1);

	ForceClientImplInstL(*client1);

	TestLogOpenL();

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

	CleanupStack::PushL(client2);

	ForceClientImplInstL(*client2);

	TestLogOpenL();

	DoTestLogL(*client1, KErrNone);

	DoTestLogL(*client2, KErrNone);

	StartBackupL();

	DelayL(1000000);

	TestLogClosedL();

	DoTestLogL(*client1, KErrAccessDenied);

	DoTestLogL(*client2, KErrAccessDenied);

	EndBackupL();

	TestLogOpenL();

	DoTestLogL(*client1, KErrNone);

	DoTestLogL(*client2, KErrNone);

	CleanupStack::PopAndDestroy(2); // client1, client2

	}

/**

@SYMTestCaseID          SYSLIB-LOGENG-CT-1001

@SYMTestCaseDesc	    Tests for notification changes

@SYMTestPriority 	    High

@SYMTestActions  	    Set up for client log notification changes.

                        Change the log and unlock the log.Try and change the log again and check for access denied error.

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_C void TestNotificationsL()

	{

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

	CTestActive* notify = new(ELeave)CTestActive;

	CleanupStack::PushL(notify);

	CTestTimer* timer = CTestTimer::NewL();

	CleanupStack::PushL(timer);

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

	CleanupStack::PushL(client);

	ForceClientImplInstL(*client);

	EndBackupL();

	// Setup change notification

	notify->StartL();

	client->NotifyChange(10000000, notify->iStatus);

	// Wait a second