void CT_KeypadDriverData::ProcessResults()
	{
	INFO_PRINTF1(_L("Processing results"));

	if (iActualStore.Count() == iExpectedStore.Count())
		{
		for(TInt i = 0; i < iActualStore.Count(); i+=2)
			{
			if(	iActualStore[i] != iExpectedStore[i]	)//compare event
				{
				ERR_PRINTF3(_L("Expected event (%d) does not match Actual event (%d)! "), iExpectedStore[i], iActualStore[i]);
				SetBlockResult(EFail);
				}
			else
				{
				INFO_PRINTF2(_L("Expected event was: %d, Actual event matches the expected one."), iExpectedStore[i]);
				}

			if(iActualStore[i+1] == iExpectedStore[i+1])
				{
				INFO_PRINTF2(_L("Expected scancode was: %d. Actual scancode matches the expected one."), iExpectedStore[i+1]);
				}
			else
				{
				ERR_PRINTF3(_L("Actual scancode (%d) != expected scancode (%d)"), iActualStore[i+1], iExpectedStore[i+1]);
				SetBlockResult(EFail);
				}
			}
		}
	else
		{
		ERR_PRINTF3(_L("Actual results array count (%d) != expected results array count (%d)"), iActualStore.Count(), iExpectedStore.Count());
		SetBlockResult(EFail);
		}
	}

/**
Creates a second process, runs the requested test and ensures that
the specified panic occurs.

@param aExecutableName The name of the new process
@param aTestInfo The specification for this test
@param aPanicCategory Descriptor containing the start of the expected panic string e.g. for "ALLOC:xxxxxxxx" this would be "ALLOC"
@leave One of the system wide error codes
*/
void CTGraphicsResourceInternalBase::CreateSecondProcessAndCheckAllocPanicL(const TDesC &aExecutableName, TSgResIntTestInfo& aTestInfo, const TDesC &aPanicCategory)
	{
	// Create a second process
	RProcess process;
	TInt err = process.Create(aExecutableName, KNullDesC);
	TESTEL(KErrNone == err, err);
	CleanupClosePushL(process);

	// Specify the id passed to the second process
	TPckg<TSgResIntTestInfo> ptr(aTestInfo);
	err = process.SetParameter(KSecondProcessParametersSlot, ptr);
	TESTEL(KErrNone == err, err);

	// Kick off the second process and wait for it to complete
	// The actual testing is done in the second process
	TRequestStatus status;
	process.Logon(status);
	process.Resume();
	User::WaitForRequest(status);

	if(EExitPanic != process.ExitType())
		{
		ERR_PRINTF3(_L("Expected exit type: %d, Actual exit type: %d"), EExitPanic, process.ExitType());
		TEST(EFalse);
		}

	TExitCategoryName secondProcessExitCategory = process.ExitCategory();
	if(0 != secondProcessExitCategory.Match(aPanicCategory))
		{
		ERR_PRINTF3(_L("Expected panic category: %S, Actual panic category: %S"), &aPanicCategory, &secondProcessExitCategory);
		TEST(EFalse);
		}
	
	CleanupStack::PopAndDestroy();
	}

