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

 	}