// Copyright (c) 1997-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 <e32debug.h>

#include <e32test.h>

#include <babackup.h>

#include "T_backupSrv.h"

LOCAL_D RTest MainTest(_L(" T_BackupSrv.cpp"));

_LIT(KFileName1, "FileName1");

_LIT(KFileName2, "FileName2");

_LIT(KFileName3, "FileName3");

_LIT(KFileName4, "FileName4");

// Nasty global convenience function

LOCAL_D void LogThread()

{

	TBuf<150> buf((RThread().Name()));

	RDebug::Print(_L("*** Currently in thread : "));

	RDebug::Print(buf);

}

//

//	class CBackupOperationObserver

//

CBackupOperationObserver* CBackupOperationObserver::NewL(TInt aObserverNumber)

	{

	LogThread();

	RDebug::Print(_L("CBackupOperationObserver::NewL"));

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

	CleanupStack::PushL(self);

	self->ConstructL(aObserverNumber);

	CleanupStack::Pop();

	return self;

	}

CBackupOperationObserver::CBackupOperationObserver()

 : CActive(0)

	{ ; }

CBackupOperationObserver::~CBackupOperationObserver()

	{

	LogThread();

	RDebug::Print(_L("CBackupOperationObserver::~CBackupOperationObserver"));

	iBackupSession->DeRegisterBackupOperationObserver(*this);

	delete iBackupSession;

	delete iLocalRTest;

	}

void CBackupOperationObserver::ConstructL(TInt aObserverNumber)

	{

	// Set up the AO callback

	CActiveScheduler::Add(this);

	SetActive();

	iStatus = KRequestPending;

	// Create a new session for this backup notification observer

	iBackupSession = CBaBackupSessionWrapper::NewL();

	iBackupSession->RegisterBackupOperationObserverL(*this);

	iObserverNumber = aObserverNumber;

	iLocalRTest = new (ELeave) RTest(_L("BackupOperationObserver"));

	}

void CBackupOperationObserver::HandleBackupOperationEventL(const TBackupOperationAttributes& aBackupOperationAttributes)

	{

	LogThread();

	RDebug::Print(_L("CBackupOperationObserver::HandleBackupOperationEventL"));

	TBuf<150> buf;

	buf.Format(_L("Backup observer number %d received a notification of operation type %d and file lock type: %d\n"),iObserverNumber, aBackupOperationAttributes.iOperation, aBackupOperationAttributes.iFileFlag);

	RDebug::Print(buf);

	}

void CBackupOperationObserver::DoCancel()

	{ ; }

void CBackupOperationObserver::RunL()

	{

	// Okay - we're back in the right thread!

	LogThread();

	RDebug::Print(_L("CBackupOperationObserver::RunL"));

	// Finished with this object

	delete this;

	// And the active scheduler in this thread

	CActiveScheduler::Current()->Stop();

	}

void CBackupOperationObserver::Kill(RThread* aThread)

	{

	LogThread();

	RDebug::Print(_L("CBackupFileObserver::Kill"));

	// Trigger the Active Object locally - in a different thread!

	TRequestStatus* tempStatus=(&iStatus);

	aThread->RequestComplete(tempStatus, KErrNone);

	}

//

//	class CBackupFileObserver

//

CBackupFileObserver::CBackupFileObserver()

 : CActive(0)

  { ;  }

void CBackupFileObserver::ConstructL(TInt aFileObserverNumber)

	{

	// Set up the AO callback

	CActiveScheduler::Add(this);

	SetActive();

	iStatus = KRequestPending;

	// Create a new session for this file lock observer

	iBackupSession = CBaBackupSessionWrapper::NewL();

	iFileObserverNumber = aFileObserverNumber;

	iFileLocksChanged = 0;

	iFileLockState = ELocked;

	iLocalRTest = new (ELeave) RTest(_L("BackupFileObserver"));

	}

CBackupFileObserver* CBackupFileObserver::NewL(TInt aFileObserverNumber)

	{

	LogThread();

	RDebug::Print(_L("CBackupFileObserver::NewL"));

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

	CleanupStack::PushL(self);

	self->ConstructL(aFileObserverNumber);

	CleanupStack::Pop();

	return self;

	}