TBool CUpsClientStep::CheckDialogCreatorResultsL(TInt aIndex)
	{
	TBool checkPassed = ETrue;
	
	// checks return properties from dialog creator.
 	if (iArraySersToRequest[aIndex].iDialogCreatorInvoked != 0)
		{
		TInt instanceDia = iArraySersToRequest[aIndex].iDialogCreatorInvoked;
		TInt dialogError = 0;
		iPropertyReader->GetL(instanceDia,KDc_Error,CUpsProperty::EDialogCreator, dialogError);
		
		// Checks that any error encountered by dialog creator is transmited by UPS to system server
		if(dialogError != iReturnData.iError && dialogError!=KErrNone)
			{
			ERR_PRINTF3(_L("%S: Dialog creator found an error: %d"),&iTEFServerName,dialogError);
			checkPassed = EFalse; 	
			}
		
		TInt clientSidDia=0;
		iPropertyReader->GetL(instanceDia,KDc_ClientSid,CUpsProperty::EDialogCreator, clientSidDia);
	     
	    if(iExpectedClientSid != clientSidDia)
		    {
		    ERR_PRINTF2(_L("%S: Client SID returned by dialog creator is not what is expected"),&iTEFServerName);
			checkPassed = EFalse;
		    }
	    
	    TInt buttonsDisplayed=0;
		iPropertyReader->GetL(instanceDia,KDc_UpsRequestedButtons,CUpsProperty::EDialogCreator, buttonsDisplayed);
	    TInt32 expectedButtonsDisplayed=iArraySersToRequest[aIndex].iButtonsDisplayed;
	    if(expectedButtonsDisplayed != buttonsDisplayed)
		    {
		   	ERR_PRINTF2(_L("%S: Incorrect buttons displayed."),&iTEFServerName);
		   	ERR_PRINTF3(_L("%S: Buttons displayed expected: %d"),&iTEFServerName,expectedButtonsDisplayed);
		   	ERR_PRINTF3(_L("%S: Buttons displayed received: %d"),&iTEFServerName,buttonsDisplayed);
			checkPassed = EFalse;
		    }
	    
	    TInt serverSidDia=0;
		iPropertyReader->GetL(instanceDia,KDc_ServerSid,CUpsProperty::EDialogCreator, serverSidDia);
	     
	    if(iServerId != serverSidDia)
		    {
		   	ERR_PRINTF2(_L("%S: Server SID returned by dialog creator is not what is expected"),&iTEFServerName);
			checkPassed = EFalse;
		    } 
	    
	    TInt serviceSidDia=0;
		iPropertyReader->GetL(instanceDia,KDc_ServiceId,CUpsProperty::EDialogCreator, serviceSidDia);
		if(serviceSidDia != iArraySersToRequest[aIndex].iServiceUID)
		    {
		   	ERR_PRINTF3(_L("%S: Service ID reported by dialog creator is not what is expected: %d"),&iTEFServerName,serviceSidDia);
			checkPassed = EFalse;
		    }  
		}
	
	return checkPassed;
	}  // End of function.

void CT_DataRSocketServ::DoCmdVersion(const TDesC& aSection)
	{	

	INFO_PRINTF1(_L("Calling RSocketServ::Version()"));			
	TVersion				version = iSocketServ->Version();
	TBuf<KMaxVersionName>	versionName(version.Name());

	INFO_PRINTF2(_L("Version name  : %S"), &versionName);
	INFO_PRINTF2(_L("Version build : %d"), (TInt)version.iBuild);
	INFO_PRINTF2(_L("Version major : %d"), (TInt)version.iMajor);
	INFO_PRINTF2(_L("Version minor : %d"), (TInt)version.iMinor);			 

	TPtrC	expectedVersionName;
	if( GetStringFromConfig(aSection, KExpectedVersionName(), expectedVersionName) )
		{
		if( version.Name() != expectedVersionName )
			{
			ERR_PRINTF3(_L("Expected Version Name (%S) != Actual Version Name (%S)"), &expectedVersionName, &versionName);
			SetBlockResult(EFail);	
			}
		}
		
	TInt	intTemp;
	if( GetIntFromConfig(aSection, KExpectedVersionBuild(), intTemp) )
		{
		if( version.iBuild != intTemp )
			{
			ERR_PRINTF3(_L("Expected Version Build (%d) != Actual Version Build (%d)"), &intTemp, version.iBuild);
			SetBlockResult(EFail);	
			}
		}
		
	if( GetIntFromConfig(aSection, KExpectedVersionMajor(), intTemp) )
		{
		if( version.iMajor != intTemp )
			{
			ERR_PRINTF3(_L("Expected Version Major (%d) != Actual Version Major (%d)"), &intTemp, version.iMajor);
			SetBlockResult(EFail);	
			}
		}
	
	if( GetIntFromConfig(aSection, KExpectedVersionMinor(), intTemp) )
		{
		if( version.iMinor != intTemp )
			{
			ERR_PRINTF3(_L("Expected Version Minor (%d) != Actual Version Minor (%d)"), &intTemp, version.iMinor);
			SetBlockResult(EFail);	
			}
		}

	if (version.Name() == _L("") && version.iBuild == 0 && version.iMajor == 0 && version.iMinor == 0)
		{
		ERR_PRINTF1(_L("Some version fields are not set!"));
		SetBlockResult(EFail);
		}
	}

