// Copyright (c) 2008-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 The TEFUnit test suite for SatControl in the Common TSY.

*/

#include <cstktsy/bertlv_defs.h>

#include <etel.h>

#include <etelmm.h>

#include <etelsat.h>

#include <et_clsvr.h>

#include <ctsy/serviceapi/gsmerror.h>

#include <ctsy/mmtsy_names.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include <ctsy/ltsy/sat_defs.h>

#include <cstktsy/ttlv.h>

#include "cctsysatfu.h"

#include <ctsy/ltsy/mltsydispatchsatinterface.h>

#include <ctsy/ltsy/mltsydispatchsmsinterface.h> //for KLtsyDispatchSmsSendSatSmsApiId

#include <ctsy/ltsy/mltsydispatchphoneinterface.h> //for KLtsyDispatchPhoneGetPhoneIdApiId

#include <ctsy/ltsy/mltsydispatchphonebookinterface.h> //for KLtsyDispatchPhonebookSmsStoreWriteEntryApiId

#include "mockltsyindicatorids.h"

#include "testconstants.h"

#include <test/tmockltsydata.h>

const TDesC8& KGeneralResultAddInfo = KNullDesC8;

const TInt KShiftBitsToGetMSB = 8;

const TInt KShiftBitsToGetLSB = 0;

//const TUint8 KAddrMaxLength 	= 255;

//const TUint8 KFilePathLength	= 8;

CTestSuite* CCTsySatFU::CreateSuiteL(const TDesC& aName)

	{

	SUB_SUITE;

	//add use-case tests

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUseCase0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUseCase0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUseCase0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUseCase0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUseCase0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUseCase0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUseCase0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUseCase0008L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUseCase0009L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUseCase0010L);

	//add other unit tests

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0007L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0008L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0009L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0010L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0011L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0012L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0013L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0014L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0015L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0016L);

	ADD_TEST_STEP_ISO_CPP(CCTsySatFU, TestUnit0017L);

	END_SUITE;

	}

//

// Use-case tests

//

/**

@SYMTestCaseID BA-CTSYD-DIS-SAT-UC0001

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test CTSY/STK initialisation

@SYMTestPriority High

@SYMTestActions Invokes RSat::Open()

@SYMTestExpectedResults Pass

@SYMTestType CT

 */

void CCTsySatFU::TestUseCase0001L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	//OpenSatL contains the test code that drives the initialisation of SAT.

	OpenSatL(KSmsMoControlEnabled | KSmsPpDownloadEnabled | KUssdEnabled); 

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(this);

	}

/**

@SYMTestCaseID BA-CTSYD-DIS-SAT-UC0002

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for a representative Proactive Command session involving user interaction

@SYMTestPriority High

@SYMTestActions Invokes RSat::NotifySetUpMenuPCmd, RSat::NotifyDisplayTextPCmd, RSat::NotifySelectItemPCmd,RSat::TerminalRsp, RSat::MenuSelection

@SYMTestExpectedResults Pass

@SYMTestType CT

 */

