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

			iBackupObserverThreads[0]->Kill(KErrNone);

			delete iBackupObserverThreads[0];

			iBackupObserverThreads.Remove(0);

			// All done - start this sub-test

			CloseAllStartL(ECloseAllDropBackupObserverSessionReturned, MBackupObserver::EReleaseLockReadOnly);

			break;

		case ECloseAllDropBackupObserverSessionReturned:

			CloseAllEndL(ESingleFileTests, 3);

			break;

		case ESingleFileTests:

			iLocalRTest->Start(_L("\nSingle file lock tests\n"));

			StartBackupL();

			SingleFileLockTestsL();

			SignalEndBackupL();

			// Can call EndBackup synchronously here as nothing in SingleFileLockTests is asynchronous

			EndBackup(3, EFalse);

			iLocalRTest->End();

 			iState = ENoBackupSessionSingleFileTests;

			Complete();

			break;

		// Required to cover the situation when the backup server is used purely for message signalling

		// For example in the LogEng compnent

		case ENoBackupSessionSingleFileTests:

			iLocalRTest->Start(_L("\nNo backup session single file lock tests\n"));

			SingleFileLockTestsL();

			// Can call EndBackup synchronously here as nothing in SingleFileLockTests is asynchronous

			EndBackup(3, EFalse);

			iLocalRTest->End();

			iState = EStateMachineEnd;

			Complete();

			break;

		case EStateMachineEnd:

			RDebug::Print(_L("\nEnd of state machine\n"));

			End();

			break;

		default:

			RDebug::Print(_L("\nCBackupTestsStateMachine::RunL problem"));

			break;

		}

	if (!IsActive())

		{

		SetActive();

		}

	}

void CBackupTestsStateMachine::DoCancel()

	{

	Complete();

	}

void CBackupTestsStateMachine::RunError()

	{ ; }

// Common function to start a backup

void CBackupTestsStateMachine::StartBackupL()

	{

	TBackupOperationAttributes attribs;

	attribs.iFileFlag=MBackupObserver::EReleaseLockNoAccess;

	attribs.iOperation=MBackupOperationObserver::EStart;

	iBackupSession->NotifyBackupOperationL(attribs);

	RDebug::Print(_L("\nStarting backup\n"));

	}

void CBackupTestsStateMachine::SignalEndBackupL()

	{

	// Tell the server the backup is over

	TBackupOperationAttributes attribs;

	attribs.iFileFlag=MBackupObserver::EReleaseLockNoAccess;

	attribs.iOperation=MBackupOperationObserver::EEnd;

	iBackupSession->NotifyBackupOperationL(attribs);

	}

// This function works in two ways. If oneTimeOnly is ETrue then all file lock

// change notifications must have been received before this function is called.

// If oneTimeOnly is EFalse this function recursively calls itself (a finate number

// of times) until all notifications have arrived (this happens with single file testing)

void CBackupTestsStateMachine::EndBackup(TInt aFileLockChangesExpected, TBool oneTimeOnly)

	{

	// Get the total notification count so far

	TInt numberOfObservers = iBackupFileObservers.Count();

	TInt totalNotificationCount = 0;

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

		{

		totalNotificationCount += iBackupFileObservers[i]->GetFileLocksChanged();

		}

	if (aFileLockChangesExpected == totalNotificationCount)

		{

		// Reset the recursion count

		iEndBackupRecursionCount = 0;

		// Zero the notification counts in the file lock observers

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

			{

			iBackupFileObservers[i]->ZeroFileLocksChanged();

			}

		// Debug output

		TBuf<100> buf;

		buf.Format(_L("\nBackup finished sucsessfully on recusion count %d of EndBackup\n"), iEndBackupRecursionCount);

		RDebug::Print(buf);

		}

	else if (oneTimeOnly)

		{

		// No second chances - fail here

		(*iLocalRTest)(EFalse);

		}

	else

		{

		// Give it 5 more seconds (in 10 .5 second iterations) for the notifications to arrive

		User::After(500000);

		// 5 seconds is more than enough (timeouts in server should have gone off by now anyway)

		iEndBackupRecursionCount++;

		if (iEndBackupRecursionCount > 10)

			{

				(*iLocalRTest)(EFalse);

			}

		// Recursively calling isn't great but it needs to leave the function so the AO can run

		EndBackup(aFileLockChangesExpected, EFalse);

		}

	}