/**
Test BTAddr()
*/
void CT_InquirySockAddrData::DoCmdBTAddr(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("TInquirySockAddr BTAddr Call"));	
	TBTDevAddr btDevAddr = iData->BTAddr();
	
	TBuf<KMaxSockAddrSize> tmpbtDevAddr;
	btDevAddr.GetReadable(tmpbtDevAddr);
	INFO_PRINTF2(_L("Returned BT Addres = (%S)"), &tmpbtDevAddr);		
    TBuf<KMaxSockAddrSize> tmptBTDevAddrData; 

	TPtrC	tBTDevAddrName;
	TBool	foundParameter=EFalse;	
	TBool result = EFalse;
	
	if(GetStringFromConfig(aSection, KTBTDevAddr(), tBTDevAddrName))
		{
		foundParameter=ETrue;			
		TBTDevAddr* tBTDevAddrData=static_cast<TBTDevAddr*>(GetDataObjectL(tBTDevAddrName));

		tBTDevAddrData->GetReadable(tmptBTDevAddrData);
		INFO_PRINTF2(_L("Expected BT address = (%S) from ini file"), &tmptBTDevAddrData);

		result = btDevAddr==(*tBTDevAddrData);
		
		if ( !result )
			{
			ERR_PRINTF3(_L("BT Address (%S) is not as expected (%S)"),&tmpbtDevAddr, &tmptBTDevAddrData);
			SetBlockResult(EFail);
			}
		}
	
	TInt	intBtDevAddr=0;	
	if(GetIntFromConfig(aSection, KIntDevAddr(), intBtDevAddr))
		{
		foundParameter=ETrue;			
		const TBTDevAddr expectedBTAddr(intBtDevAddr);
		
		result = btDevAddr==(expectedBTAddr);
		btDevAddr.GetReadable(tmpbtDevAddr);
		if ( !result )
			{
			ERR_PRINTF3(_L("BT Address (%S) is not as expected (%d)"), &tmpbtDevAddr, intBtDevAddr);
			SetBlockResult(EFail);
			}
		}
		
	if( !foundParameter )
		{
		ERR_PRINTF3(KLogMissingParameters, &KTBTDevAddr(), &KIntDevAddr());
		SetBlockResult(EFail);
		}
	}