void CCTsySatFU::TestUseCase0002L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	OpenSatL();

	RBuf8 data;

	CleanupClosePushL(data);

	TRequestStatus reqStatus;

	const TUint8 KPCmdNumber1 = 123;

	const TUint8 KPCmdNumber2 = 124;

	const TUint8 KPCmdNumber3 = 125;

	TUint8 pcmdCode = KSetUpMenu;

	TMockLtsyData1<TUint8> expLtsyData(pcmdCode);

	expLtsyData.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,data);

	TTlv tlv;

	tlv.Begin(KBerTlvProactiveSimCommandTag);

	tlv.AddTag(KTlvCommandDetailsTag);

	tlv.AddByte(KPCmdNumber1);//ETLV_CommandNumber

	tlv.AddByte(KSetUpMenu); //ETLV_TypeOfCommand

	tlv.AddByte(KSelectionUsingSoftKey); //ETLV_CommandQualifier

	tlv.AddTag(KTlvDeviceIdentityTag); 

	tlv.AddByte(KSim); //ETLV_SourceDeviceIdentity

	tlv.AddByte(KDisplay); //ETLV_DestinationDeviceIdentity

	tlv.AddTag(KTlvAlphaIdentifierTag);

	_LIT8(KSetupMenuTest8,"Menu AlphaIdent");

	_LIT16(KSetupMenuTest16,"Menu AlphaIdent");

	tlv.AddData(KSetupMenuTest8);//ETLV_AlphaIdentifier

	const TUint8 KItemIdentifier1 = 77;

	tlv.AddTag(KTlvItemTag);

	tlv.AddByte(KItemIdentifier1); //item identifier

	tlv.AddData(_L8("Item AlphaIdent1"));

	const TUint8 KItemIdentifier2 = 78;

	tlv.AddTag(KTlvItemTag);

	tlv.AddByte(KItemIdentifier2); //item identifier

	tlv.AddData(_L8("Item AlphaIdent2"));

	TDesC8* tlvDscPtr = &const_cast<TDesC8&>(tlv.End());

	TMockLtsyData1<TDesC8*> tlvDscPack(tlvDscPtr);

	data.Close();

	tlvDscPack.SerialiseL(data);

	iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data);

	RSat::TSetUpMenuV2 setupMenu;

	RSat::TSetUpMenuV2Pckg setpPck(setupMenu);

	iSat.NotifySetUpMenuPCmd(reqStatus, setpPck);

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(KErrNone, reqStatus.Int());

	ASSERT_EQUALS(KPCmdNumber1, setupMenu.PCmdNumber());

	ASSERT_EQUALS(RSat::EAlphaIdProvided, setupMenu.iAlphaId.iStatus);

	ASSERT_EQUALS(0, setupMenu.iAlphaId.iAlphaId.Compare(KSetupMenuTest16));

	AssertMockLtsyStatusL();

	data.Close();

	//generate the terminal response

	RSat::TSetUpMenuRspV1 setupMenuResp;

	RSat::TSetUpMenuRspV1Pckg setupMenuRespPckg(setupMenuResp);

	setupMenuResp.iGeneralResult = RSat::KSuccess;

	setupMenuResp.iInfoType = RSat::KNoAdditionalInfo;

	setupMenuResp.SetPCmdNumber(KPCmdNumber1);

	GenerateAndWaitForTermRspL(KPCmdNumber1,KSetUpMenu,KSelectionUsingSoftKey,RSat::ESetUpMenu, RSat::KSuccess, setupMenuRespPckg, KErrNone);

	//simulate the user requesting help on a menu option.

	TTlv menuSelectionEnvelope;

	menuSelectionEnvelope.Begin( KBerTlvMenuSelectionTag );

	menuSelectionEnvelope.AddTag( KTlvDeviceIdentityTag );

	menuSelectionEnvelope.AddByte( KKeypad );

	menuSelectionEnvelope.AddByte( KSim );

	menuSelectionEnvelope.AddTag( KTlvItemIdentifierTag );

	menuSelectionEnvelope.AddByte( KItemIdentifier1 );

	menuSelectionEnvelope.AddTag( KTlvHelpRequestTag );

	TDesC8* menuSelectionEnvelopePtr = &const_cast<TDesC8&>(menuSelectionEnvelope.End());

	TMockLtsyData1<TDesC8*> menuSelDescPck(menuSelectionEnvelopePtr);

	data.Close();

	menuSelDescPck.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchSatMenuSelectionEnvelope::KLtsyDispatchSatMenuSelectionEnvelopeApiId, data);

	TRequestStatus reqStatusNotifyTerminated;

	iMockLTSY.NotifyTerminated(reqStatusNotifyTerminated); 

	RSat::TMenuSelectionV1 menuSelection;

	RSat::TMenuSelectionV1Pckg menuSelectionPckg(menuSelection);

	menuSelection.iItemId = KItemIdentifier1;

	menuSelection.iHelp = RSat::EHelpRequested;

	iSat.MenuSelection(reqStatus, menuSelectionPckg);

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(reqStatus.Int(),KErrNone);

	User::WaitForRequest(reqStatusNotifyTerminated);

	ASSERT_EQUALS(reqStatusNotifyTerminated.Int(),KErrNone);

	//response from ucc to the help request

	pcmdCode = KDisplayText;

	data.Close();

	expLtsyData.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,data);

	RSat::TDisplayTextV2 displayText;

	RSat::TDisplayTextV2Pckg displayTextPckg(displayText);

	iSat.NotifyDisplayTextPCmd(reqStatus, displayTextPckg);

	TTlv displayTextTlv;

	displayTextTlv.Begin(KBerTlvProactiveSimCommandTag);

	displayTextTlv.AddTag(KTlvCommandDetailsTag);

	displayTextTlv.AddByte(KPCmdNumber2);//ETLV_CommandNumber

	displayTextTlv.AddByte(KDisplayText); //ETLV_TypeOfCommand

	TUint8 dispTextMask = KMessageClearMask & ~KPriorityMask; //user must acknowledge the message. normal priority.

	displayTextTlv.AddByte(dispTextMask); //ETLV_CommandQualifier

	displayTextTlv.AddTag(KTlvDeviceIdentityTag); 

	displayTextTlv.AddByte(KSim); //ETLV_SourceDeviceIdentity

	displayTextTlv.AddByte(KDisplay); //ETLV_DestinationDeviceIdentity

	displayTextTlv.AddTag(KTlvTextStringTag);

	displayTextTlv.AddByte(K8BitDCS); //ETLV_DataCodingScheme

	_LIT8(KTstHelpInfo8, "HELP INFORMATION ABOUT MENU COMMAND");//defining this string twice because its returned 

	_LIT(KTstHelpInfo16, "HELP INFORMATION ABOUT MENU COMMAND");//via NotifyDisplayTextPcmd completion as 16 bit desc

	displayTextTlv.AddData(KTstHelpInfo8);

	displayTextTlv.AddTag(KTlvImmediateResponseTag);

	TDesC8* displayTextDscPtr = &const_cast<TDesC8&>(displayTextTlv.End());

	TMockLtsyData1<TDesC8*> displayTextPack(displayTextDscPtr);

	data.Close();

	displayTextPack.SerialiseL(data);

	iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data);

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(reqStatus.Int(),KErrNone);

	ASSERT_EQUALS(displayText.PCmdNumber(),KPCmdNumber2);

	ASSERT_TRUE(displayText.iText == KTstHelpInfo16);

	AssertMockLtsyStatusL();

	//generate the terminal response

	RSat::TDisplayTextRspV1 displayTextRsp;

	RSat::TDisplayTextRspV1Pckg displayTextRspPckg(displayTextRsp);

	displayTextRsp.iGeneralResult = RSat::KSuccess;

	displayTextRsp.iInfoType = RSat::KNoAdditionalInfo;

	displayTextRsp.SetPCmdNumber(KPCmdNumber2);

	GenerateAndWaitForTermRspL(KPCmdNumber2,KDisplayText,dispTextMask,RSat::EDisplayText, RSat::KSuccess, displayTextRspPckg, KErrNone);

	//now let the user select a top level item which will open a submenu.

	menuSelectionEnvelope.Begin( KBerTlvMenuSelectionTag );

	menuSelectionEnvelope.AddTag( KTlvDeviceIdentityTag );

	menuSelectionEnvelope.AddByte( KKeypad );

	menuSelectionEnvelope.AddByte( KSim );

	menuSelectionEnvelope.AddTag( KTlvItemIdentifierTag );

	menuSelectionEnvelope.AddByte( KItemIdentifier1 );

	menuSelectionEnvelopePtr = &const_cast<TDesC8&>(menuSelectionEnvelope.End());

	data.Close();

	menuSelDescPck.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchSatMenuSelectionEnvelope::KLtsyDispatchSatMenuSelectionEnvelopeApiId, data);

	menuSelection.iItemId = KItemIdentifier1;

	menuSelection.iHelp = RSat::EHelpNotRequested;

	iMockLTSY.NotifyTerminated(reqStatusNotifyTerminated); 

	iSat.MenuSelection(reqStatus, menuSelectionPckg);

    User::WaitForRequest(reqStatus);

    ASSERT_EQUALS(reqStatus.Int(),KErrNone);

	User::WaitForRequest(reqStatusNotifyTerminated);

	ASSERT_EQUALS(reqStatusNotifyTerminated.Int(),KErrNone);

    //now provide the sub menu

	pcmdCode = KSelectItem;

	data.Close();

	expLtsyData.SerialiseL(data);

	iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,data);

	tlv.Begin(KBerTlvProactiveSimCommandTag);

	tlv.AddTag(KTlvCommandDetailsTag);

	tlv.AddByte(KPCmdNumber3);//ETLV_CommandNumber

	tlv.AddByte(KSelectItem); //ETLV_TypeOfCommand

	tlv.AddByte(KSelectionUsingSoftKey); //ETLV_CommandQualifier

	tlv.AddTag(KTlvDeviceIdentityTag); 

	tlv.AddByte(KSim); //ETLV_SourceDeviceIdentity

	tlv.AddByte(KDisplay); //ETLV_DestinationDeviceIdentity

	tlv.AddTag(KTlvAlphaIdentifierTag);

	_LIT8(KSelectItemTestMenu8,"select item Menu AlphaIdent");

	_LIT16(KSelectItemTestMenu16,"select item Menu AlphaIdent");

	tlv.AddData(KSelectItemTestMenu8);//ETLV_AlphaIdentifier

	const TUint8 KSubMenuItemIdentifier1 = 90;

	tlv.AddTag(KTlvItemTag);

	tlv.AddByte(KSubMenuItemIdentifier1); //item identifier

	tlv.AddData(_L8("select Item AlphaIdent1"));

	const TUint8 KSumMenuItemIdentifier2 = 91;

	tlv.AddTag(KTlvItemTag);

	tlv.AddByte(KSumMenuItemIdentifier2); //item identifier

	tlv.AddData(_L8("select Item AlphaIdent2"));

	tlvDscPtr = &const_cast<TDesC8&>(tlv.End());

	data.Close();

	tlvDscPack.SerialiseL(data);

	iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data);

	RSat::TSelectItemV5 selectItem;

	RSat::TSelectItemV5Pckg SelectItemPck(selectItem);

	iSat.NotifySelectItemPCmd(reqStatus, SelectItemPck);

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(reqStatus.Int(),KErrNone);

	ASSERT_EQUALS(selectItem.PCmdNumber(),KPCmdNumber3);

	ASSERT_EQUALS(selectItem.iAlphaId.iStatus,RSat::EAlphaIdProvided);

	ASSERT_TRUE(selectItem.iAlphaId.iAlphaId == KSelectItemTestMenu16);

	//generate the terminal response

	RSat::TSelectItemRspV1 selectItemRsp;

	RSat::TSelectItemRspV1Pckg selectItemRspPckg(selectItemRsp);

	selectItemRsp.iGeneralResult = RSat::KSuccess;

	selectItemRsp.iInfoType = RSat::KItemIdentifier;

	selectItemRsp.iAdditionalInfo.Append(KSubMenuItemIdentifier1);

	selectItemRsp.SetPCmdNumber(KPCmdNumber3);

	TTlv tlvAddInfo;

	tlvAddInfo.AddTag(KTlvItemIdentifierTag);

	tlvAddInfo.AddByte(KSubMenuItemIdentifier1);

	TPtrC8 addInfo = tlvAddInfo.GetDataWithoutTopLevelTag();

	GenerateAndWaitForTermRspL(	KPCmdNumber3,

								KSelectItem,

								KSelectionUsingSoftKey,

								RSat::ESelectItem,selectItemRsp.iGeneralResult,

								KGeneralResultAddInfo,

								selectItemRspPckg,

								addInfo,

								KErrNone);

	data.Close();

	AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(2, this); // data, this

	}	