CBackupFileObserver::~CBackupFileObserver()

	{

	LogThread();

	RDebug::Print(_L("CBackupFileObserver::~CBackupFileObserver"));

	delete iBackupSession;

	delete iLocalRTest;

	}

void CBackupFileObserver::AddFileL(TInt aFileNumber)

	{

	LogThread();

	RDebug::Print(_L("CBackupFileObserver::AddFileL"));

	// We base the filename of the number of thread in the RArray

	iFileName.Format(_L("FileName%d"), aFileNumber);

	iBackupSession->RegisterFileL(iFileName,*this);

	}

TInt CBackupFileObserver::GetFileLocksChanged()

	{

	return iFileLocksChanged;

	}

void CBackupFileObserver::ZeroFileLocksChanged()

	{

	iFileLocksChanged = 0;

	}

void CBackupFileObserver::SetDelay(TBool aDelay)

{

	iDelay = aDelay;

}

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

	{

	LogThread();

	RDebug::Print(_L("BackupFileObserver::ChangeFileLockL"));

	// Keep a count of how many release notifications there have been

	if (aFlags != MBackupObserver::ETakeLock)

		{

		iFileLocksChanged++;

		}

	// If delay is set then insert wait now

	if (iDelay && (!(aFileName.Compare(KFileName1))))

		{

		User::After(10000000);

		}

	// Check this file is the one for this observer - if not fail test;

	if (iFileName.Compare(aFileName))

		{

		RDebug::Print(_L("\nReceived notification for non-registered file!"));

		(*iLocalRTest)(EFalse);

		}

	// Update the local file lock array

	CBackupFileObserver::TFileLock flag = (CBackupFileObserver::TFileLock) aFlags;

	iFileLockState = flag;

	// Test output

	TBuf<150> buf;

	buf.Format(_L("File backup observer number %d was notified for file %S of file lock type: %d\n"),iFileObserverNumber, &aFileName, flag);

	RDebug::Print(buf);

	}

void CBackupFileObserver::DoCancel()

	{ ; }

void CBackupFileObserver::RunL()

	{

	// Okay - we're back in the right thread!

	LogThread();

	RDebug::Print(_L("CBackupFileObserver::RunL"));

	// Finished with this object

	delete this;

	// And the active scheduler in this thread

	CActiveScheduler::Current()->Stop();

	}

void CBackupFileObserver::Kill(RThread* aThread)

	{

	LogThread();

	RDebug::Print(_L("CBackupFileObserver::Kill"));

	// Trigger the Active Object locally - in a different thread!

	TRequestStatus* tempStatus=(&iStatus);

	aThread->RequestComplete(tempStatus, KErrNone);

	}

//

// class CBackupTestsStateMachine

//