/**
  Function : doTestStepL
  Description : Checks the provisioned SNAP information for the POP account settings of a test case.
  @return : TVerdict - Test step result
*/		
TVerdict CT_MsgCheckPopSNAPSetting::doTestStepL()
	{
	INFO_PRINTF1(_L("Test Step : CheckPopSNAPSetting"));
	if(ReadIni())
		{
		CEmailAccounts* accounts = CEmailAccounts::NewL();
		CleanupStack::PushL(accounts);
		
		CImIAPPreferences* popIapPrefs = CImIAPPreferences::NewLC();
					
		TPopAccount popAccountId;
		CT_MsgUtilsCentralRepository::GetPopAccountL((TDes&)iPopAccountName,popAccountId);
				
		accounts->LoadPopIapSettingsL(popAccountId, *popIapPrefs);	
		
		TBool actualSNAPDefintion = popIapPrefs->SNAPDefined();
		
		if (actualSNAPDefintion == iExpectedSNAPDefinition)
			{
			if (actualSNAPDefintion)
				{
				TInt expectedSNAPPreference = 0;
				if(!GetIntFromConfig(ConfigSection(), KSNAPPreference, expectedSNAPPreference))
					{
					ERR_PRINTF1(_L("An expected SNAP ID value is not specified"));
					SetTestStepResult(EFail);
					CleanupStack::PopAndDestroy(2,accounts); // popIapPrefs, accounts
					return TestStepResult();
					}
				TInt actualSNAPPreference = popIapPrefs->SNAPPreference();
				
				if (actualSNAPPreference != expectedSNAPPreference)
					{
					ERR_PRINTF3(_L("Actual SNAP ID [%d] does not equal Expected SNAP ID [%d]"),actualSNAPPreference,expectedSNAPPreference);
					SetTestStepResult(EFail);
					}
				else
					{
					INFO_PRINTF3(_L("Actual SNAP ID [%d] equals Expected SNAP ID [%d]"),actualSNAPPreference,expectedSNAPPreference);
					}
				}
			}
		else
			{
			ERR_PRINTF3(_L("Actual SNAP Defintion [%d] does not equal Expected SNAP Defintion [%d]"),actualSNAPDefintion,iExpectedSNAPDefinition);
			SetTestStepResult(EFail);
			}
	
		CleanupStack::PopAndDestroy(2,accounts); // popIapPrefs, accounts
		}
	return TestStepResult();
	}

/** Calls CFbsFont::HasCharacter() */
void CT_DataFbsFont::DoCmdHasCharacter(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("Calls CFbsFont::HasCharacter()"));

	// get character code from parameters
	TInt	charCode = 0;
	if(!GetIntFromConfig(aSection, KCharCode(), charCode))
		{
		ERR_PRINTF2(_L("No %S"), &KCharCode());
		SetBlockResult(EFail);
		}
	else
		{
		// call HasCharacter()
		TBool	actual = iFbsFont->HasCharacter(charCode);

		TBool	expected;
		if(GetBoolFromConfig(aSection, KExpectedBool(), expected))
			{
		// check that the value is as expected
			if (actual != expected)
				{
				ERR_PRINTF3(_L("The value is not as expected! expected: %d, actual: %d"), expected, actual);
				SetBlockResult(EFail);
				}
			}
		}
	}

TVerdict CTestStepSDevSoundClientThreadNoCap::DoVerifyResult()
{
    if (iCallbackError != iExpectedValue)
    {
        ERR_PRINTF3 (_L("DevSound ToneFinished returned %d, expected %d"), iCallbackError, iExpectedValue);
        return EFail;
    }
    if (iServerResult != KErrUnderflow)
    {
        ERR_PRINTF2 (_L("DevSound(server-side) ToneFinished returned %d, expected 0"), iServerResult);
        return EFail;
    }
    if (iCallbackArray[EToneFinished] != 1)
    {
        ERR_PRINTF2 (_L("DevSound ToneFinished was called %d times, expected 1"), iCallbackArray[EToneFinished]);
        return EFail;
    }
    TInt tot = GetCallbackTotal();
    if (tot > 1)
    {
        ERR_PRINTF2 (_L("DevSound called %d callbacks, expected 1"), tot);
        return EFail;
    }
    return EPass;
}

/**
 Function : RetriveSearchSortResultL
 Description : Retrieves the search/sort result
 @return : none
 */
