// Copyright (c) 2008-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 <e32test.h>

#include "t_backupsrvdefects.h"

RTest TheTest (_L("t_backupsrvdefects"));

#define TEST(arg)  TheTest((arg), __LINE__)

_LIT(KFileName1, "FileName1");

CBUDefectTestMachine* CBUDefectTestMachine::NewL()

	{

	CBUDefectTestMachine* self = new (ELeave) CBUDefectTestMachine();

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CBUDefectTestMachine::CBUDefectTestMachine()

	:CActive(0)

	{}

CBUDefectTestMachine::~CBUDefectTestMachine()

	{

	delete iWrapper;

	// Cancel this if it's active

	if (IsActive())

		{

		Cancel();

		}

	}	

void CBUDefectTestMachine::ConstructL()

	{

	iWrapper = CBaBackupSessionWrapper::NewL();

	iNextState = EMachineStart;

	// Add this to the Active Scheduler and set us active

	CActiveScheduler::Add(this);

	SetActive();	

	}

// Called when CloseAll request is completed or the active object is scheduled.	

void CBUDefectTestMachine::RunL()	

	{

	switch(iNextState)

		{

		case EMachineStart:

			// Send 2 requests of CloseAll with different file lock states.

			// The second request will be ignored. The first one will be completed.		

			iWrapper->CloseAll(MBackupObserver::EReleaseLockReadOnly, iStatus);

			iWrapper->CloseAll(MBackupObserver::EReleaseLockNoAccess, iStatus);

			iNextState = EMachineCloseAllsEndSameClient;

			SetActive();

			break;

		case EMachineCloseAllsEndSameClient:

			// The first CloseAll request is completed.		

			TEST(iStatus == KErrNone);

			// Send 2 requests of CloseAll from different client.

			// The second client should be completed with KErrServerBusy before 

			// the first client is completed with KErrNone

			iWrapper->CloseAll(MBackupObserver::EReleaseLockReadOnly, iStatus);

			iBackupFileObserver->CloseAll(MBackupObserver::EReleaseLockReadOnly);

			iNextState = EMachineCloseAllsEndOtherClient;

			SetActive();

			break;

		case EMachineCloseAllsEndOtherClient:

			// The first CloseAll client is completed successfully

			TEST(iStatus == KErrNone);

			// Tests under CloseAll operation, CloseFileL requested by the other client will leave;

			// CloseFileL requested by the same client will be successful and not affect the CloseAll

			// process.

			iWrapper->CloseAll(MBackupObserver::EReleaseLockReadOnly, iStatus);

			TRAPD(err, iBackupFileObserver->CloseFileL(KFileName1,MBackupObserver::EReleaseLockNoAccess));

			TEST(err == KErrServerBusy);

			iWrapper->CloseFileL(KFileName1,MBackupObserver::EReleaseLockReadOnly);

			iNextState = EMachineCloseAllsEndCloseFile;

			SetActive();

			break;

		case EMachineCloseAllsEndCloseFile:

			// The CloseAll is completed successfully

			TEST(iStatus == KErrNone);

			CActiveScheduler::Stop();	

			break;

		default:

			break;

		}

	}

void CBUDefectTestMachine::DoCancel()

	{ 

	Complete();

	}

void CBUDefectTestMachine::Complete()

	{

	TRequestStatus* tempStatus=&iStatus;

	User::RequestComplete(tempStatus, KErrNone);

	}

/*

Sets the other client of the backup server

*/

void CBUDefectTestMachine::SetFileObserver(CBackupFileObserver* aBackupFileObserver)

	{

	iBackupFileObserver = aBackupFileObserver;

	}

//CBackupFileObserver

CBackupFileObserver* CBackupFileObserver::NewL(CBUDefectTestMachine& aDefectMachine, const TDesC& aLockedFileName)

	{

	CBackupFileObserver* self = new (ELeave) CBackupFileObserver(aDefectMachine, aLockedFileName);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CBackupFileObserver::CBackupFileObserver(CBUDefectTestMachine& aTestMachine, const TDesC& aLockedFileName)

:CActive(0), iTestMachine(aTestMachine), iLockedFileName(aLockedFileName)

	{}

void CBackupFileObserver::ConstructL()

	{

	iWrapper = CBaBackupSessionWrapper::NewL();

	iWrapper->RegisterFileL(iLockedFileName, *this);

	iTestMachine.SetFileObserver(this);

	// Add this to the Active Scheduler and set us active

	CActiveScheduler::Add(this);

	}

CBackupFileObserver::~CBackupFileObserver()

	{

	delete iWrapper;

	// Cancel this if it's active

	if (IsActive())

		{

		Cancel();

		}	

	}

void CBackupFileObserver::CloseAll(MBackupObserver::TFileLockFlags aFlags)

	{

	iWrapper->CloseAll(aFlags, iStatus);

	if(! IsActive())

		{

		SetActive();

		}

	}

void CBackupFileObserver::CloseFileL(const TDesC& aFileName,MBackupObserver::TFileLockFlags aFlags)

	{

	iWrapper->CloseFileL(aFileName,aFlags);

	}

void CBackupFileObserver::ChangeFileLockL(const TDesC& aFileName,TFileLockFlags aFlags)

	{

	TEST(aFileName == KFileName1);

	TEST(aFlags == MBackupObserver::EReleaseLockReadOnly);

	}

/**

Called when CloseAll request is completed.

*/

void CBackupFileObserver::RunL()	

	{

	if(iTestMachine.iNextState == EMachineCloseAllsEndOtherClient)

		{

		// As the second CloseAll client, Tests the CloseAll request is completed with KErrServerBusy 

		// while the first one is still pending

		TEST(iStatus == KErrServerBusy); 

		TEST(iTestMachine.iStatus == KRequestPending);	

		}

	}

void CBackupFileObserver::DoCancel()

	{ 

	TRequestStatus* tempStatus=&iStatus;

	User::RequestComplete(tempStatus, KErrNone);

	}

/**

Tests CBaBackupSessionWrapper::RegisterFileL leaves with KErrServerBusy while the sever is under 

CloseAll operation. And the CloseAll request is complete successfully.

*/	

void TestRegisterFileL()

	{

	class TSimpleObserver : public MBackupObserver

	{

	void ChangeFileLockL(const TDesC& /*aFileName*/,TFileLockFlags /*aFlags*/) {;}

	} simpleObserver;

	CBaBackupSessionWrapper* wrapper = CBaBackupSessionWrapper::NewL();

	CleanupStack::PushL(wrapper);

	TRequestStatus status;

	wrapper->CloseAll(MBackupObserver::EReleaseLockReadOnly, status);

	TRAPD(err,wrapper->RegisterFileL(KFileName1, simpleObserver));

	TEST(err == KErrServerBusy);

	User::WaitForRequest(status);

	TEST(status == KErrNone);

	CleanupStack::PopAndDestroy(wrapper);

	}

/**

@SYMTestCaseID          SYSLIB-BAFL-CT-4053

@SYMTestCaseDesc        Tests the updated functions work as expectation

@SYMTestPriority        High

@SYMTestActions         Calls the updated functions under the specified circumstance (sever under 

						CloseAll operation). They run as expectation:

                        1. Call CBaBackupSessionWrapper::RegisterFileL while the sever is under 

                           CloseAll operation. It leaves with KErrServerBusy. The CloseAll 

                           request is complete successfully.

                        2. Call CBaBackupSessionWrapper::CloseAll() 2 times from the same client. 

                           The second request will be ignored. The first one will be completed 

                           successfully.	

                        3. Call CBaBackupSessionWrapper::CloseAll() 2 times from the different clients. 

                           The second request will be completed immediately with KErrServerBusy. The 

                           first one will be completed successfully.	

                        4. Call CBaBackupSessionWrapper::CloseFileL() while the sever is under CloseAll 

                           operation requested by the other client. It leaves with KErrServerBusy. The 

                           CloseAll request is complete successfully.

                        5. Call CBaBackupSessionWrapper::CloseFileL() while the sever is 

                           under CloseAll operation requested by the same client. It is ignored and 

                           the CloseAll request is complete successfully.

@SYMTestExpectedResults Test must not fail

@SYMDEF                 PDEF121575

*/	

void PDEF121575L()

	{

	TestRegisterFileL();

	CBUDefectTestMachine* bUSrvDefectMachine = CBUDefectTestMachine::NewL();

	CleanupStack::PushL(bUSrvDefectMachine);

	CBackupFileObserver* fileObserver = CBackupFileObserver::NewL(*bUSrvDefectMachine, KFileName1);

	CleanupStack::Pop(bUSrvDefectMachine);

	// start the machine

	bUSrvDefectMachine->Complete();

	CActiveScheduler::Start();

	delete bUSrvDefectMachine ;

	delete fileObserver ;

	return;	

	}

void StartTestsL()

	{

	TheTest.Start (_L("PDEF121575: BAFL Backup System Multiple Simultaneous Call Problema\n"));

	PDEF121575L();

	}

TInt E32Main()

	{

	TheTest.Title ();

	__UHEAP_MARK;

	CTrapCleanup* theTrapCleanup=CTrapCleanup::New();

	CActiveScheduler *activeScheduler=new CActiveScheduler;

	CActiveScheduler::Install(activeScheduler);

	TRAPD(error, StartTestsL());

	TEST(error == KErrNone);

	delete activeScheduler;

	delete theTrapCleanup;

	__UHEAP_MARKEND; 

	TheTest.End();	

	return(KErrNone);

	}