void CBackupTestsStateMachine::Complete()

	{

	// Trigger the Active Object locally

	TRequestStatus* tempStatus=(&iStatus);

	User::RequestComplete(tempStatus, KErrNone);

	}

void CBackupTestsStateMachine::Start()

	{

	// Time to start testing

	RDebug::Print(_L("\nCBackupTestsStateMachine::Start"));

	Complete();

	}

void CBackupTestsStateMachine::End()

	{

	// We're done testing - kill the Active Scheduler

	RDebug::Print(_L("\nAll test complete\n"));

	Cancel();

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

	}

void CBackupTestsStateMachine::SingleFileLockTestsL()

	{

	TFileName file;

	// File 1

	file.Copy(KFileName1);

	iLocalRTest->Next(file);

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

	iBackupSession->RestartFile(file);

//	iBackupSession->CloseFileL(KFileName1, MBackupObserver::EReleaseLockNoAccess);

//	iBackupSession->RestartFile(file);

	// File 2

	file.Copy(KFileName2);

	iLocalRTest->Next(file);

	iBackupSession->CloseFileL(KFileName2, MBackupObserver::EReleaseLockReadOnly);

	iBackupSession->RestartFile(file);

//	iBackupSession->CloseFileL(KFileName2, MBackupObserver::EReleaseLockNoAccess);

//	iBackupSession->RestartFile(file);

	// File 3

	file.Copy(KFileName3);

	iLocalRTest->Next(file);

	iBackupSession->CloseFileL(KFileName3, MBackupObserver::EReleaseLockReadOnly);

	iBackupSession->RestartFile(file);

//	iBackupSession->CloseFileL(KFileName3, MBackupObserver::EReleaseLockNoAccess);

//	iBackupSession->RestartFile(file);

	// File 3

	file.Copy(KFileName4);

	iLocalRTest->Next(file);

	iBackupSession->CloseFileL(KFileName4, MBackupObserver::EReleaseLockReadOnly);

	iBackupSession->RestartFile(file);

//	iBackupSession->CloseFileL(KFileName4, MBackupObserver::EReleaseLockNoAccess);

//	iBackupSession->RestartFile(file);

	}

/**

@SYMTestCaseID          SYSLIB-BAFL-CT-0467

@SYMTestCaseDesc        Tests the functionality of CBaBackupSessionWrapper class

@SYMTestPriority        High

@SYMTestActions         Tests for the enabling backup of files

@SYMTestExpectedResults Test must not fail

@SYMREQ                 REQ0000

*/

LOCAL_D void StartTestsL()

	{

	// For the sake of logging let's start off by renaming the main "command" thread

	RThread().RenameMe(_L("Main thread"));

	// Create state machine

	CBackupTestsStateMachine* stateMachine = CBackupTestsStateMachine::NewL();

	// Kick it off

	stateMachine->Start();

	// Start the Active Scheduler

	CActiveScheduler::Start();

	// Clean up the state machine

	delete stateMachine;

	}

TInt E32Main()

	{

	MainTest.Title();

	MainTest.Start(_L(" @SYMTestCaseID:SYSLIB-BAFL-CT-0467 Loading Device"));

	__UHEAP_MARK;

	CTrapCleanup* theTrapCleanup=CTrapCleanup::New();

	CActiveScheduler *activeScheduler=new CActiveScheduler;

	CActiveScheduler::Install(activeScheduler);

	TRAPD(error, StartTestsL());

	User::LeaveIfError(error);

	delete activeScheduler;

	delete theTrapCleanup;

	__UHEAP_MARKEND;

	MainTest.End();

	return(KErrNone);

	}