void CT_MsgSearchSortByQueryObject::RetriveSearchSortResultL(const TInt aIterationLimit, TMsvSearchSortResultType aResultType)
	{
	// Get the number of messages satisfying the search/sort request
	TInt resultCount = iSharedDataCommon.iSearchSortOperation->GetResultCountL();
	WriteIntToConfig(ConfigSection(), KCountOfResult, resultCount); 
	
	// Get the search/sort result according to user preference
	TMsvId messageId, serviceId;
	TMsvEntry messageEntry;
	iSharedDataCommon.iSearchSortResultArray.Reset(); // Flush out the existing search/sort result
	if (aIterationLimit > 0 && aResultType == EMsvResultAsTMsvId) // Iteration limit is one and result type is TMsvId
		{
		for(TInt index = 0; index < resultCount; ++index)
			{
			iSharedDataCommon.iSearchSortOperation->GetNextResultL(messageId);
			 // Get the corresponding index entry and append the same to array of entries.
			iSharedDataCommon.iSession->GetEntry(messageId, serviceId, messageEntry);
			iSharedDataCommon.iSearchSortResultArray.Append(messageEntry);
			}
		}
	else if(aIterationLimit > 0 && aResultType == EMsvResultAsTMsvEntry) // Iteration limit is one and result type is TMsvEntry
		{
		for(TInt index = 0; index < resultCount; ++index)
			{
			iSharedDataCommon.iSearchSortOperation->GetNextResultL(messageEntry);
			iSharedDataCommon.iSearchSortResultArray.Append(messageEntry);
			}
		}
	else if (aIterationLimit == 0 && aResultType == EMsvResultAsTMsvId) // No iteration and result type is TMsvId
		{
		RArray<TMsvId> idArray;
		TRAPD(error, iSharedDataCommon.iSearchSortOperation->GetResultsL(idArray));
		if(error == KErrNone)
			{
			// Get the corresponding index entries and create an array of entries.
			for(TInt index = 0; index < idArray.Count(); ++index)
				{
				iSharedDataCommon.iSession->GetEntry(idArray[index], serviceId, messageEntry);
				iSharedDataCommon.iSearchSortResultArray.Append(messageEntry);
				}
			}
		else
			{
			SetTestStepError(error);
			}
		}
	else // No iteration and result type is TMsvEntry
		{
//		RArray<TMsvEntry> entryArray;
		TRAPD(error, iSharedDataCommon.iSearchSortOperation->GetResultsL(iSharedDataCommon.iSearchSortResultArray));
		SetTestStepError(error);
		}
	// Ensure Number of Entries in iSharedDataCommon.iSearchSortResultArray is same as the result count
	if(iSharedDataCommon.iSearchSortResultArray.Count() != resultCount)
		{
		ERR_PRINTF1(_L("MisMatch in Result count and Entries retrieved"));
		ERR_PRINTF3(_L("Search-sort result count= %d Entries retrieved= %d"), resultCount, iSharedDataCommon.iSearchSortResultArray.Count());
		SetTestStepResult(EFail);
		}
	}

/**
 *
 * Check the config file for a TInt value
 *
 * @param	"const TDesC &aSectName"
 *			Section name to check in
 *
 * @param	"const TDesC &aKeyName"
 *			Key name to check for
 *
 * @param	"TInt &aResult"
 *			TInt returned from config file
 *
 * @return	"TBool"
 *			Result (ETrue if found)
 *
 * @xxxx
 *
 */
EXPORT_C TBool RTestStep::GetIntFromConfig(const TDesC &aSectName, const TDesC &aKeyName, TInt &aResult)
	{
	// check file available
	if ( !iConfigDataAvailable )
		{
		ERR_PRINTF1(_L("No config file available"));
		return EFalse;
		}	

	TBool ret = EFalse;
	TPtrC result;

	// get the value 
	ret = iConfigData->FindVar(aSectName, aKeyName, result);

	// if failed to decode display error
	if (!ret) 
		{
		// display error message
		ERR_PRINTF3(_L("Failed to read section:%S key:%S "),
				&aSectName, &aKeyName );

		// return fail
		return EFalse;
		}

	// use TLex to convert to a TInt
	TLex lex(result);
	if (lex.Val(aResult) == KErrNone)
		return ETrue;
	else
		return EFalse;
}

