/**
  Function 		: doTestStepL
  Description 	: 
  @return 		: TVerdict - Test step result
*/
TVerdict CT_CopyMsgsToExternalDrive::doTestStepL()
	{	
	INFO_PRINTF1(_L("Test Step: CopyMsgsToExternalDrive"));
	
	TInt extDrive = EDriveD;
	GetIntFromConfig(ConfigSection(), KDrive, extDrive);

	CT_MsgActive&	active=Active();
	delete iOperation;
	iOperation = NULL;		
	iOperation = iSharedDataIMAP.iSession->CopyStoreL(extDrive, active.iStatus);
	active.Activate();
	CActiveScheduler::Start();
	return TestStepResult();
	}

void CTestExplicitSessionStep::StartClientL()
	{
	TPtrC uri;
	TInt iap = 0;
	
    if (!GetStringFromConfig(ConfigSection(), KIniUri, uri) ||
    	!GetIntFromConfig(ConfigSection(), KIAP, iap)
    	)
		{
		ERR_PRINTF3(_L("Problem in reading values from ini.			\
						\nExpected fields are: \n%S\n%d"
					  ),&KIniUri, iap);
		SetTestStepResult(EFail);
		return;
		}

/**
 * Third phase construction
 *
 * @internalComponent
 *
 * @return	N/A
 *
 * @pre		None
 * @post	None
 *
 * @leave	system wide error
 */
void CT_RMobileCallData::InitialiseL()
	{
	CDataWrapperBase::InitialiseL();
	GetIntFromConfig(KDefaultSection, KMaxPhoneCalls, iMaxPhoneCalls );

	RMobileCall* mobileCall=  NULL;
	for (TInt i = 0; i < iMaxPhoneCalls; ++i)
		{
		// RMobileCalls
		mobileCall = new (ELeave) RMobileCall(); // We need a bunch of RMobileCall handles
		CleanupStack::PushL (mobileCall);
		iMobileCalls.AppendL (mobileCall);
		CleanupStack::Pop (mobileCall);
		}
	}

TInt CTS_MultiHomingStep::SetConnPrefs(TCommDbConnPref& aPrefs, TDesC& aName)
/**
 * Fills up a CStoreableOverrideSettings* with script file configs
 * @param aPrefs A pointer to a CStoreableOverrideSettings object
 * @param aName Name of the connection to get prefs for
 * @return KErrNone if sucessful, otherwise system wide error codes
 * @exception Can leave
 */
	{

	TInt theIap = 0;
	TInt theNet = 0;
	// Get the IAP index and use it to complete the .ini file section name
	if(GetIntFromConfig(aName, KConnIap, theIap))
		{
		aPrefs.SetIapId(theIap);		
		}

	if(GetIntFromConfig(aName, KConnNet, theNet))
		{
		aPrefs.SetNetId(theNet);
		}
	return KErrNone;
	}

/**
Test SetMinWindowSize()
*/
void CT_AvdtpRecoveryCapabilitiesData::DoCmdSetMinWindowSize(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("TAvdtpRecoveryCapabilities SetMinWindowSize() Call"));
	
	TInt size = 0;
	if( GetIntFromConfig(aSection, KMinWindowSize, size) )
		{
		iAvdtpRecoveryCapabilities->SetMinWindowSize(size);
		}
	else
		{
		ERR_PRINTF2(KLogMissingParameter, &KMinWindowSize);
		SetBlockResult(EFail);		
		}
	}

/**
	Postamble for all CEtelMMLbsTestStepBase
*/
TVerdict CEtelMMLbsTestStepBase::doTestStepPostambleL()
	{
	TInt lbsCloseFlag ;
	TBool existsLbsCloseFlag = GetIntFromConfig(ConfigSection(), _L("LbsCloseFlag"), lbsCloseFlag);
	if(!existsLbsCloseFlag)
		{
		iLocationSvc.Close();
		INFO_PRINTF1(_L("Test- RMobileLocationServices::Close request"));
		}
	iPhone.Close();	
	
	//base class postamble
	CEtelMMTestStepBase::doTestStepPostambleL();
 	return TestStepResult() ;
	}

