/*

* Copyright (c) 2005-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:  

* @file

* This contains CTestBlockController

*

*/

/**

 @prototype

 @test

*/

#include "TestBlockController.h"

#include "DataWrapper.h"

_LIT(KName,				"name");

// Errors

_LIT(KErrNotExist,			"Object does not exist.");

_LIT(KErrNoCleanup,			"Object does not have a cleanup operation.");

_LIT(KErrNoName,			"No name provided.");

_LIT(KErrNoFunction,		"No function provided.");

_LIT(KErrSharedData,		"Test server needs to be loaded in -SharedData mode.");

_LIT(KErrCmdUnknown,		"Unknown command.");

_LIT(KErrWrapperCreate,		"Can't create an object wrapper of type %S");

_LIT(KErrBlockCorrupt,		"Corrupt block of commands.");

_LIT(KErrActiveSched,		"Active Scheduler, error = %d");

_LIT(KErrSharedMode,		"-SharedData mode required.");

_LIT(KErrSchedulerLoc,		"SHARED_ACTIVE_SCHEDULER command must be first in block.");

_LIT(KLocalScheduler,		"Creating a local active scheduler.");

_LIT(KSharedScheduler,		"Creating a shared active scheduler.");

_LIT(KSharedServer,			"Error accessing the test server.");

_LIT(KErrOutstanding,		"Outstanding failed with error %d.");

// Defaults

const TInt				KDefaultDelay		= 1000000;

const TInt				KDefaultInterval	= 1000000;

EXPORT_C CTestBlockController::CTestBlockController()

/**

 * Constructor

 */

:	iBlockArray(NULL)

,	iCommandProcessor(NULL)

,	iActiveScheduler(NULL)

,	iTimer(NULL)

,	iPeriodic(NULL)

,	iAsyncTimer(EFalse)

,	iTimerActive(EFalse)

,	iCommandIndex(0)

,	iAsyncCount(0)

,	iSharedData(NULL)

,	iDeleteSharedScheduler(ETrue)

	{

	}

EXPORT_C CTestBlockController::~CTestBlockController()

/**

 * Destructor

 */

	{

	if( iTimer )

		{

		delete iTimer;

		iTimer=NULL;

		}

	if( iPeriodic )

		{

		delete iPeriodic;

		iPeriodic=NULL;

		}

	if( iCommandProcessor )

		{

		delete iCommandProcessor;

		iCommandProcessor=NULL;

		}

	if( iActiveScheduler )

		{

		delete iActiveScheduler;

		iActiveScheduler=NULL;

		}

	if( IsSharedDataMode() && iDeleteSharedScheduler && iSharedData)

		{

		TRAP_IGNORE(iSharedData->DeleteActiveSchedulerL());

		}

	}

EXPORT_C TVerdict CTestBlockController::doTestStepPreambleL()

	{

	TVerdict	ret = CTestStep::doTestStepPreambleL();

	if( !iSharedData )

		{

		ERR_PRINTF1(KSharedServer);

		User::Leave(KErrBadHandle);

		}

	// Test for a persistent active scheduler command

	if( ETEFSharedActiveScheduler == iBlockArray->At(iCommandIndex).iItemType )

		{

		if( IsSharedDataMode() )

			{

			INFO_PRINTF1(KSharedScheduler);

			iSharedData->CreateActiveSchedulerL();

			}

		else

			{

			iBlockArray->At(iCommandIndex).iError = KErrNotSupported;

			ERR_PRINTF1(KErrSharedMode);

			// Create a new active scheduler

			INFO_PRINTF1(KLocalScheduler);

			iDeleteSharedScheduler = EFalse;

			iActiveScheduler=new (ELeave) CBlockActiveScheduler(*this);

			CActiveScheduler::Install(iActiveScheduler);

			}

		iBlockArray->At(iCommandIndex).iExecuted = ETrue;

		iCommandIndex++;

		}

	else

		{

		if( IsSharedDataMode() )

			{

			// Ensure there is no persistent active scheduler if in -SharedData mode

			iSharedData->DeleteActiveSchedulerL();

			}

		// Create a new active scheduler

		INFO_PRINTF1(KLocalScheduler);

		iDeleteSharedScheduler = EFalse;

		iActiveScheduler=new (ELeave) CBlockActiveScheduler(*this);

		CActiveScheduler::Install(iActiveScheduler);

		}

	iCommandProcessor=CCommandProcessor::NewL(*this);

	iTimer=CTEFTimer::NewL(*this);

	iPeriodic=CPeriodic::NewL(CActive::EPriorityStandard);

	return ret;

	}