/**
doTestStepL()
Reads the expected count from the ini file.
Obtains the count of the POP accounts created and compares against the expected number.

@return
Returns the test step result.
*/
TVerdict CT_MsgVerifyPopAccountsCount::doTestStepL()
	{
	INFO_PRINTF1(_L("Test Step: Verify Pop Accounts Count"));
	TInt expectedCount = -1;
	if(!GetIntFromConfig(ConfigSection(), KExpectedCount, expectedCount) && expectedCount < 0)
		{
		ERR_PRINTF1(_L("ExpectedCount is not Specified or < 0"));
		SetTestStepResult(EFail);
		}
	else
		{
		CEmailAccounts *account = CEmailAccounts::NewLC();	
		RArray<TPopAccount> arrayPopAccounts;
		account->GetPopAccountsL(arrayPopAccounts);
		TInt count = arrayPopAccounts.Count();
		
		CleanupStack::PopAndDestroy(account);
		arrayPopAccounts.Reset();
		
		if (count != expectedCount)
			{
			ERR_PRINTF3(_L("Number of POP accounts do not match ! expected = %d actual = %d"), 
									  expectedCount, count);
			SetTestStepResult(EFail);
			}
		else
			{
			INFO_PRINTF2(_L("Number of POP accounts matched value = %d !"), expectedCount);	
			}			
		}
	return TestStepResult();
	}

/**
Test SetBTAddr()
*/
void CT_InquirySockAddrData::DoCmdSetBTAddr(const TDesC& aSection)
	{	
	TPtrC	tBTDevAddrName;
	TBool	foundParameter=EFalse;	
	
	if(GetStringFromConfig(aSection, KTBTDevAddr(), tBTDevAddrName))
		{
		foundParameter=ETrue;			
		CT_BTDevAddrData* tBTDevAddrData=static_cast<CT_BTDevAddrData*>(GetDataWrapperL(tBTDevAddrName));
		const TBTDevAddr* btDevAddr = tBTDevAddrData->GetAddress();
		
		INFO_PRINTF1(_L("TInquirySockAddr SetBTAddr Call"));
		iData->SetBTAddr(*btDevAddr);
		}
	
	TInt	intBtDevAddr=0;	
	if(GetIntFromConfig(aSection, KIntDevAddr(), intBtDevAddr))
		{
		foundParameter=ETrue;			
		const TBTDevAddr btDevAddr(intBtDevAddr);
		
		INFO_PRINTF1(_L("TInquirySockAddr SetBTAddr Call"));	
		iData->SetBTAddr(btDevAddr);
		}
		
	if( !foundParameter )
		{
		ERR_PRINTF3(KLogMissingParameters, &KTBTDevAddr(), &KIntDevAddr());
		SetBlockResult(EFail);
		}
	}

void CTestDevVideoPlayClock::MmcspuoTick(const TTimeIntervalMicroSeconds& aTime)
	{
	iPeriodicUtilityIteration++;

	TUint currentTime = I64LOW(aTime.Int64());
	TUint predictedTime = iPeriodicUtilityIteration * KTestClock2Seconds;

	if (!TimeComparison(currentTime, predictedTime, KTestClockBigDeviationMS))
		{
		ERR_PRINTF3(_L("Error - Periodic Utility time comparison failed:  Got %u;  Expected %u"), currentTime, predictedTime);
		iPeriodicUtilityTestVerdict = EFail;
		iPeriodicUtility->Stop();
		CActiveScheduler::Stop();
		}
	else
		{
		INFO_PRINTF3(_L("Periodic Utility time comparison passed:  Got %u;  Expected %u"), currentTime, predictedTime);
		}

	if (iPeriodicUtilityIteration >= 5)
		{
		iPeriodicUtility->Stop();
		CActiveScheduler::Stop();
		}
	}

void CT_DataAnimDll::DoCmdLoad(const TDesC& aSection)
	{
	TInt err = KErrNone;
	
	// Get test data for command input parameter(s)
	TPtrC fileName;
	if(!GetStringFromConfig(aSection, KPlugInFileName(), fileName))
		{
		ERR_PRINTF2(KLogErrMissingPara, &KPlugInFileName());
		SetBlockResult(EFail);
		}
	else
		{	
		// Execute command and log parameters
		if (iAnimDll != NULL)
			{
			INFO_PRINTF1(KLogInfoCmdLoad1);
			err = iAnimDll->Load(fileName);
			}
		
		// Check the command return code
		if(err != KErrNone)
			{
			ERR_PRINTF3(KLogErrLoad, err, &fileName);
			SetError(err);
			}
		}
	}