/**

@SYMTestCaseID BA-CTSYD-DIS-SAT-UC0003

@SYMComponent telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for Getting and Icon Ef(Img) Record, Icon instance and CLUT

@SYMTestPriority High

@SYMTestActions Invokes RSat::GetIcon , RSat::GetImageInstance, Rsat::GetClut

@SYMTestExpectedResults Pass

@SYMTestType CT

 */

void CCTsySatFU::TestUseCase0003L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	OpenSatL();

	RBuf8 getData;

	CleanupClosePushL(getData);

	RBuf8 retData;

	CleanupClosePushL(retData);

	TRequestStatus reqStatus;

	/******************************************Get Icon*******************************************************/

	//Test to get a given Icons EF(Img) record

	//re-create the file path

    TBuf8<KFilePathLength> simFilePath(KFilePathLength);

    simFilePath[0] = 0x3F; //MF High byte

    simFilePath[1] = 0x00; //MF Low byte

    simFilePath[2] = 0x7F; //DF(Telecom) High byte

    simFilePath[3] = 0x10; //DF(Telecom) Low byte

    simFilePath[4] = 0x5F; //DF(Graphics) High byte

    simFilePath[5] = 0x50; //DF(Graphics) Low byte

    simFilePath[6] = 0x4F; //EF(Img) High byte

    simFilePath[7] = 0x20; //EF(Img) Low byte

    //a EF(Img) record to get

    const TUint8 KRecordNumber = 5;

    //create the down expect data

    TUint8 recordNumber = KRecordNumber;

    TDesC8* simFilePathPtr = &simFilePath;

    TMockLtsyData2<TUint8,TDesC8*> getIconData(recordNumber,simFilePathPtr);

    getIconData.SerialiseL(getData);

    //create a EF(Img) record    

    const TUint KNoImagesLength = 1;

    const TUint KEfImgRecordLength = 9;

    RBuf8 iconEfRecordInstance;

    CleanupClosePushL(iconEfRecordInstance);

    iconEfRecordInstance.CreateMaxL(KEfImgRecordLength);

    const TUint8 KNumberOfImages = 1;

    const TUint16 KInstanceNumber = 1;

    const TUint16 KOffset = 1;

    const TUint16 KLength = 1;

    const TUint8 KWidth  = 40;

    const TUint8 KHeight = 40;

    iconEfRecordInstance[0] = KWidth; 								//image instance width, expressed in raster image points

    iconEfRecordInstance[1] = KHeight; 								//image instance height, expressed in raster image points

    iconEfRecordInstance[2] = RSat::KBasic;							//image coding scheme that has been used in encoding the image instance 11-basic, 21-colour 

    iconEfRecordInstance[3] = KInstanceNumber >> KShiftBitsToGetMSB; 	//high byte of Image Instance File Identifier

    iconEfRecordInstance[4] = KInstanceNumber & 0xFF; 				//low byte of Image Instance File Identifier.

    iconEfRecordInstance[5] = KOffset >> KShiftBitsToGetMSB;				//high byte of offset into Image Instance File

    iconEfRecordInstance[6] = KOffset & 0xFF; 						//low byte of offset into Image Instance File

    iconEfRecordInstance[7] = KLength >> KShiftBitsToGetMSB;				//high byte of  Image Instance Data length

    iconEfRecordInstance[8] = KLength & 0xFF;						//low byte of Image Instance Data length

    RBuf8 iconEfImgData;

    CleanupClosePushL(iconEfImgData);

    iconEfImgData.CreateL(KNoImagesLength + KEfImgRecordLength);

    iconEfImgData.Append(KNumberOfImages);

    iconEfImgData.Append(iconEfRecordInstance);

    //create the up complete data

    TDesC8* iconDataPtr = &iconEfImgData;

    TMockLtsyData1<TDesC8*> retIconData(iconDataPtr);

    retIconData.SerialiseL(retData);

    //queue the MockLTSY expect completes

	iMockLTSY.ExpectL(MLtsyDispatchSatGetIconData::KLtsyDispatchSatGetIconDataApiId,getData);

	iMockLTSY.CompleteL(MLtsyDispatchSatGetIconData::KLtsyDispatchSatGetIconDataApiId, KErrNone, retData);

	// ETel Sat Calls

	RSat::TIcon retrievedIconEfImg;

    RSat::TIconId iconId;

    iconId.iIdentifier = KRecordNumber;

	iSat.GetIcon(reqStatus,iconId.iIdentifier,retrievedIconEfImg); 

	User::WaitForRequest(reqStatus);

	ASSERT_EQUALS(reqStatus.Int(),KErrNone);

	ASSERT_TRUE(iconEfImgData == retrievedIconEfImg);

	AssertMockLtsyStatusL();

	getData.Close();

	retData.Close();

	CleanupStack::PopAndDestroy(&iconEfImgData);

	CleanupStack::PopAndDestroy(&iconEfRecordInstance);

	/*************************************************************************************************/

	/******************************************Get Image Instance*******************************************************/

	// Test to get a given instance of an icons EF(IIDF)

	// The Client should have read the icon EF before reading the image instance.

	// The contents of the icon EF indicate the size of the image instance,

	// the Client should use this information to allocate a buffer size that it requires

	// and pass a reference to is as a TDes8&

    //create the down expect data

	TUint8 imageInstanceNumberInRecord = KNumberOfImages - KInstanceNumber + 1;

	TMockLtsyData2<TUint8,TUint8> getImageInstanceData(recordNumber,imageInstanceNumberInRecord);

	getImageInstanceData.SerialiseL(getData);

    RBuf8 imageInstanceData;

    CleanupClosePushL(imageInstanceData);