/*

 * Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved.

 * This component and the accompanying materials are made available

 * under the terms of the License "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 "tupsdbmanagementstep.h"  

 #include "tupsintegdefs.h"

 #include <ups/upstypes.h>

 using namespace UserPromptService;

 _LIT(KOperationCreateView, "CreateView");

 _LIT(KOperationCancelCloseView, "CancelCloseView");

 _LIT(KOperationNextMatch, "NextMatch");

 _LIT(KOperationRemoveDecision, "RemoveDecision");

 _LIT(KOperationUpdateDecisionAllow, "UpdateDecisionAllow");

 _LIT(KOperationUpdateDecisionDeny, "UpdateDecisionDeny");

 _LIT(KOperationCancelUpdate, "CancelUpdate");

 _LIT(KOperationDeleteDatabase, "DeleteDatabase");

 _LIT(KOperationDecisionCount, "DecisionCount");

 CUpsDbRequest* CUpsDbRequest::NewL()

 	{

 	CUpsDbRequest* me = new (ELeave) CUpsDbRequest();

 	CleanupStack::PushL(me);

 	me->ConstructL();

 	CleanupStack::Pop(me);

 	return me;	

 	}

 CUpsDbRequest::~CUpsDbRequest()

 	{

 	delete iDecisionFilter;	

 	}

 CUpsDbRequest::CUpsDbRequest() 

 	:iOperation(0), iClientSid(0), iEvaluatorId(0), iServiceId(0), iServerSid(0), iFingerprint(0), 

 	iClientEntity(0), iDescription(0), iDecisionResult(0), iMajorPolicyVersion(0), iRecordId(0), iEvaluatorInfo(0), iExpectedDecisionCount(0)

 	{	

 	} 

 void CUpsDbRequest::ConstructL()

 	{

 	iDecisionFilter = CDecisionFilter::NewL();	

 	}

 CUPSDbManagementStep::CUPSDbManagementStep()

 	{

 	SetTestStepName(KUPSDbManagementStep);

 	}

 CUPSDbManagementStep::~CUPSDbManagementStep()

 	{

 	iUpsManager.CancelAndCloseView();

 	iUpsManager.Close();	

 	iArraySersToRequest.ResetAndDestroy();

 	INFO_PRINTF2(_L("END CELLS: %d"), User::CountAllocCells());  

 	__UHEAP_MARKEND;

 	}

 TVerdict CUPSDbManagementStep::doTestStepPreambleL()

 /**

  * @return - TVerdict code

  * Override of base class virtual

  */

 	{

  	__UHEAP_MARK;

  	INFO_PRINTF2(_L("START CELLS: %d"), User::CountAllocCells());

  	// reads client name and SID

 	TParse clientFullName;

 	RThread client;

 	clientFullName.Set(client.FullName(),NULL, NULL);

 	iTEFServerName=clientFullName.Name();

 	iExpectedClientSid = client.SecureId() ;

 	client.Close();

     // Read how many times the test step needs to be repeated.

     TName fStepRepeat(_L("StepRepeat"));

     TInt  repeats;

     if(GetIntFromConfig(ConfigSection(),fStepRepeat,repeats))

     	{

     	iStepRepeat=repeats;

     	}

 	else

 		{	

 		iStepRepeat=1;		

 		}

     // Read values for test sequence from INI file. (ARRAY of values)

 	TInt index=0;

 	TName fOperation;

 	fOperation.Format(_L("Operation_%d"), index);

 	TName fClientSid;

 	fClientSid.Format(_L("ClientSid_%d"),index);

 	TName fEvaluatorId;

 	fEvaluatorId.Format(_L("EvaluatorId_%d"),index);

 	TName fServiceId;

 	fServiceId.Format(_L("ServiceId_%d"),index);

 	TName fServerSid;

 	fServerSid.Format(_L("ServerSid_%d"),index);

 	TName fFingerprint;

 	fFingerprint.Format(_L("Fingerprint_%d"),index);

 	TName fClientEntity;

 	fClientEntity.Format(_L("ClientEntity_%d"),index);

 	TName fDescription;

 	fDescription.Format(_L("Description_%d"),index);

 	TName fDecisionResult;

 	fDecisionResult.Format(_L("DecisionResult_%d"),index);

 	TName fMajorPolicyVersion;

 	fMajorPolicyVersion.Format(_L("MajorPolicyVersion_%d"),index);

 	TName fRecordId;

 	fRecordId.Format(_L("RecordId_%d"),index);

 	TName fEvaluatorInfo;

 	fEvaluatorInfo.Format(_L("EvaluatorInfo_%d"),index);

 	TName fExpectedDecisionCount;

 	fExpectedDecisionCount.Format(_L("ExpectedDecisionCount_%d"),index);

 	TPtrC 	operation;

 	TInt	clientSid;

 	TInt	evaluatorId;

 	TInt	serviceId;

 	TInt	serverSid;

 	TPtrC	fingerprint;

 	TPtrC	clientEntity;

 	TPtrC	description;

 	TPtrC	decisionResult;

 	TInt	majorPolicyVersion;

 	TInt 	recordId;

 	TInt	evaluatorInfo;

 	TInt 	expectedDecisionCount;

 	while (GetStringFromConfig(ConfigSection(),fOperation,operation))

 		{

 		// Create an instance of a new request

 		CUpsDbRequest* newRequest = CUpsDbRequest::NewL();

 		CleanupStack::PushL(newRequest);

 		// Set the operation to be performed

 	    newRequest->iOperation = operation;

 	    if(GetHexFromConfig(ConfigSection(),fClientSid,clientSid))

 		    {

 		    newRequest->iClientSid = clientSid;

 		  	newRequest->iDecisionFilter->SetClientSid(TSecureId(clientSid),EEqual);

 		    }

 		if(GetHexFromConfig(ConfigSection(),fEvaluatorId,evaluatorId))

 			{

 			newRequest->iEvaluatorId = evaluatorId;	

 			newRequest->iDecisionFilter->SetEvaluatorId(TUid::Uid(evaluatorId),EEqual);

 			}

 		if(GetHexFromConfig(ConfigSection(),fServiceId,serviceId))

 			{

 			newRequest->iServiceId = serviceId;	

 			newRequest->iDecisionFilter->SetServiceId(TUid::Uid(serviceId),EEqual);

 			}

 		if(GetHexFromConfig(ConfigSection(),fServerSid,serverSid))

 			{

 			newRequest->iServerSid = serverSid;	

 			newRequest->iDecisionFilter->SetServerSid(TSecureId(serverSid),EEqual);

 			}

 		if(GetStringFromConfig(ConfigSection(),fFingerprint,fingerprint))

 			{

 			HBufC8* fingerprintConverter = HBufC8::NewLC(fingerprint.Length());

 			TPtr8 fingerprintPtr = fingerprintConverter->Des();

 			fingerprintPtr.Copy(fingerprint); 	

 	       	newRequest->iFingerprint = fingerprintPtr;

 	       	HBufC8* binaryFingerprint = StringToBinaryLC(fingerprintPtr);

 	      	newRequest->iDecisionFilter->SetFingerprintL(*binaryFingerprint,EEqual);	

 	       	CleanupStack::PopAndDestroy(binaryFingerprint);

 	       	CleanupStack::PopAndDestroy(fingerprintConverter); 

 			}

 		if(GetStringFromConfig(ConfigSection(),fClientEntity,clientEntity))

 			{

 			HBufC8* clientEntityConverter = HBufC8::NewLC(clientEntity.Length());

 			TPtr8 clientEntityPtr = clientEntityConverter->Des();

 			clientEntityPtr.Copy(clientEntity); 	

 	       	newRequest->iClientEntity = clientEntityPtr;

 	       	newRequest->iDecisionFilter->SetClientEntityL(clientEntityPtr,EEqual);		

 	       	CleanupStack::PopAndDestroy(clientEntityConverter); 

 			}

 		if(GetStringFromConfig(ConfigSection(),fDescription,description))

 			{

 		    newRequest->iDescription = description;

 			}

 		if(GetStringFromConfig(ConfigSection(),fDecisionResult,decisionResult))

 			{

 			if(decisionResult.CompareF(_L("Yes"))==0 || decisionResult.CompareF(_L("No"))==0 || decisionResult.CompareF(_L(""))==0 )

 				{

 				newRequest->iDecisionResult = decisionResult;	

 				}

 			else 

 				{

 				ERR_PRINTF3(_L("%S: Unexpected Decision Result - %S"),&iTEFServerName, &decisionResult);

 				}

 			}

 		if(GetIntFromConfig(ConfigSection(),fMajorPolicyVersion,majorPolicyVersion)) 

 			{

 			newRequest->iMajorPolicyVersion = majorPolicyVersion;

 			newRequest->iDecisionFilter->SetMajorPolicyVersion(majorPolicyVersion,EEqual);		

 			}

 		if(GetIntFromConfig(ConfigSection(),fRecordId,recordId))

 			{

 			newRequest->iRecordId = recordId;

 			newRequest->iDecisionFilter->SetRecordId(recordId,EEqual);		

 			}

 		if(GetIntFromConfig(ConfigSection(),fEvaluatorInfo,evaluatorInfo))

 			{

 			newRequest->iEvaluatorInfo = evaluatorInfo;		

 			}

 		if(GetIntFromConfig(ConfigSection(),fExpectedDecisionCount,expectedDecisionCount))

 			{

 			newRequest->iExpectedDecisionCount = expectedDecisionCount;		

 			}

 	    // Add the new service to be requested to array.

 	    iArraySersToRequest.AppendL(newRequest);

 	    CleanupStack::Pop(newRequest);

 	    index++;

 	    fOperation.Format(_L("Operation_%d"), index);

 	    fClientSid.Format(_L("ClientSid_%d"),index);

 		fEvaluatorId.Format(_L("EvaluatorId_%d"),index);

 		fServiceId.Format(_L("ServiceId_%d"),index);

 		fServerSid.Format(_L("ServerSid_%d"),index);

 		fFingerprint.Format(_L("Fingerprint_%d"),index);

 		fClientEntity.Format(_L("ClientEntity_%d"),index);

 		fDescription.Format(_L("Description_%d"),index);

 		fDecisionResult.Format(_L("DecisionResult_%d"),index);

 		fMajorPolicyVersion.Format(_L("MajorPolicyVersion_%d"),index);

 		fRecordId.Format(_L("RecordId_%d"),index);

 		fEvaluatorInfo.Format(_L("EvaluatorInfo_%d"),index);

 		fExpectedDecisionCount.Format(_L("ExpectedDecisionCount_%d"),index);

 		}

 	SetTestStepResult(EPass);

 	return TestStepResult();

 	}

 TVerdict CUPSDbManagementStep::doTestStepL()

 	{

 	// Connect to the UPS Manager

 	User::LeaveIfError(iUpsManager.Connect());

 	// loop to request for different test services.

 	SetTestStepResult(EPass);

 	TInt numServicesToRequest = iArraySersToRequest.Count();

 	if(numServicesToRequest > 0) 

 		{

 		// repeats the sequence of test services request as many times as specified in iStepRepeat

 		for(TInt repeatTimes = 0;repeatTimes<iStepRepeat;++repeatTimes)

 			{

 			INFO_PRINTF3(_L("%S: Repeat number: %d"),&iTEFServerName,repeatTimes);

 			for(TInt index=0;index < numServicesToRequest; ++index )

 				{

  			    INFO_PRINTF4(_L("%S: Database Request: %d, Command: %S"),&iTEFServerName, index, &iArraySersToRequest[index]->iOperation);	

  			    TRequestStatus requestStatus;	    

  			    TPtrC op(iArraySersToRequest[index]->iOperation);

  			    // *** CREATE VIEW ***

  			    if (!op.CompareF(KOperationCreateView))

  			    	{

  					// Create view using the Decision Filter for the Request

  			    	iUpsManager.CreateView(*iArraySersToRequest[index]->iDecisionFilter,requestStatus);

  			    	User::WaitForRequest(requestStatus);

  			    	if(requestStatus != KErrNone)

 	 			    	{

 	 			    	SetTestStepResult(EFail);

 	 			    	ERR_PRINTF3(_L("%S: Create View Failure - %d"),&iTEFServerName,requestStatus.Int());	

 	 			    	User::Leave(requestStatus.Int());	

 	 			    	}

  			    	}

  			    // *** CANCEL CLOSE VIEW ***

  			    else if (!op.CompareF(KOperationCancelCloseView))

  			    	{

  			    	iUpsManager.CancelAndCloseView();

  			    	INFO_PRINTF2(_L("%S: UPS DB Management - Current View Cancelled and Closed"),&iTEFServerName);

  			    	}

  			    // *** NEXT MATCH ***	

  			    else if (!op.CompareF(KOperationNextMatch))

  			    	{

  			    	CDecisionRecord* record = NULL;

  			    	// Retrieve the Next Decision according to the Current View

  			    	record = iUpsManager.NextMatchL();

  			    	CleanupStack::PushL(record);

  			    	// If a record is found, check that the record matches any data specified in the INI

  			    	if(record != NULL)

 	 			    	{

 	 			    	if(CheckDecisionRecordL(index,*record) == EFalse)

 		 			    	{

 		 			    	iUpsManager.CancelAndCloseView();

 		 			    	ERR_PRINTF2(_L("%S: Incorrect Results"),&iTEFServerName);

 							User::Leave(KErrGeneral);	

 		 			    	}	 			    		

 	 			    	}

 	 			    else

 	 			    	{

 	 			    	iUpsManager.CancelAndCloseView();

 	 			    	SetTestStepResult(EFail);

 		    			ERR_PRINTF2(_L("%S: NextMatchL - No Decision Retrieved"),&iTEFServerName);

 						User::Leave(KErrEof);	

 	 			    	}

 	 			    CleanupStack::PopAndDestroy(record);

  			    	}

  			    // *** REMOVE DECISION ***

  			    else if (!op.CompareF(KOperationRemoveDecision))

  			    	{

  			    	// Remove decisions from the database based on the contents of the Decision Filter

  			    	TRAPD(err, iUpsManager.RemoveDecisionsL(*iArraySersToRequest[index]->iDecisionFilter));

  			    	if(err == KErrNone)

 	 			    	{

 	 			    	INFO_PRINTF2(_L("%S: Remove Decision - Decision(s) Successfully Removed"),&iTEFServerName);

 	 			    	}

 	 			    else

 	 			    	{

 	 			    	SetTestStepResult(EFail);

 	 			    	ERR_PRINTF3(_L("%S: ** Error ** Remove Decision Failure - %d"),&iTEFServerName,err);

 	 			    	User::Leave(err);	

 	 			    	}

  			    	}

  			    // *** UPDATE DECISION ALLOW ***

  			    else if (!op.CompareF(KOperationUpdateDecisionAllow))

  			    	{

  			    	iUpsManager.UpdateDecision(iArraySersToRequest[index]->iRecordId, ETrue, requestStatus);

  			    	User::WaitForRequest(requestStatus);

  			    	if(requestStatus != KErrNone)

 	 			    	{

 	 			    	SetTestStepResult(EFail);

 	 			    	ERR_PRINTF3(_L("%S: Update Decision 'Allow' Failure - %d"),&iTEFServerName,requestStatus.Int());	

 	 			    	User::Leave(requestStatus.Int());	

 	 			    	}

  			    	}

  			    // *** UPDATE DECISION DENY ***

  			    else if (!op.CompareF(KOperationUpdateDecisionDeny))

  			    	{

  			    	iUpsManager.UpdateDecision(iArraySersToRequest[index]->iRecordId, EFalse, requestStatus);

  			    	User::WaitForRequest(requestStatus);

  			    	if(requestStatus != KErrNone)

 	 			    	{

 	 			    	SetTestStepResult(EFail);

 	 			    	ERR_PRINTF3(_L("%S: Update Decision 'Deny' Failure - %d"),&iTEFServerName,requestStatus.Int());	

 	 			    	User::Leave(requestStatus.Int());	

 	 			    	}

  			    	}

  			    // *** CANCEL DECISION UPDATE ***

  			    else if (!op.CompareF(KOperationCancelUpdate))

  			    	{

  			    	iUpsManager.CancelUpdateDecision();

  			    	INFO_PRINTF2(_L("%S: UPS DB Management - Current Decision Update Cancelled"),&iTEFServerName);

  			    	}

  			    // *** DELETE DATABASE ***

  			    else if (!op.CompareF(KOperationDeleteDatabase))

  			    	{

  			    	// Delete the contents of the Decision Database

  			    	TRAPD(err, iUpsManager.DeleteDatabaseL());

  			    	if(err == KErrNone)

 	 			    	{

 	 			    	INFO_PRINTF2(_L("%S: UPS DB Management - Database Deleted"),&iTEFServerName);

 	 			    	}

 	 			    else

 	 			    	{

 	 			    	SetTestStepResult(EFail);

 	 			    	ERR_PRINTF3(_L("%S: ** Error ** Database Deletion Failure - %d"),&iTEFServerName,err);

 	 			    	User::Leave(err);	

 	 			    	}

  			    	}

  			    // *** DECISION COUNT ***

  			    else if (!op.CompareF(KOperationDecisionCount))

  			    	{

  			    	iUpsManager.CancelAndCloseView();

  			    	// Create a new view using the constructed decision filter for the request

  			    	iUpsManager.CreateView(*iArraySersToRequest[index]->iDecisionFilter,requestStatus);

  			    	User::WaitForRequest(requestStatus);

  			    	if(requestStatus.Int() == KErrNone)

 	 			    	{

 	 			    	TInt decisionCount = 0;

 	 			    	CDecisionRecord* record = NULL;

 	 			    	TInt result = KErrNone;

 	 			    	// Whilst records located using the "NextMatchL" method, increment the record count

 						while(result == KErrNone)

 							{

 							TRAP(result, record = iUpsManager.NextMatchL());

 							if(record == NULL)

 								{

 								break;

 								}

 							else

 								{

 								++decisionCount;	

 								}

 							delete record;

 							record = NULL;

 							}

 						iUpsManager.CancelAndCloseView();

 						if(decisionCount != iArraySersToRequest[index]->iExpectedDecisionCount)

 		    				{

 		    				SetTestStepResult(EFail);

 		    				ERR_PRINTF2(_L("%S: Decision Count - Unexpected Number of Database Decisions"),&iTEFServerName);

 		    				ERR_PRINTF3(_L("%S: Decisions expected: %d"),&iTEFServerName,iArraySersToRequest[index]->iExpectedDecisionCount);

 		    				ERR_PRINTF3(_L("%S: Decisions in Database: %d"),&iTEFServerName,decisionCount);

 							User::Leave(KErrNotFound);

 		    				}

 	 			    	}

 	 			    else

 	 			    	{

 	 			    	SetTestStepResult(EFail);

 	 			    	ERR_PRINTF3(_L("%S: Decision Count - Create View Failure - %d"),&iTEFServerName,requestStatus.Int());	

 	 			    	User::Leave(requestStatus.Int());

 	 			    	}

  			    	}	

  			    else

  			    	{

  			    	SetTestStepResult(EFail);

 		     	    ERR_PRINTF2(_L("%S: Invalid operation"),&iTEFServerName);

 					User::Leave(KErrNotSupported);	 			    	

  			    	}

 				}  // End of second loop

 			}// End of first loop

 		} 

 	else

 		{

 		SetTestStepResult(EFail);

 		ERR_PRINTF2(_L("%S: Problem reading ini file"),&iTEFServerName);

 		User::Leave(KErrGeneral);	

 		}  

 	return TestStepResult();

 	}  // End of function

 TVerdict CUPSDbManagementStep::doTestStepPostambleL()

 	{

 	return TestStepResult();

 	}

 TBool CUPSDbManagementStep::CheckDecisionRecordL(TInt aIndex, const CDecisionRecord& aRecord)

 /**

  * Checks the expected record values against those stored within CDecisionRecord retrieved from the database

  *

  * @param  - TInt aIndex: Database request index used to access the required instance of CUpsDbRequest held 

  * 			 within the request array

  * @param  - const CDecisionRecord& aRecord: Decision Record retrieved from the database

  * @return - TBool: Boolean to determine the result of the value checks (ETrue = Pass, EFalse = Fail)

  **/

 	{

 	TBool checkPassed = ETrue;

 	if(iArraySersToRequest[aIndex]->iClientSid != aRecord.iClientSid)

 		{

 		ERR_PRINTF2(_L("%S: 'Client SID' value mismatch"),&iTEFServerName);

 		checkPassed = EFalse;	

 		}

 	if(iArraySersToRequest[aIndex]->iEvaluatorId != aRecord.iEvaluatorId.iUid)

 		{

 		ERR_PRINTF2(_L("%S: 'Evaluator ID' value mismatch"),&iTEFServerName);

 		checkPassed = EFalse;	

 		}	

 	if(iArraySersToRequest[aIndex]->iServiceId != aRecord.iServiceId.iUid)

 		{

 		ERR_PRINTF2(_L("%S: 'Service ID' value mismatch"),&iTEFServerName);

 		checkPassed = EFalse;	

 		}	

 	if(iArraySersToRequest[aIndex]->iServerSid != aRecord.iServerSid)

 		{

 		ERR_PRINTF2(_L("%S: 'Server SID' value mismatch"),&iTEFServerName);

 		checkPassed = EFalse;	

 		}	

 	HBufC8* recordFingerprint = StringToHexLC(aRecord.iFingerprint);

 	if(iArraySersToRequest[aIndex]->iFingerprint != *recordFingerprint)

 		{

 		HBufC* expectedFingerprint = HBufC::NewLC(iArraySersToRequest[aIndex]->iFingerprint.Length());

 		HBufC* receivedFingerprint = HBufC::NewLC(recordFingerprint->Length());

 		expectedFingerprint->Des().Copy(iArraySersToRequest[aIndex]->iFingerprint);

 		receivedFingerprint->Des().Copy(*recordFingerprint);

 		ERR_PRINTF2(_L("%S: 'Fingerprint' value mismatch."),&iTEFServerName);

 		ERR_PRINTF3(_L("%S: Fingerprint expected: %S"),&iTEFServerName,expectedFingerprint);

     	ERR_PRINTF3(_L("%S: Fingerprint received: %S"),&iTEFServerName,receivedFingerprint);

 		CleanupStack::PopAndDestroy(receivedFingerprint);

 		CleanupStack::PopAndDestroy(expectedFingerprint);

 		checkPassed = EFalse;	

 		}

 	CleanupStack::PopAndDestroy(recordFingerprint);	

 	if(iArraySersToRequest[aIndex]->iClientEntity != aRecord.iClientEntity)

 		{

 		HBufC* expectedClientEntity = HBufC::NewLC(iArraySersToRequest[aIndex]->iClientEntity.Length());

 		HBufC* receivedClientEntity = HBufC::NewLC(aRecord.iClientEntity.Length());

 		expectedClientEntity->Des().Copy(iArraySersToRequest[aIndex]->iClientEntity);

 		receivedClientEntity->Des().Copy(aRecord.iClientEntity);

 		ERR_PRINTF2(_L("%S: 'Client Entity' value mismatch."),&iTEFServerName);

 		CleanupStack::PopAndDestroy(receivedClientEntity);

 		CleanupStack::PopAndDestroy(expectedClientEntity);

 		checkPassed = EFalse;

 		}	

 	if(iArraySersToRequest[aIndex]->iDescription.CompareF(aRecord.iDescription) != 0)

 		{

 		TPtrC retrievedDescription(aRecord.iDescription);

 		ERR_PRINTF2(_L("%S: 'Description' value mismatch."),&iTEFServerName);

     	checkPassed = EFalse;

 		}

 	TInt expectedDecisionResult = 0;

 	if(iArraySersToRequest[aIndex]->iDecisionResult.CompareF(_L("Yes")) == 0)

 		{

 		expectedDecisionResult = 1;	

 		}

 	if(expectedDecisionResult != aRecord.iResult)

 		{

 		ERR_PRINTF2(_L("%S: 'Decision Result' value mismatch."),&iTEFServerName);

 		checkPassed = EFalse;

 		}

 	if(iArraySersToRequest[aIndex]->iMajorPolicyVersion != aRecord.iMajorPolicyVersion)

 		{

 		ERR_PRINTF2(_L("%S: 'Major Policy Version' value mismatch."),&iTEFServerName);

 		checkPassed = EFalse;	

 		}	

 	if(iArraySersToRequest[aIndex]->iEvaluatorInfo != aRecord.iEvaluatorInfo)

 		{

 		ERR_PRINTF2(_L("%S: 'Evaluator Info' value mismatch."),&iTEFServerName);

 		checkPassed = EFalse;	

 		}	

 	if(iArraySersToRequest[aIndex]->iRecordId != aRecord.iRecordId)

 		{

 		ERR_PRINTF2(_L("%S: 'Record ID' value mismatch."),&iTEFServerName);

 		checkPassed = EFalse;	

 		}	

 	return checkPassed;

 	}

 HBufC8* CUPSDbManagementStep::StringToHexLC(const TDes8 &aString)

 /**

  * Function to convert the contents of a TDes8 into a Hexadecimal format

  *

  * @param  - cosnt TDes8 aString: String to convert into Hexadecimal

  * @return - HBufC8*: Converted Hexadecial string representation

  **/

 	{

 	HBufC8* parsedString = HBufC8::NewLC(aString.Length()*2);

 	TBuf8<2> pair;

 	_LIT8(KFormatHex,"%02x"); 

 	TPtr8 ptr(parsedString->Des());

    	for(TInt i = 0; i<aString.Length() ; i++)

     	{

 		TInt num  = (aString)[i];

     	pair.Format(KFormatHex,num);

     	ptr.Append(pair);

     	}

 	return parsedString;

 	}

 HBufC8* CUPSDbManagementStep::StringToBinaryLC(const TDes8 &aString)

 /**

  * Function to convert the contents of a TDes8 into a Binary format

  *

  * @param  - cosnt TDes8 aString: String to convert into Hexadecimal

  * @return - HBufC8*: Converted Binary string representation

  **/

 	{

 	HBufC8* parsedString = HBufC8::NewLC(aString.Length()/2);

 	TBuf8<1> binChar;

 	_LIT8(KFormatBinary,"%c"); 

 	TPtr8 ptr(parsedString->Des());

    	for(TInt i = 0; i<aString.Length()/2 ; i++)

     	{

     	TPtrC8 tempPtr(aString.Mid(i*2,2));

     	TLex8 lex(tempPtr);

     	TUint val=0;

     	lex.Val(val, EHex);

     	binChar.Format(KFormatBinary,val);

     	ptr.Append(binChar);

     	}

 	return parsedString;

 	}