/**
 *
 * TestInitialize
 * @param aDataType
 * @param aMode
 * @result TVerdict
 *
 */
TVerdict CTestStepSDevSoundPlayDataCap::TestInitialize(TMMFState aMode)
{
    TFourCC pcm16(KMMFFourCCCodePCM16); //default to pcm16 data type

    iCallbackError = KErrNone;
    iExpectedValue = KErrNone;

    ResetCallbacks();
    iAL->InitialiseActiveListener();

    INFO_PRINTF1(_L("Initializing DevSound"));
    // Initialize
    TRAPD(err, iMMFDevSound->InitializeL(*this, pcm16, aMode));
    if (err)
    {
        WARN_PRINTF2 (_L("DevSound InitializeL left with error = %d"), err);
        return EInconclusive;
    }
    else
    {
        CActiveScheduler::Start();
        if (iCallbackError != iExpectedValue)
        {
            ERR_PRINTF3 (_L("DevSound InitializeComplete returned %d, expected %d"), iCallbackError, iExpectedValue);
            return EFail;
        }
        if (iCallbackArray[EInitComplete] != 1)
        {
            ERR_PRINTF2 (_L("DevSound InitializeComplete was called %d times, expected 1"), iCallbackArray[EInitComplete]);
            return EFail;
        }
    }
    return EPass;
}

void CT_EntryData::DoCmdAssignmentOperatorL( const TDesC& aSection )
/** Assigns another TEntry to this TEntry using "=" operator */
	{
	TPtrC entryObjectName;
	if( GET_MANDATORY_STRING_PARAMETER( KParamObject, aSection, entryObjectName ) )
		{
		INFO_PRINTF2( _L( "Assign a %S to this TEntry" ), &entryObjectName );
		
		TEntry* entryObject = NULL;
		TRAPD( err, entryObject = (TEntry*)GetDataObjectL(entryObjectName));
		if ( err == KErrNone && entryObject)
			{
			*iEntry = iEntry->operator=(*entryObject);
			}
		else
			{
			ERR_PRINTF3( _L( "Object not found or not initialised: %S. Error %d"), &entryObjectName, err );
			SetBlockResult( EFail );
			}
		}

	if ( !FileserverUtil::VerifyTEntryDataFromIniL(*this, aSection, *iEntry))
		{
		SetBlockResult(EFail);
		}
	}

/**
 *
 * InitializeDevSound
 * @param aDataType
 * @param aMode
 * @result TVerdict
 *
 */	
TVerdict CTestStepSDevSound::InitializeDevSound(TFourCC& aDataType, TMMFState aMode)
	{
	iCallbackError = KErrNone;
	iExpectedValue = KErrNone;
	
	iAL->InitialiseActiveListener();
	
	INFO_PRINTF1(_L("Initializing DevSound"));
	// Initialize
	TRAPD(err, iMMFDevSound->InitializeL(*this, aDataType, aMode));
	if (err)
		{
		WARN_PRINTF2 (_L("DevSound InitializeL left with error = %d"), err);
		return EInconclusive;
		}
	else
		{
		CActiveScheduler::Start();
		if (iCallbackError != iExpectedValue)
			{
			ERR_PRINTF3 (_L("DevSound InitializeComplete returned %d, expected %d"), iCallbackError, iExpectedValue);
			return EFail;
			}
		if (iCallbackArray[EInitComplete] != 1)
			{
			ERR_PRINTF2 (_L("DevSound InitializeComplete was called %d times, expected 1"), iCallbackArray[EInitComplete]);
			return EFail;
			}
		}
	return EPass;
	}