CBackupTestsStateMachine* CBackupTestsStateMachine::NewL()

	{

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CBackupTestsStateMachine::CBackupTestsStateMachine()

 : CActive(0)

{ ; }

void CBackupTestsStateMachine::ConstructL()

	{

	// Set up the RTest for this thread and display we're started

	iLocalRTest = new (ELeave) RTest(_L("T_BACKUP_SRV"));

	iLocalRTest->Title();

	// Set the ititial state

	iState = EStateMachineStart;

	// Zero the EndBackupRecursionCount (see below)

	iEndBackupRecursionCount = 0;

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

	CActiveScheduler::Add(this);

	SetActive();

	// Create the backup "command" session

	iBackupSession = CBaBackupSessionWrapper::NewL();

	// Set up the mutex

	iMutex.CreateLocal();

	}

// Observers need to have their own thread

void CBackupTestsStateMachine::CreateObserversThreadsL()

	{

	RDebug::Print(_L("Starting observers threads"));

	TInt i;

	TBuf<30> newThreadNames;

	TInt error;

	for (i = 0; i<4 ; i++)

		{

		// Backup observer

		iBackupObserverThreads.AppendL(new (ELeave) RThread);

		newThreadNames.Format(_L("Backup Observer Thread %d"), i+1);

		error = iBackupObserverThreads[i]->Create(newThreadNames, CBackupTestsStateMachine::BackupObserversThreadStartL, 0x2000, NULL, (TAny*)this);

		(*iLocalRTest)(error==KErrNone);

		iBackupObserverThreads[i]->Resume();

		// File observer

		iFileObserverThreads.AppendL(new (ELeave) RThread);

		newThreadNames.Format(_L("File Observer Thread %d"), i+1);

		error = iFileObserverThreads[i]->Create(newThreadNames, CBackupTestsStateMachine::FileObserversThreadStartL, 0x2000, NULL, (TAny*)this);

		(*iLocalRTest)(error==KErrNone);

		iFileObserverThreads[i]->Resume();

		// Brief delay to let the observer threads get started

		User::After(1000000);

		}

	}

// Static starting function for the backup observers threads

TInt CBackupTestsStateMachine::BackupObserversThreadStartL(TAny* aPtr)

	{

	// Create the Cleanup Stack and Active Scheduler for this thread

	CTrapCleanup* theTrapCleanup = CTrapCleanup::New();

	CActiveScheduler *activeScheduler = new CActiveScheduler;

	CActiveScheduler::Install(activeScheduler);

	// Create the observer instances

	CBackupTestsStateMachine* objectPtr = static_cast<CBackupTestsStateMachine*>(aPtr);

	TRAPD(error, objectPtr->CreateBackupObserverInstanceL());

	User::LeaveIfError(error);

	// Go to Active Scheduler main loop for this thread

	CActiveScheduler::Start();

	// And we're done

	delete activeScheduler;

	delete theTrapCleanup;

	return KErrNone;

	}

// Static starting function for the file observers threads

TInt CBackupTestsStateMachine::FileObserversThreadStartL(TAny* aPtr)

{

	// Create the Cleanup Stack and Active Scheduler for this thread

	CTrapCleanup* theTrapCleanup = CTrapCleanup::New();

	CActiveScheduler* activeScheduler = new CActiveScheduler;

	CActiveScheduler::Install(activeScheduler);

	// Create the observer instances

	CBackupTestsStateMachine* objectPtr = static_cast<CBackupTestsStateMachine*>(aPtr);

	TRAPD(error, objectPtr->CreateFileObserverInstanceL());

	User::LeaveIfError(error);

	// Go to Active Scheduler main loop for this thread

	CActiveScheduler::Start();

	// And we're done

	delete activeScheduler;

	delete theTrapCleanup;

	return KErrNone;

}

void CBackupTestsStateMachine::CreateBackupObserverInstanceL()

	{

	iMutex.Wait();

	TInt count = iBackupObserverThreads.Count();

	// Create the new object instance (one object per thread)

	// We base the thread number of the number of thread in the RArray

	CBackupOperationObserver* newObserver = CBackupOperationObserver::NewL(count);

	iBackupObservers.AppendL(newObserver);

	iMutex.Signal();

	}

void CBackupTestsStateMachine::CreateFileObserverInstanceL()

{

	iMutex.Wait();

	TInt count = iBackupFileObservers.Count();

	// Create the new object instance (one object per thread)

	CBackupFileObserver* newObserver = CBackupFileObserver::NewL(count + 1);

	iBackupFileObservers.AppendL(newObserver);

	// Register the file for this thread / instance

	iBackupFileObservers[count]->AddFileL(count + 1);

	iMutex.Signal();

}

// State Machine destructor

CBackupTestsStateMachine::~CBackupTestsStateMachine()

	{

	// Close our session into the backup server

	delete iBackupSession;

	// Delete all the observers (only 3 of each of by this point)

	TInt i;

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

		{

		iBackupObservers[i]->Kill(iBackupObserverThreads[i]);

		iBackupFileObservers[i]->Kill(iFileObserverThreads[i]);

		User::After(50000000);

		}

	iBackupObservers.Close();

	iBackupFileObservers.Close();

	// Kill the observer threads

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

	{

	iBackupObserverThreads[i]->Kill(KErrNone);

	delete iBackupObserverThreads[i];

	iFileObserverThreads[i]->Kill(KErrNone);

	delete iFileObserverThreads[i];

	}

	iBackupObserverThreads.Close();

	iFileObserverThreads.Close();

	// Display we're finished

	iLocalRTest->Close();

	delete iLocalRTest;

	// Cancel this is it's active

	if (IsActive())

		{

		Cancel();

		}

	}

// Common starting function for all test-related calls to CloseAll

void CBackupTestsStateMachine::CloseAllStartL(StateMachineState aNextState, MBackupObserver::TFileLockFlags aFlag)

	{

	StartBackupL();

	iState = aNextState;

	iBackupSession->CloseAll(aFlag, iStatus);

	}

// Common ending function for all test-related calls to CloseAll

void CBackupTestsStateMachine::CloseAllEndL(StateMachineState aNextState, TInt aExpectedNotifications)

	{

	iState = aNextState;

	SignalEndBackupL();

	EndBackup(aExpectedNotifications, ETrue);

	iLocalRTest->End();

	Complete();

	}

// State machine call back - get here by calls to Complete and returns for asynchronous server calls

void CBackupTestsStateMachine::RunL()

	{

	switch(iState)

		{

		case EStateMachineStart:

			// Create observers threads

			CreateObserversThreadsL();

			iState = ECloseAllNormalReadOnly;

			Complete();

			break;

		case ECloseAllNormalReadOnly:

			iLocalRTest->Start(_L("\nCloseAllFiles normal ReadOnly\n"));

			CloseAllStartL(ECloseAllNormalReadOnlyReturned, MBackupObserver::EReleaseLockReadOnly);

			break;

		case ECloseAllNormalReadOnlyReturned:

			CloseAllEndL(ECloseAllNormalNoAccess, 4);

			break;

		case ECloseAllNormalNoAccess:

			iLocalRTest->Start(_L("\nCloseAllFiles normal NoAccess\n"));

			CloseAllStartL(ECloseAllNormalNoAccessReturned, MBackupObserver::EReleaseLockNoAccess);

			break;

		case ECloseAllNormalNoAccessReturned:

			CloseAllEndL(ECloseAllDelayReadOnly, 4);

			break;

		case ECloseAllDelayReadOnly:

			iLocalRTest->Start(_L("\nCloseAllFiles delay ReadOnly\n"));

			iBackupFileObservers[0]->SetDelay(ETrue);

			CloseAllStartL(ECloseAllDelayReadOnlyReturned, MBackupObserver::EReleaseLockReadOnly);

			break;

		case ECloseAllDelayReadOnlyReturned:

			iBackupFileObservers[0]->SetDelay(EFalse);

			CloseAllEndL(ECloseAllDelayNoAccess, 4);

			// Nice long wait for the timer to expire in the other thread

			User::After(10000000);

			break;

		case ECloseAllDelayNoAccess:

			iLocalRTest->Start(_L("\nCloseAllFiles delay NoAccess\n"));

			iBackupFileObservers[0]->SetDelay(ETrue);

			CloseAllStartL(ECloseAllDelayNoAccessReturned, MBackupObserver::EReleaseLockNoAccess);

			break;

		case ECloseAllDelayNoAccessReturned:

			iBackupFileObservers[0]->SetDelay(EFalse);

			CloseAllEndL(ECloseAllDropFileSession, 4);

			// Nice long wait for the timer to expire in the other thread

			User::After(10000000);

			break;

		case ECloseAllDropFileSession:

			iLocalRTest->Start(_L("\nCloseAllFiles dropping file session\n"));

			// Drop one of the file registration / observer sessions

			iBackupFileObservers[0]->Kill(iFileObserverThreads[0]);

			// Nice long wait for the observer to be killed in the other thread

			User::After(10000000);

			// Remove it from the list

			iBackupFileObservers.Remove(0);

			// Kill the thread

			iFileObserverThreads[0]->Kill(KErrNone);

			delete iFileObserverThreads[0];

			iFileObserverThreads.Remove(0);

			// All done - start this sub-test

			CloseAllStartL(ECloseAllDropFileSessionReturned, MBackupObserver::EReleaseLockReadOnly);

			break;

		case ECloseAllDropFileSessionReturned:

			CloseAllEndL(ECloseAllDropBackupObserverSession, 3);

			break;

		case ECloseAllDropBackupObserverSession:

			iLocalRTest->Start(_L("\nCloseAllFiles dropping backup session\n"));

			// Drop one of the backup observer sessions

			iBackupObservers[0]->Kill(iBackupObserverThreads[0]);

			// Nice long wait for the observer to be killed in the other thread

			User::After(10000000);

			// Remove it from the list

			iBackupObservers.Remove(0);

			// Kill the thread