EXPORT_C TVerdict CTestBlockController::doTestStepL()

	{

	//	Execute oommands

	StartCommands();

	CActiveScheduler::Start();

	return TestStepResult();

	}

EXPORT_C TVerdict CTestBlockController::doTestStepPostambleL()

	{

	iDataDictionary.Empty();

	return TestStepResult();

	}

EXPORT_C void CTestBlockController::SetBlockArray( TTEFItemArray* aBlockArray )

	{

	iBlockArray = aBlockArray;

	}

EXPORT_C void CTestBlockController::SetSharedData( MSharedData* aSharedData )

	{

	iSharedData = aSharedData;

	}

EXPORT_C void CTestBlockController::SetError(const TInt aError)

	{

	iBlockArray->At(iCommandIndex).iError = aError;

	}

EXPORT_C void CTestBlockController::SetAsyncError(const TInt aIndex, const TInt aError)

	{

	iBlockArray->At(aIndex).iAsyncError = aError;

	}

EXPORT_C void CTestBlockController::SetBlockResult(const TVerdict aResult)

	{

	SetTestStepResult(aResult);

	}

EXPORT_C TVerdict CTestBlockController::BlockResult()

	{

	return TestStepResult();

	}

EXPORT_C TBool CTestBlockController::DoCommandL(TTEFBlockItem& aCommand, const TInt aAsyncErrorIndex)

	{

	TBool			synchronous	= ETrue;

	if( ETEFCreateObject==aCommand.iItemType )

		{

		CreateObjectL(aCommand);

		}

	else if( ETEFRestoreObject==aCommand.iItemType )

		{

		RestoreObjectL(aCommand);

		}

	else if( ETEFStore==aCommand.iItemType )

		{

		StoreL(aCommand);

		}

	else if( ETEFDelay==aCommand.iItemType )

		{

		User::After(aCommand.iTime?aCommand.iTime:KDefaultDelay );

		}

	else if( ETEFAsyncDelay==aCommand.iItemType )

		{

		synchronous=EFalse;

		StartTimer(aCommand);

		}

	else if( ETEFOutstanding==aCommand.iItemType )

		{

		synchronous=EFalse;

		iPeriodic->Start(	0,

							aCommand.iTime?aCommand.iTime:KDefaultInterval,

							TCallBack(OutstandingCallback,this));

		}

	else if( ETEFSharedActiveScheduler==aCommand.iItemType )

		{

		aCommand.iError = KErrNotSupported;

		ERR_PRINTF1(KErrSchedulerLoc);

		}

	else if( ETEFStoreActiveScheduler==aCommand.iItemType )

		{

		StoreActiveScheduler(aCommand);

		}

	else if( ETEFCommand==aCommand.iItemType )

		{

		CommandL(aCommand, aAsyncErrorIndex);

		}

	else

		{

		ERR_PRINTF1(KErrCmdUnknown);

		aCommand.iError = KErrNotSupported;

		}

	// Update the iExecuted flag

	aCommand.iExecuted = ETrue;

	return synchronous;

	}