void CT_DataRSocketServ::DoCmdGetProtocolInfo(const TDesC& aSection)
	{	
	TInt	start = 1;
	TInt	end = iNumOfProtocols;
	
	TInt	index;
	if( GetIntFromConfig(aSection, KIndex(), index) )
		{
		start = index;
		end = index;
		}

	for( TInt i=start; i<=end; ++i )
		{
		INFO_PRINTF2(_L("Calling RSocketServ::GetProtocolInfo(%d)"), i);   
		TInt	err = iSocketServ->GetProtocolInfo(i, iProtocolDesc);
		if( err!=KErrNone )
			{
			ERR_PRINTF3(_L("RSocketServ::GetProtocolInfo(%d) failed with error %d"), i, err);
			SetError(err); 
			}
		else
			{
			PrintProtocol(_L("RSocketServ::GetProtocolInfo()"), iProtocolDesc);
			}
		}
	}

TVerdict COomTestStep::ImplOomServerTestL()
	{
	RScsClientBase *client = ClientHandle();
	if(!client)
		{
		ERR_PRINTF1(_L("ClientHandle has returned NULL. The server cannot be tested without the client handle!"));
		User::Leave(KErrArgument);
		}
	TInt err(0);
	for (TInt testCount=0; ; ++testCount)
 		{
 		INFO_PRINTF2(_L("OOM Server Test %d"), testCount);
 		err = client->SetServerHeapFail(testCount+1);
 		if(KErrNone != err)
 			{
 			ERR_PRINTF3(_L("OOM Server Test Result: Failed to set heap fail on iteration %d. Error:%d"), testCount, err);
 			SetTestStepResult(EFail);
 			break;
 			}
 		TRAPD(retStepVal, ImplTestStepL());
 		err = client->ResetServerHeapFail();
 		
 		if(KErrNone != err)
 			{
 			ERR_PRINTF3(_L("ResetServerHeapFail failed on iteration %d with error %d"), testCount, err);
 			SetTestStepResult(EFail);
 			break;
 			}
 					
 		if(KErrNoMemory == retStepVal)
 			{
 			INFO_PRINTF2(_L("Received correct out of memory error on iteration %d"), testCount);
 			}
 		else if (KErrNone == retStepVal)
 			{
 			INFO_PRINTF1(_L("Server OOM Test Finished"));
 			break;
 			}
 		else 
 			{
 			// Propagate all errors apart from KErrNoMemory
 			User::Leave(retStepVal);
 			}
 		}// for
	
	return TestStepResult();
	}

/**
Test GetFlowCtrl()
*/
void CT_RfcommRemotePortParamsData::DoCmdGetFlowCtrl(const TDesC& aSection)
	{
	TBool expected = EFalse;
	TBool param = EFalse;
	TInt	flowCtrlValue = 0;
	TUint8	exp = 0;
    TUint8	flowCtrl = 0;

	INFO_PRINTF1(_L("TRfcommRemotePortParams GetFlowCtrl Call"));
	TBool result = iData->GetFlowCtrl(flowCtrl);
	INFO_PRINTF3(_L("Return result (%d) and flow control on return (%d)"), result, flowCtrl);

	if(GetBoolFromConfig(aSection, KExpected(), expected) )
		{
		param = ETrue;
		if ( result != expected )
			{
			ERR_PRINTF3(_L("Result (%d) is not as expected (%d)"), result, expected);
			SetBlockResult(EFail);
			}
		else 
			{
			if ( result )
				{
				INFO_PRINTF1(_L("Verify that aFlowCtrl has been set with the expected value"));
				if(GetIntFromConfig(aSection, KFlowCtrl(), flowCtrlValue) )
					{
					param = ETrue;
					exp = flowCtrlValue;
				
					if ( flowCtrl != exp )
						{
						ERR_PRINTF3(_L("aFlowCtrl (%d) is not as expected (%d)"), flowCtrl, exp);
						SetBlockResult(EFail);
						}
						
					}
				}
			}
		}
	if ( !param )
		{
		ERR_PRINTF3(KLogMissingParameters, &KExpected(), &KFlowCtrl());
        SetBlockResult(EFail);
		}
	}