diff -r bbd31066657e -r 8bb370ba6d1d testexecfw/stf/stfext/testmodules/teftestmod/teftestmodulefw/utils/src/testblockcontroller.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/testexecfw/stf/stfext/testmodules/teftestmod/teftestmodulefw/utils/src/testblockcontroller.cpp	Fri Apr 09 10:46:28 2010 +0800
@@ -0,0 +1,577 @@
+/*
+* 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()
+	{
+	}
+
+EXPORT_C void CTestBlockController::CBlockActiveScheduler::Error(TInt aError) const
+	{
+	if ( KErrNone != aError )
+		{
+		iTestStep.ERR_PRINTF2(KErrActiveSched, aError);
+		iTestStep.SetTestStepResult(EFail);
+		}
+	CActiveScheduler::Error(aError);
+	}
+
+EXPORT_C void CTestBlockController::StartCommands()
+	{
+	iCommandProcessor->KickState();
+	}
+
+EXPORT_C void CTestBlockController::NextCommandL()
+	{
+	if( iBlockArray )
+		{
+		if( iCommandIndex < iBlockArray->Count() )
+			{
+			TInt synchronous = EFalse;
+			synchronous = DoCommandL(iBlockArray->At(iCommandIndex), iCommandIndex);
+			if( synchronous )
+				{
+				StartCommands();
+				}
+			else
+				{
+				IncAsyncCount();
+				}
+			iCommandIndex++;
+			}
+		else
+			{
+			CActiveScheduler::Stop();
+			}
+		}
+	else
+		{
+		ERR_PRINTF1(KErrBlockCorrupt);
+		SetTestStepResult(EFail);
+		CActiveScheduler::Stop();
+		}
+	}