void CTestBlockController::CreateObjectL(TTEFBlockItem& aCommand)

	{

	// Retrieve the object name from the ini file

	TPtrC	name;

	if( GetStringFromConfig(aCommand.iSection, KName, name) &&

		0 != aCommand.iSection.Compare(KTEFNull) )

		{

		// Create the wrapper

		CDataWrapper*	data = CreateDataL(aCommand.iObjectType);

		if( NULL != data)

			{

			CleanupStack::PushL(data);

			data->SetTestBlockController(this);

			data->SetDataDictionary(&iDataDictionary);

			data->InitialiseL();

			// Add it to the dictionary with the lookup name provided

			iDataDictionary.AddDataL(name, data);

			CleanupStack::Pop(data);

			}

		else

			{

			aCommand.iError = KErrNotFound;

			ERR_PRINTF2( KErrWrapperCreate, &name );

			}

		}

	else

		{

		ERR_PRINTF1(KErrNoName);

		aCommand.iError = KErrNotFound;

		}

	}

void CTestBlockController::RestoreObjectL(TTEFBlockItem& aCommand)

	{

	if( IsSharedDataMode() )

		{

		// Retrieve the object name from the ini file

		TPtrC	name;

		if( 0 != aCommand.iSection.Compare(KTEFNull) &&

			GetStringFromConfig(aCommand.iSection, KName, name) )

			{

			// Create the wrapper

			CDataWrapper*	data = CreateDataL(aCommand.iObjectType);

			if( NULL != data)

				{

				CleanupStack::PushL(data);

				data->SetTestBlockController(this);

				data->SetDataDictionary(&iDataDictionary);

				data->InitialiseL();

				// Add it to the dictionary with the lookup name provided

				iDataDictionary.AddDataL(name, data);

				// Retrieve the object from the persistent store

				TAny*	object = NULL;

				TRAPD( err, object = iSharedData->GetObjectAndOwnL(name) );

				if( KErrNone == err )

					{

					CleanupStack::PushL(object);

					// Update the object contained within the wrapper

					iDataDictionary.SetObjectL(name, object);

					CleanupStack::Pop(object);

					}

				else

					{

					ERR_PRINTF1(KErrNotExist);

					iDataDictionary.DeleteDataL(name);

					aCommand.iError = KErrNotFound;

					}

				CleanupStack::Pop(data);

				}

			else

				{

				aCommand.iError = KErrNotFound;

				ERR_PRINTF2( KErrWrapperCreate, &name );

				}

			}

		else

			{

			ERR_PRINTF1(KErrNoName);

			aCommand.iError = KErrNotFound;

			}

		}

	else

		{

		ERR_PRINTF1(KErrSharedData);

		aCommand.iError = KErrNotSupported;

		}

	}

void CTestBlockController::StoreL(TTEFBlockItem& aCommand)

	{

	if( IsSharedDataMode() )

		{

		// Retrieve the object name from the ini file

		TPtrC	name;

		if( 0 != aCommand.iSection.Compare(KTEFNull) &&

			GetStringFromConfig(aCommand.iSection, KName, name) )

			{

			// Lookup the wrapper

			CDataWrapper*	data = iDataDictionary.GetDataL( name );

			// Retrieve the object being wrapped

			TAny*			object = data->GetObject();

			if ( object!=NULL )

				{

				// Add it to the persistent store

				TCleanupOperation	operation=data->CleanupOperation();

				if ( operation!=NULL )

					{

					iSharedData->PutAndDisownL(name, object, operation);

					data->DisownObjectL();

					}

				else

					{

					ERR_PRINTF1(KErrNoCleanup);

					aCommand.iError = KErrNotFound;

					}

				}

			else

				{

				ERR_PRINTF1(KErrNotExist);

				aCommand.iError = KErrNotFound;

				}

			}

		else

			{

			ERR_PRINTF1(KErrNoName);

			SetTestStepResult(EFail);

			}

		}

	else

		{

		ERR_PRINTF1(KErrSharedData);

		aCommand.iError = KErrNotSupported;

		}

	}