TVerdict CUpnpResponseComposerTest::doTestStepL()
	{
	TBool responseBodyPresence;
	TInt responseStatusCode;
	TPtrC responseStatusText;
	TInt noOfHdrValPairs;
	TInt noOfHdrParamValPairs;
	RMemoryAllocator allocator ( iMBufMgr );
	
	if( !GetIntFromConfig(ConfigSection(), KResponseStatusCode, responseStatusCode) ||
		!GetStringFromConfig(ConfigSection(), KResponseStatusText, responseStatusText) ||
		!GetBoolFromConfig(ConfigSection(), KResponseBodyPresence, responseBodyPresence) ||
		!GetIntFromConfig(ConfigSection(), KNoOfHdrValPairs, noOfHdrValPairs) ||
		!GetIntFromConfig(ConfigSection(), KNoOfHdrParamValPairs, noOfHdrParamValPairs)
			)
		{
		ERR_PRINTF6(_L("===> Problem in reading values from ini.			\
				\nExpected fields are: \n%S\n%S\n%S\n%S\n%S <==="
			  ), &KResponseStatusCode, &KResponseStatusText, &KResponseBodyPresence,
			  &KNoOfHdrValPairs, &KNoOfHdrParamValPairs);
		
		SetTestStepResult(EFail);
		return TestStepResult();
		}

TBool CDataWrapperBase::GetRectFromConfig(const TDesC& aSectName, const TDesC& aKeyName, TRect& aResult)
	{
	TBuf<KMaxTestExecuteCommandLength>	tempStore;

	TInt	top;
	tempStore.Format(KFormatEntryField, &aKeyName, &KTagRectTop);
	TBool	ret=GetIntFromConfig(aSectName, tempStore, top);

	TInt	left;
	tempStore.Format(KFormatEntryField, &aKeyName, &KTagRectLeft);
	if ( !GetIntFromConfig(aSectName, tempStore, left) )
		{
		ret=EFalse;
		}

	TInt	bottom;
	tempStore.Format(KFormatEntryField, &aKeyName, &KTagRectBottom);
	if ( !GetIntFromConfig(aSectName, tempStore, bottom) )
		{
		ret=EFalse;
		}

	TInt	right;
	tempStore.Format(KFormatEntryField, &aKeyName, &KTagRectRight);
	if ( !GetIntFromConfig(aSectName, tempStore, right) )
		{
		ret=EFalse;
		}

	if ( ret )
		{
		aResult.SetRect(left, top, right, bottom);
		}

	return ret;
	}

TBool CDataWrapperBase::GetWsGraphicIdFromConfigL(const TDesC& aSectName, const TDesC& aKeyName, TWsGraphicId& aResult)
	{
	TBuf<KMaxTestExecuteCommandLength>	tempStore;

	TInt	id;
	tempStore.Format(KFormatEntryField, &aKeyName, &KTagWsGraphicIdUid);
	TBool	ret=GetIntFromConfig(aSectName, tempStore, id);

	if ( ret )
		{
		TUid	uid=TUid::Uid(id);
		aResult.Set(uid);
		}
	else
		{
		tempStore.Format(KFormatEntryField, &aKeyName, &KTagWsGraphicIdId);
		ret=GetIntFromConfig(aSectName, tempStore, id);
		if ( ret )
			{
			aResult.Set(id);
			}
		else
			{
			tempStore.Format(KFormatEntryField, &aKeyName, &KTagWsGraphicIdName);
			TPtrC	name;
			ret=GetStringFromConfig(aSectName, tempStore, name);
			if ( ret )
				{
				CDataWrapperBase*	wrapper=static_cast<CDataWrapperBase*>(GetDataWrapperL(name));
				aResult=wrapper->GetId();
				}
			}
		}

	return ret;
	}

/**
Tests the count functionality( finds the count of all matched uris of specific servicetype/list-type
and check that returned count is correct if it is positive and non-capability test.
It reads values from INI file and gets the count of matching URIs of specific service/list type from database
@internalTechnology
@test
@param		None
@return		EPass or EFail indicating the success or failure of the test step
*/
TVerdict CTestUriCountStep::doTestStepL()
{
    __UHEAP_MARK;
    INFO_PRINTF1(_L("\n"));
    // Get necessary information from INI file

    TInt listType;
    TInt serviceType;
    TInt expCountOrErrCode;
    TInt actCountOrErrCode;
    TBool isCapabilityTest;

    if(!GetIntFromConfig(ConfigSection(), 	KIniListType, listType) ||
            !GetIntFromConfig(ConfigSection(), 	KIniServiceType, serviceType) ||
            !GetIntFromConfig(ConfigSection(), KIniExpCountOrErrCode, expCountOrErrCode) ||
            !GetBoolFromConfig(ConfigSection(), KIniIsCapabilityTest, isCapabilityTest)
      )
    {
        ERR_PRINTF5(_L("Problem in reading values from ini.			\
						\nExpected fields are: \n%S\n%S\n%S\n%S\n"
                      ),&KIniListType, &KIniServiceType, &KIniExpCountOrErrCode, isCapabilityTest
                   );
        SetTestStepResult(EFail);
    }

/**
Test SetIAC()
*/
void CT_InquirySockAddrData::DoCmdSetIAC(const TDesC& aSection)
	{
	TInt theIAC = 0;
	
	if (GetIntFromConfig(aSection, KIAC(), theIAC) )
		{
		INFO_PRINTF1(_L("TInquirySockAddr SetIAC Call"));
		iData->SetIAC((TUint)theIAC);
		}
	else
		{
		ERR_PRINTF2(KLogMissingParameter, &KIAC());
		SetBlockResult(EFail);
		}	
	}

/**
Test SetMinorClassOfDevice()
*/
void CT_InquirySockAddrData::DoCmdSetMinorClassOfDevice(const TDesC& aSection)
	{
	TInt classValue = 0;
	
	if (GetIntFromConfig(aSection, KClass(), classValue) )
		{
		INFO_PRINTF1(_L("TInquirySockAddr SetMinorClassOfDevice Call"));
		iData->SetMinorClassOfDevice((TUint8)classValue);
		}
	else
		{
		ERR_PRINTF2(KLogMissingParameter, &KClass());
		SetBlockResult(EFail);
		}	
	}

/** Calls TAlgSAtyle::SetWidthFactor() */
void CT_DataAlgStyle::DoCmdSetHeightFactor(const TDesC& aSection)
	{
	INFO_PRINTF1(_L("Calls TAlgSAtyle::SetHeightFactor()"));

	// get factor from parameters
	TInt	factor;
	if (!GetIntFromConfig(aSection, KFactor(), factor) )
		{
		ERR_PRINTF2(_L("No %S"), &KFactor());
		SetBlockResult(EFail);
		}

	// call SetHeightFactor()		
	iAlgStyle->SetHeightFactor(factor);
	}

void CT_RMobileCallData::DoCmdAnswerIncomingCallPost(const TTEFFunction& aSection, const TInt aAsyncErrorIndex)
	{
	INFO_PRINTF1(_L("*START*CT_RMobileCallData::DoCmdAnswerIncomingCallPost"));

	TInt callNameParameter;
	if ( !GetIntFromConfig(aSection, KCallName, callNameParameter))
		{
		ERR_PRINTF2(_L("Error in getting parameter %S from INI file"), &KCallName);
		SetBlockResult(EFail);
		}
	else
		{
		INFO_PRINTF1(_L("Getting mobile call"));
		TRAPD( error, iMobileCall = GetMobileCallL(callNameParameter) );
		if(error != KErrNone)
			{
			ERR_PRINTF2(_L("GetMobileCallL left when trying to obtain the MobileCall with error %d"), error);
			SetBlockResult(EFail);
			}
		else
			{
			INFO_PRINTF1(_L("Read call status to check if the other party hanged up."));
			RCall::TStatus callStatus;
			error = iMobileCall->GetStatus(callStatus);
			if ( error != KErrNone)
				{
				ERR_PRINTF2(_L("Failed to read mobile call's status [%d]"), error);
				SetError(error);
				}
			else
				{
				// Normal status of the connection is EStatusConnected.
				if ( callStatus == RCall::EStatusConnected)
					{
					INFO_PRINTF1(_L("Mobile call is connected."));
					}
				else
					{
					INFO_PRINTF1(_L("Mobile call was disconnected, hanging up."));
					iMobileCall->HangUp (iActiveCallback->iStatus);
					iActiveCallback->Activate (aAsyncErrorIndex);
					IncOutstanding ();
					}
				}
			}
		}
	INFO_PRINTF1(_L("*END*CT_RMobileCallData::DoCmdAnswerIncomingCallPost"));
	}

/**
	Preamble for all CEtelMMLbsTestStepBase
*/
TVerdict CEtelMMLbsTestStepBase::doTestStepPreambleL()
	{
	//base class preamble
	CEtelMMTestStepBase::doTestStepPreambleL();
	TInt ret=iPhone.Open(iTelServer,DMMTSY_PHONE_NAME);
	TEST(ret==KErrNone);
	TInt lbsOpenFlag ;
	TBool existsLbsOpenFlag = GetIntFromConfig(ConfigSection(), _L("LbsOpenFlag"), lbsOpenFlag);
	if(!existsLbsOpenFlag)
		{
		ret=iLocationSvc.Open(iPhone);
		TEST(ret == KErrNone);	
		INFO_PRINTF2(_L("Test %d - RMobileLocationServices::Open request"), ret);
		}
	return TestStepResult() ;
	}

TInt CTestSendsignal::TestSigKillwithTmpfile()
	{
	int ret = KErrGeneral, pid, pid1, Signum, status;
    ret = GetIntFromConfig(ConfigSection(),_L("Signum"), Signum);
    FILE* ff;
    if(ret == 0)
		{
		ERR_PRINTF1(_L("Failed to read the signal number\n")) ;
		goto close;
		}
	ff = tmpfile();
	if(ff == 0)
		{
		ERR_PRINTF2(_L("Unable to create temporary file, errno=%d\n"), errno);
		}
	else
		{
		fclose(ff);
		}
	//Run a second instance of the current test process
	ret = posix_spawn(&pid, "z:\\sys\\bin\\tsendsignal.exe", NULL, NULL, NULL, NULL);  
	if(ret == -1)
		{
		ERR_PRINTF2(_L("posix_spawn() has failed with error=%d\n"), errno);	
		goto close;
		}
	pid1 = waitpid(pid, &status, WUNTRACED);
	if (pid1 != pid)
		{
		ERR_PRINTF1(_L("waitpid failed...\n"));	
		goto close;
		}
	else
		{
		//Send a SIGKILL signall
		ret = kill(pid, Signum);
		if(ret < 0)
			{
			ERR_PRINTF2(_L("kill() has failed with error=%d\n"), errno);
			goto close;
			}
		INFO_PRINTF1(_L("Kill() on self successfull\n"));
		}
	INFO_PRINTF1(_L("Test Case successfull\n"));
	close:
	return ret;
	}

/**
@SYMTestCaseID			PIM-CIT-CallnterimAPI-1098AP-13				 
@SYMTestType			CIT
@SYMTestPriority		Medium
@SYMPREQ				1098
@SYMFssID				3.2.13, 001, 002, 003, 005, 
@SYMTestCaseDesc		Fetch entries
@SYMTestActions			Create a CCalIter, and move through the entries
@SYMTestExpectedResults	The iteration should be move through the entries successfully
*/
void CTestCalInterimApiIterator::IterateEntriesL()
	{
	TInt	expectedCount=0;
	GetIntFromConfig(ConfigSection(), KExpectedCount, expectedCount);
	INFO_PRINTF2(KInfoExpectedCount, expectedCount);
	
	const TFileName&		fileName=GetCalenderFileName();
	INFO_PRINTF2(KInfoFileName, &fileName);
	TInt					count=0;
	CCalIter*				iter=CCalIter::NewL(GetSession());
	CleanupStack::PushL(iter);

	TPtrC8	uid(iter->FirstL());
	while (KNullDesC8()!=uid)
		{
		++count;
		TBuf<MAX_TEXT_MESSAGE>	iterateUid;
		iterateUid.Copy(uid);
		INFO_PRINTF2(KInfoIterateCalFileUid, &iterateUid);
		uid.Set(iter->NextL());
		}

	//make sure we have iterated through all entries
	if ( expectedCount!=count )
		{
		ERR_PRINTF4(KErrIterateCalFileInvalidEntries, &fileName, expectedCount, count);
		SetTestStepResult(EFail);
		}

	if( TestStepResult() == EPass )
		{
		TRAPD(err, uid.Set(iter->NextL()));

		TInt	expectedErr=KErrNone;
		if ( count==0 )
			{
			expectedErr=KErrCorrupt;
			}
		if ( err!=expectedErr )
			{
			ERR_PRINTF2(KErrIterateEmptyFileNoEntries, err);
			SetTestStepResult(EFail);
			}	
		}
	CleanupStack::PopAndDestroy(iter);
	}

/**
 ReadFlags - read in bitwise measeure text input flags
 @internalComponent
 @param aSection - main entry in .ini file
 @param aFlags - bitwise flags output
 @return ETrue if data is valid in the ini file
 @pre None
 @post 2nd stage construction complete
*/
TBool CT_DataMeasureTextInput::ReadFlags(const TDesC& aSection, TUint16& aFlags)
	{
	TBuf<KMaxTestExecuteCommandLength>	tempStore;
	TInt								index=0;
	TBool								moreData=ETrue;
	TPtrC								flagString;
	TBool								ret=ETrue;

	aFlags=0;
	while ( moreData && ret )
		{
		tempStore.Format(KFlag(), &aSection, ++index);
		if ( GetStringFromConfig(aSection, tempStore, flagString) )
			{
			TInt	flag=0;

			if ( flagString==KEFVisualOrder )
				{
				flag=CFont::TMeasureTextInput::EFVisualOrder;
				}
			else if ( flagString==KEFVisualOrderRightToLeft )
				{
				flag=CFont::TMeasureTextInput::EFVisualOrderRightToLeft;
				}
			else if ( flagString==KEFIncludePenPositionInBoundsCheck )
				{
				flag=CFont::TMeasureTextInput::EFIncludePenPositionInBoundsCheck;
				}
			else
				{
				ret=GetIntFromConfig(aSection, tempStore, flag);
				}

			if ( ret )
				{
				aFlags |= flag;
				}
			}
		else
			{
			moreData=EFalse;
			}
		}

	return ret;
	}

/**
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);
		}
	}

/**
 Purpose: To test that an wrapped object exists in the dictionary. And optionally to check the object's value.

 @internalComponent
 @param  aSection Current ini file command section
 */
void CTEFLoggerTestWrapper::DoCmdGetDataObject(const TDesC& aSection)
	{
	// check if null is expected
	TBool nullExpected = EFalse;
	GetBoolFromConfig(aSection, KNullExpected(), nullExpected);

	// call GetDataObject() and check that the wrapped object is found
	TInt* wrappedObject= NULL;
	TRAPD(err, wrappedObject = static_cast<TInt*>(GetDataObjectL(aSection)));

	if (err != KErrNone)
		{
		ERR_PRINTF2(_L("GetDataObjectL() error: %d"), err);
		SetBlockResult(EFail);
		SetError(err);
		}

	// check if is null if is expetced to be null and vice versa
	if (wrappedObject == NULL && !nullExpected)
		{
		ERR_PRINTF1(_L("Wrapped object is not expected to be null!"));
		SetBlockResult(EFail);
		}
	else
		if (wrappedObject != NULL)
			{
			if (nullExpected)
				{
				ERR_PRINTF1(_L("Wrapped object is expected to be null!"));
				SetBlockResult(EFail);
				}
			else
				{
				// check expected value
				TInt objectValue = 0;
				if (GetIntFromConfig(aSection, KObjectValue(), objectValue))
					{
					if (*wrappedObject != objectValue)
						{
						ERR_PRINTF3(_L("Wrapped object's value is not as expected. expected=%d, actual=%d"), objectValue, *wrappedObject);
						SetBlockResult(EFail);
						}					
					}
				}
			}
	}