void CTestBlockController::StoreActiveScheduler(TTEFBlockItem& aCommand)

	{

	if( IsSharedDataMode() )

		{

		// Don't delete the persistent active scheduler

		iDeleteSharedScheduler = EFalse;

		}

	else

		{

		aCommand.iError = KErrNotSupported;

		ERR_PRINTF1(KErrSharedMode);

		}

	}

void CTestBlockController::CommandL(TTEFBlockItem& aCommand, const TInt aAsyncErrorIndex)

	{

	// Retrieve the object name from the ini file

	TPtrC	name;

	if( 0 != aCommand.iCommand.iObject.Compare(KTEFNull) &&

		GetStringFromConfig(aCommand.iCommand.iObject, KName, name) )

		{

		CDataWrapper*	data = iDataDictionary.GetDataL(name);

		if( data!=NULL )

			{

			TBool cmdExists = EFalse;

			TRAPD(err, cmdExists = data->DoCommandL(aCommand.iCommand.iFunction, aCommand.iSection, aAsyncErrorIndex));

			if (KErrNone != err)

				{

				ERR_PRINTF4(_L("Command \"%S\" of the object \"%S\" leaves with error code %d"), &aCommand.iCommand.iFunction, &aCommand.iCommand.iObject, err);

				aCommand.iError = err;

				SetBlockResult(EFail);

				}

			else if( !cmdExists )

				{

				ERR_PRINTF1(KErrNoFunction);

				aCommand.iError = KErrNotFound;

				}

			}

		else

			{

			ERR_PRINTF1(KErrNotExist);

			aCommand.iError = KErrNotFound;

			}

		}

	else

		{

		ERR_PRINTF1(KErrNoName);

		aCommand.iError = KErrNotFound;

		}

	}

EXPORT_C void CTestBlockController::StartTimer(const TTEFBlockItem& aCommand)

	{

	iTimer->After(aCommand.iTime?aCommand.iTime:KDefaultDelay);

	}

EXPORT_C void CTestBlockController::CancelTimer()

	{

	if ( iTimerActive )

		{

		iTimer->Cancel();

		}

	}

EXPORT_C void CTestBlockController::TimerCompleted()

	{

	if( iAsyncTimer )

		{

		DecAsyncCount();

		}

	iTimerActive=EFalse;

	StartCommands();

	}

EXPORT_C TBool CTestBlockController::OutstandingCallback( TAny* aAny )

	{

	CTestBlockController* self = STATIC_CAST(CTestBlockController*,aAny);

	if( self )

		{

		self->OutstandingCallback();

		}

	return EFalse;

	}

EXPORT_C void CTestBlockController::OutstandingCallback()

	{

	TBool			ok=ETrue;

	TTEFBlockItem&	block=iBlockArray->At(iCommandIndex-1);

	TPtrC			name(KTEFNull);

	if( 0 != block.iSection.Compare(KTEFNull)  )

		{

		if ( !GetStringFromConfig(block.iSection, KName, name) )

			{

			block.iError = KErrNotFound;

			ERR_PRINTF1(KErrNoName);

			ERR_PRINTF1(block.iSection);

			ok=EFalse;

			}

		}

	if ( ok )

		{

		TBool	moreToDo;

		TInt	err=iDataDictionary.Outstanding(name, moreToDo);

		if( err!=KErrNone )

			{

			block.iError = err;

			ERR_PRINTF2(KErrOutstanding, err);

			}

		if ( !moreToDo )

			{

			iPeriodic->Cancel();

			DecAsyncCount();

			StartCommands();

			}

		}

	}

EXPORT_C CTestBlockController::CBlockActiveScheduler::CBlockActiveScheduler(CTestBlockController& aTestStep)

:	CActiveScheduler()

,	iTestStep(aTestStep)

	{

	}

EXPORT_C CTestBlockController::CBlockActiveScheduler::~CBlockActiveScheduler()