--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/telephonyserver/etelsimtoolkit/tetel/Te_EtelSat/TE_EtelSatpcmds1b.cpp	Tue Feb 02 01:41:59 2010 +0200
@@ -0,0 +1,891 @@
+// Copyright (c) 2002-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:
+//
+
+#include "Te_EtelSatTestStepBase.h"
+#include "TE_EtelSatpcmds1b.h"
+#include <utf.h>
+
+CTestSatPCmds1b::CTestSatPCmds1b()
+/** Each test step initialises it's own name
+*/
+	{
+	// store the name of this test case
+	// this is the name that is used by the script file
+	SetTestStepName(_L("TestSatPCmds1b"));
+	}
+
+enum TVerdict CTestSatPCmds1b::doTestStepL()
+	{
+	INFO_PRINTF1(_L("***********************************************"));
+	INFO_PRINTF1(_L("RSat Proactive Commands Functionality suite - 1"));
+	INFO_PRINTF1(_L("***********************************************"));
+
+	TInt ret=phone.Open(iTelServer,DSATTSY_PHONE_NAME);
+	TEST(ret==KErrNone);
+
+	ret=sat.Open(phone);
+    TEST(ret==KErrNone);
+
+	// local variables used throughout the sat tests
+	// Boundary error testing
+
+	// Select Item
+	RSat::TSelectItemV2* selectItem = new (ELeave) RSat::TSelectItemV2;
+	CleanupStack::PushL(selectItem);
+
+	RSat::TSelectItemV2Pckg* selectItemPckg = new (ELeave) RSat::TSelectItemV2Pckg(*selectItem);
+	CleanupStack::PushL(selectItemPckg);
+
+	TEST(selectItem->ExtensionId()== RSat::KSatV2);
+	TEST(selectItem->NumberOfItems()==0);
+	TEST(selectItem->IsRemoveMenu());
+
+	sat.NotifySelectItemPCmd(reqStatus, *selectItemPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	TEST(selectItem->MenuContent()==DSATTSY_ITEMS_ACTIONS_AND_ICONS);
+	TEST(selectItem->NumberOfItems()==0x03);
+	TEST(selectItem->iPreference==DSATTSY_SELECTION_PREFERENCE);
+
+	index=1;
+	TEST(selectItem->GetItem(index++,item,action,icon)==KErrNone);
+
+	TEST(item.iItemId==0x01);
+	TEST(item.iItemString==DSATTSY_ITEM1);
+	TEST(action==0x01);
+	TEST(icon==0x01);
+
+	TEST(selectItem->GetItem(index++,item,action,icon)==KErrNone);
+	TEST(item.iItemId==0x02);
+	TEST(item.iItemString==DSATTSY_ITEM2);
+	TEST(action==0x02);
+	TEST(icon==0x02);
+
+	TEST(selectItem->GetItem(index++,item,action,icon)==KErrNone);
+	TEST(item.iItemId==0x03);
+	TEST(item.iItemString==DSATTSY_ITEM3);
+	TEST(action==0x03);
+	TEST(icon==0x03);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySelectItemPCmd with RSat::TSelectItemV2 passed"),iTestCount++);
+
+	// Select Item Cancel
+	sat.NotifySelectItemPCmd(reqStatus,*selectItemPckg);
+	sat.CancelAsyncRequest(ESatNotifySelectItemPCmd);
+
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrCancel);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySelectItemPCmdCancel with RSat::TSelectItemV2 passed"),iTestCount++);
+
+	// Select Item with RSat::TSelectItemV5
+
+	// Text attribute parameters used for tests
+	RSat::TTextAttribute textAttribute1, textAttribute2, textAttribute3, textAttribute4;
+
+	textAttribute1.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS;
+	const TUint8 textAttributeData[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA;
+	textAttribute1.iTextAttributeData.Append(textAttributeData, DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH);
+
+	textAttribute2.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS2;
+	const TUint8 textAttributeData2[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA2;
+	textAttribute2.iTextAttributeData.Append(textAttributeData2, DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH);
+
+	textAttribute3.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS3;
+	const TUint8 textAttributeData3[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA3;
+	textAttribute3.iTextAttributeData.Append(textAttributeData3, DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH);
+
+	textAttribute4.iStatus = DSATTSY_TEXT_ATTRIBUTE_STATUS4;
+	const TUint8 textAttributeData4[DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH] = DSATTSY_TEXT_ATTRIBUTE_DATA4;
+	textAttribute4.iTextAttributeData.Append(textAttributeData4, DSATTSY_TEXT_ATTRIBUTE_DATA_LENGTH);
+
+	RSat::TSelectItemV5* selectItemV5 = new (ELeave) RSat::TSelectItemV5;
+	CleanupStack::PushL(selectItemV5);
+
+	TEST(selectItemV5->ExtensionId()== RSat::KSatV5);
+	TEST(selectItemV5->NumberOfItems()==0);
+	TEST(selectItemV5->IsRemoveMenu());
+
+	TEST(selectItemV5->iAlphaId.iStatus==RSat::EAlphaIdNotSet);
+	TEST(selectItemV5->iHelp==RSat::EHelpNotSet);
+	TEST(selectItemV5->iDefaultItemId==0);
+	TEST(selectItemV5->iIconId.iQualifier==RSat::EIconQualifierNotSet);
+	TEST(selectItemV5->iIconId.iIdentifier==0);
+	TEST(selectItemV5->iIconListQualifier==RSat::EIconQualifierNotSet);
+	TEST(selectItemV5->iPreference==RSat::ESelectionPreferenceNotSet);
+	TEST(selectItemV5->iTextAttribute.iStatus == RSat::ETextAttributeNotSet);
+
+	RSat::TSelectItemV5Pckg* selectItemV5Pckg = new (ELeave) RSat::TSelectItemV5Pckg(*selectItemV5);
+	CleanupStack::PushL(selectItemV5Pckg);
+
+	sat.NotifySelectItemPCmd(reqStatus, *selectItemV5Pckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	TEST(selectItemV5->MenuContent()==DSATTSY_ITEMS_WITH_TEXT_ATTRIBUTES_ACTIONS_AND_ICONS);
+	TEST(selectItemV5->NumberOfItems()==0x03);
+	TEST(selectItemV5->iAlphaId.iStatus==DSATTSY_ALPHA_ID1_STATUS);
+	TEST(selectItemV5->iAlphaId.iAlphaId==DSATTSY_ALPHA_ID1);
+	TEST(selectItemV5->iHelp==DSATTSY_HELP);
+	TEST(selectItemV5->iDefaultItemId==DSATTSY_DEFAULT_ITEM);
+	TEST(selectItemV5->iIconId.iQualifier==DSATTSY_ICON_QUALIFIER1);
+	TEST(selectItemV5->iIconId.iIdentifier==DSATTSY_ICON_ID1);
+	TEST(selectItemV5->iIconListQualifier==DSATTSY_ICON_QUALIFIER2);
+	TEST(selectItemV5->iPreference==DSATTSY_SELECTION_PREFERENCE);
+
+	TEST(selectItemV5->iTextAttribute.iStatus == textAttribute1.iStatus);
+	TEST(selectItemV5->iTextAttribute.iTextAttributeData == textAttribute1.iTextAttributeData);
+
+	index = 1;
+	TEST(selectItemV5->GetItem(index++, item, iTextAttribute, action, icon)==KErrNone);
+	TEST(item.iItemId==0x01);
+	TEST(item.iItemString==DSATTSY_ITEM1);
+	TEST(iTextAttribute.iStatus == textAttribute1.iStatus);
+	TEST(iTextAttribute.iTextAttributeData == textAttribute1.iTextAttributeData);
+	TEST(icon==0x01);
+	TEST(action==0x01);
+
+	TEST(selectItemV5->GetItem(index++, item, iTextAttribute, action, icon)==KErrNone);
+	TEST(item.iItemId==0x02);
+	TEST(item.iItemString==DSATTSY_ITEM2);
+	TEST(iTextAttribute.iStatus == textAttribute2.iStatus);
+	TEST(iTextAttribute.iTextAttributeData == textAttribute2.iTextAttributeData);
+	TEST(icon==0x02);
+	TEST(action==0x02);
+
+	TEST(selectItemV5->GetItem(index++, item, iTextAttribute, action, icon)==KErrNone);
+	TEST(item.iItemId==0x03);
+	TEST(item.iItemString==DSATTSY_ITEM3);
+	TEST(iTextAttribute.iStatus == textAttribute3.iStatus);
+	TEST(iTextAttribute.iTextAttributeData == textAttribute3.iTextAttributeData);
+	TEST(icon==0x03);
+	TEST(action==0x03);
+
+	TEST(selectItemV5->GetItem(index,item, iTextAttribute, action)==KErrNotFound);
+
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySelectItemPCmd with RSat::TSelectItemV5 passed"),iTestCount++);
+
+	// Select Item Cancel with RSat::TSelectItemV5
+	sat.NotifySelectItemPCmd(reqStatus,*selectItemV5Pckg);
+	sat.CancelAsyncRequest(ESatNotifySelectItemPCmd);
+
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrCancel);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySelectItemPCmdCancel with RSat::TSelectItemV5 passed"),iTestCount++);
+
+	// Select Item Terminal Response
+	sat.NotifySelectItemPCmd(reqStatus,*selectItemPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	RSat::TSelectItemRspV1* selectItemRsp = new (ELeave) RSat::TSelectItemRspV1;
+	CleanupStack::PushL(selectItemRsp);
+	RSat::TSelectItemRspV1Pckg* selectItemRspPckg = new (ELeave) RSat::TSelectItemRspV1Pckg(*selectItemRsp);
+	CleanupStack::PushL(selectItemRspPckg);
+
+	// Testing that PCmdNumber = 0 is not supported as out of range
+	TEST(selectItemRsp->SetPCmdNumber(0)==KErrNotSupported);
+
+	selectItemRsp->SetPCmdNumber(selectItem->PCmdNumber());
+	selectItemRsp->iGeneralResult=DSATTSY_PCMD_RESULT_SUCCESS;
+	selectItemRsp->iInfoType=DSATTSY_PCMD_RSP_ITEM_ID;
+	selectItemRsp->iAdditionalInfo=DSATTSY_RSP_ITEM_ID;
+
+	sat.TerminalRsp(reqStatus,RSat::ESelectItem,*selectItemRspPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+	INFO_PRINTF2(_L("Test %d - RSat::TerminalRsp - Select Item - passed"),iTestCount++);
+
+	CleanupStack::PopAndDestroy(6, selectItem);
+
+	// Send Sm with V1
+	RSat::TSendSmV1* sendSm = new (ELeave) RSat::TSendSmV1;
+	CleanupStack::PushL(sendSm);
+	RSat::TSendSmV1Pckg* sendSmPckg = new (ELeave) RSat::TSendSmV1Pckg(*sendSm);
+	CleanupStack::PushL(sendSmPckg);
+
+	sat.NotifySendSmPCmd(reqStatus,*sendSmPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	TEST(sendSm->PCmdNumber()==DSATTSY_SEND_SM_NUMBER);
+
+	TEST(sendSm->iAlphaId.iStatus==DSATTSY_ALPHA_ID1_STATUS);
+	TEST(sendSm->iAlphaId.iAlphaId==DSATTSY_ALPHA_ID1);
+	TEST(sendSm->iAddress.iTypeOfNumber==DSATTSY_TON);
+	TEST(sendSm->iAddress.iNumberPlan==DSATTSY_NPI);
+	TEST(sendSm->iAddress.iTelNumber==DSATTSY_TEL_NUMBER);
+	TEST(sendSm->iSmsTpdu==DSATTSY_SMS_TPDU);
+	TEST(sendSm->iIconId.iIdentifier==DSATTSY_ICON_ID1);
+	TEST(sendSm->iIconId.iQualifier==DSATTSY_ICON_QUALIFIER1);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySendSmPCmd with RSat::TSendSmV1 passed"),iTestCount++);
+
+	// Send Sm Cancel with V1
+	sat.NotifySendSmPCmd(reqStatus,*sendSmPckg);
+	sat.CancelAsyncRequest(ESatNotifySendSmPCmd);
+
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrCancel);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySendSmPCmdCancel with RSat::TSendSmV1 passed"),iTestCount++);
+
+	// Send Sm with V5
+	RSat::TSendSmV5* sendSmV5 = new (ELeave) RSat::TSendSmV5;
+	CleanupStack::PushL(sendSmV5);
+	RSat::TSendSmV5Pckg* sendSmV5Pckg = new (ELeave) RSat::TSendSmV5Pckg(*sendSmV5);
+	CleanupStack::PushL(sendSmV5Pckg);
+
+	TEST(sendSmV5->ExtensionId() == RSat::KSatV5);
+	TEST(sendSmV5->iTextAttribute.iStatus == RSat::ETextAttributeNotSet);
+
+	sat.NotifySendSmPCmd(reqStatus, *sendSmV5Pckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	TEST(sendSmV5->PCmdNumber()==DSATTSY_SEND_SM_NUMBER);
+
+	TEST(sendSmV5->iAlphaId.iStatus==DSATTSY_ALPHA_ID1_STATUS);
+	TEST(sendSmV5->iAlphaId.iAlphaId==DSATTSY_ALPHA_ID1);
+	TEST(sendSmV5->iAddress.iTypeOfNumber==DSATTSY_TON);
+	TEST(sendSmV5->iAddress.iNumberPlan==DSATTSY_NPI);
+	TEST(sendSmV5->iAddress.iTelNumber==DSATTSY_TEL_NUMBER);
+	TEST(sendSmV5->iSmsTpdu==DSATTSY_SMS_TPDU);
+	TEST(sendSmV5->iIconId.iIdentifier==DSATTSY_ICON_ID1);
+	TEST(sendSmV5->iIconId.iQualifier==DSATTSY_ICON_QUALIFIER1);
+
+	// V5 parameters
+
+	TEST(sendSmV5->iTextAttribute.iStatus == textAttribute1.iStatus);
+	TEST(sendSmV5->iTextAttribute.iTextAttributeData == textAttribute1.iTextAttributeData);
+
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySendSmPCmd with RSat::TSendSmV5 passed"),iTestCount++);
+
+	// Send Sm Cancel with V5
+	sat.NotifySendSmPCmd(reqStatus,*sendSmV5Pckg);
+	sat.CancelAsyncRequest(ESatNotifySendSmPCmd);
+
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrCancel);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySendSmPCmdCancel with RSat::TSendSmV5 passed"),iTestCount++);
+
+	// Send Sm Terminal Rsp
+	sat.NotifySendSmPCmd(reqStatus,*sendSmPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	RSat::TSendSmRspV1* sendSmRsp = new (ELeave) RSat::TSendSmRspV1;
+	CleanupStack::PushL(sendSmRsp);
+	RSat::TSendSmRspV1Pckg* sendSmRspPckg = new (ELeave) RSat::TSendSmRspV1Pckg(*sendSmRsp);
+	CleanupStack::PushL(sendSmRspPckg);
+
+	sendSmRsp->SetPCmdNumber(sendSm->PCmdNumber());
+	sendSmRsp->iGeneralResult=DSATTSY_PCMD_RESULT_SUCCESS;
+	sendSmRsp->iInfoType=DSATTSY_PCMD_RSP_NO_INFO;
+	sendSmRsp->iAdditionalInfo=DSATTSY_NULL_BUF;
+
+	sat.TerminalRsp(reqStatus,RSat::ESendSm,*sendSmRspPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySendSmPCmd - Send Sm - passed"),iTestCount++);
+
+	CleanupStack::PopAndDestroy(6, sendSm);
+
+	// Send Message No Logging
+	RSat::TSatSmsV1* satSms = new (ELeave) RSat::TSatSmsV1;
+	CleanupStack::PushL(satSms);
+	RSat::TSatSmsV1Pckg* satSmsPckg = new (ELeave) RSat::TSatSmsV1Pckg(*satSms);
+	CleanupStack::PushL(satSmsPckg);
+
+	satSms->iBuf=DSATTSY_SMS_TPDU;
+	satSms->iServiceCenter.iNumberPlan=DSATTSY_NPI;
+	satSms->iServiceCenter.iTypeOfNumber=DSATTSY_TON;
+	satSms->iServiceCenter.iTelNumber=DSATTSY_TEL_NUMBER;
+	TUint16 smsRef;
+
+	sat.SendMessageNoLogging(reqStatus,*satSmsPckg,smsRef);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+	TEST(smsRef==DSATTSY_SMS_REF);
+	INFO_PRINTF2(_L("Test %d - RSat::SendMessageNoLogging passed"),iTestCount++);
+
+	// Send Message No Logging Cancel
+	sat.SendMessageNoLogging(reqStatus,*satSmsPckg,smsRef);
+	sat.CancelAsyncRequest(ESatSendMessageNoLogging);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrCancel);
+	INFO_PRINTF2(_L("Test %d - RSat::SendMessageNoLoggingCancel passed"),iTestCount++);
+
+	CleanupStack::PopAndDestroy(2, satSms);
+
+	// Send Ss
+	RSat::TSendSsV1* sendSs = new (ELeave) RSat::TSendSsV1;
+	CleanupStack::PushL(sendSs);
+	RSat::TSendSsV1Pckg* sendSsPckg = new (ELeave) RSat::TSendSsV1Pckg(*sendSs);
+	CleanupStack::PushL(sendSsPckg);
+
+	sat.NotifySendSsPCmd(reqStatus,*sendSsPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	TEST(sendSs->PCmdNumber()==DSATTSY_SEND_SS_NUMBER);
+
+	TEST(sendSs->iAlphaId.iStatus==DSATTSY_ALPHA_ID1_STATUS);
+	TEST(sendSs->iAlphaId.iAlphaId==DSATTSY_ALPHA_ID1);
+	TEST(sendSs->iSsString.iTypeOfNumber==DSATTSY_TON);
+	TEST(sendSs->iSsString.iNumberPlan==DSATTSY_NPI);
+	TEST(sendSs->iSsString.iSsString==DSATTSY_SS_STRING);
+	TEST(sendSs->iIconId.iIdentifier==DSATTSY_ICON_ID1);
+	TEST(sendSs->iIconId.iQualifier==DSATTSY_ICON_QUALIFIER1);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySendSsPCmd passed"),iTestCount++);
+
+	// Send Ss Cancel
+	sat.NotifySendSsPCmd(reqStatus,*sendSsPckg);
+	sat.CancelAsyncRequest(ESatNotifySendSsPCmd);
+
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrCancel);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySendSsPCmdCancel passed"),iTestCount++);
+
+	// Send Ss Terminal Rsp
+	sat.NotifySendSsPCmd(reqStatus,*sendSsPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	RSat::TSendSsRspV2* sendSsRsp = new (ELeave) RSat::TSendSsRspV2;
+	CleanupStack::PushL(sendSsRsp);
+	RSat::TSendSsRspV2Pckg* sendSsRspPckg = new (ELeave) RSat::TSendSsRspV2Pckg(*sendSsRsp);
+	CleanupStack::PushL(sendSsRspPckg);
+
+	sendSsRsp->SetPCmdNumber(sendSs->PCmdNumber());
+
+	RSat::TCallControlV1* ccRequestedAction = new (ELeave) RSat::TCallControlV1;
+	CleanupStack::PushL(ccRequestedAction);
+
+	sendSsRsp->iGeneralResult=DSATTSY_PCMD_RESULT_SUCCESS;
+	sendSsRsp->iInfoType=DSATTSY_PCMD_RSP_NO_INFO;
+	sendSsRsp->iAdditionalInfo=DSATTSY_NULL_BUF;
+
+	sendSsRsp->iUssdString.iUssdString=DSATTSY_DEFAULT_TEXT;
+	sendSsRsp->iUssdString.iDcs=DSATTSY_DCS;
+
+	RSat::TCallSetUpParams* params = new (ELeave) RSat::TCallSetUpParams;
+	CleanupStack::PushL(params);
+
+	params->iCcp1					=DSATTSY_CCP1;
+	params->iSubAddress				=DSATTSY_SUBADDRESS;
+	params->iCcp2					=DSATTSY_CCP2;
+	params->iAddress.iTypeOfNumber	=DSATTSY_TON;
+	params->iAddress.iNumberPlan		=DSATTSY_NPI;
+	params->iAddress.iTelNumber		=DSATTSY_TEL_NUMBER;
+
+	RSat::TAlphaId* nullBuf = new (ELeave) RSat::TAlphaId;
+	CleanupStack::PushL(nullBuf);
+
+	nullBuf->iAlphaId=DSATTSY_NULL_BUF;
+	nullBuf->iStatus=DSATTSY_ALPHAID_STATUS;
+	ccRequestedAction->SetCcGeneralResult(DSATTSY_CC_RESULT);
+	ccRequestedAction->SetAlphaId(DSATTSY_NO_ALPHAID, *nullBuf);
+	ccRequestedAction->SetCallSetUpDetails(*params);
+	ccRequestedAction->SetBCRepeatIndicator(RSat::EBCSequentialMode);
+
+	sendSsRsp->iCcRequestedAction=*ccRequestedAction;
+
+	sendSsRsp->iGeneralResult2=DSATTSY_PCMD_RESULT_SUCCESS;
+	sendSsRsp->iInfoType2=DSATTSY_PCMD_RSP_NO_INFO;
+	sendSsRsp->iAdditionalInfo2=DSATTSY_NULL_BUF;
+
+	sat.TerminalRsp(reqStatus,RSat::ESendSs,*sendSsRspPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	INFO_PRINTF2(_L("Test %d - RSat::TerminalRsp -Send Ss - passed"),iTestCount++);
+
+	// Send Ussd
+	RSat::TSendUssdV1* sendUssd = new (ELeave) RSat::TSendUssdV1;
+	CleanupStack::PushL(sendUssd);
+	RSat::TSendUssdV1Pckg* sendUssdPckg = new (ELeave) RSat::TSendUssdV1Pckg(*sendUssd);
+	CleanupStack::PushL(sendUssdPckg);
+
+	sat.NotifySendUssdPCmd(reqStatus,*sendUssdPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	TEST(sendUssd->PCmdNumber()==DSATTSY_SEND_USSD_NUMBER);
+
+	TEST(sendUssd->iAlphaId.iStatus==DSATTSY_ALPHA_ID1_STATUS);
+	TEST(sendUssd->iAlphaId.iAlphaId==DSATTSY_ALPHA_ID1);
+	TEST(sendUssd->iUssdString.iDcs==DSATTSY_DCS);
+	TEST(sendUssd->iUssdString.iUssdString==DSATTSY_USSD_STRING);
+	TEST(sendUssd->iIconId.iIdentifier==DSATTSY_ICON_ID1);
+	TEST(sendUssd->iIconId.iQualifier==DSATTSY_ICON_QUALIFIER1);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySendUssdPCmd passed"),iTestCount++);
+
+	// Send Ussd Cancel
+	sat.NotifySendUssdPCmd(reqStatus,*sendUssdPckg);
+	sat.CancelAsyncRequest(ESatNotifySendUssdPCmd);
+
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrCancel);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySendUssdPCmdCancel passed"), iTestCount++);
+
+	// Send Ussd Terminal Rsp
+	sat.NotifySendUssdPCmd(reqStatus,*sendUssdPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	RSat::TSendUssdRspV1* sendUssdRsp = new (ELeave) RSat::TSendUssdRspV1;
+	CleanupStack::PushL(sendUssdRsp);
+	RSat::TSendUssdRspV1Pckg* sendUssdRspPckg = new (ELeave) RSat::TSendUssdRspV1Pckg(*sendUssdRsp);
+	CleanupStack::PushL(sendUssdRspPckg);
+
+	sendUssdRsp->SetPCmdNumber(sendUssd->PCmdNumber());
+
+	sendUssdRsp->iGeneralResult=DSATTSY_PCMD_RESULT_SUCCESS;
+	sendUssdRsp->iInfoType=DSATTSY_PCMD_RSP_TEXT_STRING;
+	sendUssdRsp->iAdditionalInfo=DSATTSY_NETWORK_TEXT_STRING;
+
+	sendUssdRsp->iCcRequestedAction=*ccRequestedAction;
+
+	sendUssdRsp->iGeneralResult2=DSATTSY_PCMD_RESULT_SUCCESS;
+	sendUssdRsp->iInfoType2=DSATTSY_PCMD_RSP_NO_INFO;
+	sendUssdRsp->iAdditionalInfo2=DSATTSY_NULL_BUF;
+
+	sat.TerminalRsp(reqStatus,RSat::ESendUssd,*sendUssdRspPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+	INFO_PRINTF2(_L("Test %d - RSat::TerminalRsp - Send USSD - passed"),iTestCount++);
+
+	// Set Up Call
+	RSat::TSetUpCallV1* setUpCall = new (ELeave) RSat::TSetUpCallV1;
+	CleanupStack::PushL(setUpCall);
+	RSat::TSetUpCallV1Pckg* setUpCallPckg = new (ELeave) RSat::TSetUpCallV1Pckg(*setUpCall);
+	CleanupStack::PushL(setUpCallPckg);
+
+	sat.NotifySetUpCallPCmd(reqStatus,*setUpCallPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	TEST(setUpCall->PCmdNumber()==DSATTSY_SET_UP_CALL_NUMBER);
+
+	TEST(setUpCall->iType==DSATTSY_SET_UP_CALL_TYPE);
+	TEST(setUpCall->iAlphaIdConfirmationPhase.iStatus==DSATTSY_ALPHA_ID1_STATUS);
+	TEST(setUpCall->iAlphaIdConfirmationPhase.iAlphaId==DSATTSY_ALPHA_ID1);
+	TEST(setUpCall->iIconIdConfirmationPhase.iIdentifier==DSATTSY_ICON_ID1);
+	TEST(setUpCall->iIconIdConfirmationPhase.iQualifier==DSATTSY_ICON_QUALIFIER1);
+	TEST(setUpCall->iAddress.iTypeOfNumber==DSATTSY_TON);
+	TEST(setUpCall->iAddress.iNumberPlan==DSATTSY_NPI);
+	TEST(setUpCall->iAddress.iTelNumber==DSATTSY_TEL_NUMBER);
+	TEST(setUpCall->iCapabilityConfigParams==DSATTSY_CCP1);
+	TEST(setUpCall->iSubAddress==DSATTSY_SUBADDRESS);
+	TEST(setUpCall->iDuration.iTimeUnit==DSATTSY_TIME_UNIT);
+	TEST(setUpCall->iDuration.iNumOfUnits==DSATTSY_NUM_OF_UNITS);
+	TEST(setUpCall->iAlphaIdCallSetUpPhase.iStatus==DSATTSY_ALPHA_ID2_STATUS);
+	TEST(setUpCall->iAlphaIdCallSetUpPhase.iAlphaId==DSATTSY_ALPHA_ID2);
+	TEST(setUpCall->iIconIdCallSetUpPhase.iIdentifier==DSATTSY_ICON_ID2);
+	TEST(setUpCall->iIconIdCallSetUpPhase.iQualifier==DSATTSY_ICON_QUALIFIER2);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpCallPCmd RSat::TSetUpCallV1 passed"),iTestCount++);
+
+	// Set Up Call Cancel
+	sat.NotifySetUpCallPCmd(reqStatus,*setUpCallPckg);
+	sat.CancelAsyncRequest(ESatNotifySetUpCallPCmd);
+
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrCancel);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpCallPCmdCancel RSat::TSetUpCallV1 passed"), iTestCount++);
+
+	// Set Up Call
+	RSat::TSetUpCallV5* setUpCallV5 = new (ELeave) RSat::TSetUpCallV5;
+	CleanupStack::PushL(setUpCallV5);
+	RSat::TSetUpCallV5Pckg* setUpCallV5Pckg = new (ELeave) RSat::TSetUpCallV5Pckg(*setUpCallV5);
+	CleanupStack::PushL(setUpCallV5Pckg);
+
+	TEST(setUpCallV5->ExtensionId() == RSat::KSatV5);
+	TEST(setUpCallV5->iTextAttributeConfirmationPhase.iStatus == RSat::ETextAttributeNotSet);
+	TEST(setUpCallV5->iTextAttributeCallSetUpPhase.iStatus == RSat::ETextAttributeNotSet);
+
+	sat.NotifySetUpCallPCmd(reqStatus,*setUpCallV5Pckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	TEST(setUpCallV5->PCmdNumber()==DSATTSY_SET_UP_CALL_NUMBER);
+
+	TEST(setUpCallV5->iType==DSATTSY_SET_UP_CALL_TYPE);
+	TEST(setUpCallV5->iAlphaIdConfirmationPhase.iStatus==DSATTSY_ALPHA_ID1_STATUS);
+	TEST(setUpCallV5->iAlphaIdConfirmationPhase.iAlphaId==DSATTSY_ALPHA_ID1);
+	TEST(setUpCallV5->iIconIdConfirmationPhase.iIdentifier==DSATTSY_ICON_ID1);
+	TEST(setUpCallV5->iIconIdConfirmationPhase.iQualifier==DSATTSY_ICON_QUALIFIER1);
+	TEST(setUpCallV5->iAddress.iTypeOfNumber==DSATTSY_TON);
+	TEST(setUpCallV5->iAddress.iNumberPlan==DSATTSY_NPI);
+	TEST(setUpCallV5->iAddress.iTelNumber==DSATTSY_TEL_NUMBER);
+	TEST(setUpCallV5->iCapabilityConfigParams==DSATTSY_CCP1);
+	TEST(setUpCallV5->iSubAddress==DSATTSY_SUBADDRESS);
+	TEST(setUpCallV5->iDuration.iTimeUnit==DSATTSY_TIME_UNIT);
+	TEST(setUpCallV5->iDuration.iNumOfUnits==DSATTSY_NUM_OF_UNITS);
+	TEST(setUpCallV5->iAlphaIdCallSetUpPhase.iStatus==DSATTSY_ALPHA_ID2_STATUS);
+	TEST(setUpCallV5->iAlphaIdCallSetUpPhase.iAlphaId==DSATTSY_ALPHA_ID2);
+	TEST(setUpCallV5->iIconIdCallSetUpPhase.iIdentifier==DSATTSY_ICON_ID2);
+	TEST(setUpCallV5->iIconIdCallSetUpPhase.iQualifier==DSATTSY_ICON_QUALIFIER2);
+	// Version 5 parameters
+	TEST(setUpCallV5->iTextAttributeConfirmationPhase.iStatus == textAttribute1.iStatus);
+	TEST(setUpCallV5->iTextAttributeConfirmationPhase.iTextAttributeData == textAttribute1.iTextAttributeData);
+	TEST(setUpCallV5->iTextAttributeCallSetUpPhase.iStatus == textAttribute1.iStatus);
+	TEST(setUpCallV5->iTextAttributeCallSetUpPhase.iTextAttributeData == textAttribute1.iTextAttributeData);
+
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpCallPCmd with RSat::TSetUpCallV5 passed"),iTestCount++);
+
+	// Set Up Call Cancel
+	sat.NotifySetUpCallPCmd(reqStatus,*setUpCallV5Pckg);
+	sat.CancelAsyncRequest(ESatNotifySetUpCallPCmd);
+
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrCancel);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpCallPCmdCancel with RSat::TSetUpCallV5 passed"), iTestCount++);
+
+	// Set Up Call Terminal Rsp
+	sat.NotifySetUpCallPCmd(reqStatus,*setUpCallPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	RSat::TSetUpCallRspV2* setUpCallRspV2 = new (ELeave) RSat::TSetUpCallRspV2;
+	CleanupStack::PushL(setUpCallRspV2);
+	RSat::TSetUpCallRspV2Pckg* setUpCallRspV2Pckg = new (ELeave) RSat::TSetUpCallRspV2Pckg(*setUpCallRspV2);
+	CleanupStack::PushL(setUpCallRspV2Pckg);
+
+	setUpCallRspV2->SetPCmdNumber(DSATTSY_SET_UP_CALL_NUMBER);
+	setUpCallRspV2->iGeneralResult=DSATTSY_PCMD_RESULT_SUCCESS;
+	setUpCallRspV2->iInfoType=DSATTSY_PCMD_RSP_NO_INFO;
+	setUpCallRspV2->iAdditionalInfo=DSATTSY_NULL_BUF;
+	setUpCallRspV2->iCcRequestedAction=*ccRequestedAction;
+
+	setUpCallRspV2->iGeneralResult2=DSATTSY_PCMD_RESULT_SUCCESS;
+	setUpCallRspV2->iInfoType2=DSATTSY_PCMD_RSP_NO_INFO;
+	setUpCallRspV2->iAdditionalInfo2=DSATTSY_NULL_BUF;
+
+	setUpCallRspV2->iUssdString.iUssdString=DSATTSY_DEFAULT_TEXT;
+	setUpCallRspV2->iUssdString.iDcs=DSATTSY_DCS;
+
+	sat.TerminalRsp(reqStatus,RSat::ESetUpCall,*setUpCallRspV2Pckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+	INFO_PRINTF2(_L("Test %d - RSat::TerminalRsp - Set Up Call passed"),iTestCount++);
+
+	CleanupStack::PopAndDestroy(17, sendSs);
+
+	// Refresh
+	RSat::TRefreshV2* refresh = new (ELeave) RSat::TRefreshV2;
+	CleanupStack::PushL(refresh);
+	RSat::TRefreshV2Pckg* refreshPckg = new (ELeave) RSat::TRefreshV2Pckg(*refresh);
+	CleanupStack::PushL(refreshPckg);
+
+	sat.NotifyRefreshPCmd(reqStatus,*refreshPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	TEST(refresh->PCmdNumber()==DSATTSY_REFRESH_NUMBER);
+
+	TEST(refresh->iType==DSATTSY_REFRESH_TYPE);
+	TEST(refresh->iFileList.Length()==2);
+ 	TEST(refresh->iFileList[0]==DSATTSY_REFRESH_ADN_EF);
+ 	TEST(refresh->iFileList[1]==DSATTSY_REFRESH_FDN_EF);
+	TEST(refresh->iAid==DSATTSY_AID);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifyRefreshPCmd passed"),iTestCount++);
+
+	// Refresh Cancel
+	sat.NotifyRefreshPCmd(reqStatus,*refreshPckg);
+	sat.CancelAsyncRequest(ESatNotifyRefreshPCmd);
+
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrCancel);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifyRefreshPCmdCancel passed"),iTestCount++);
+
+	// Refresh Required
+	sat.NotifyRefreshRequired(reqStatus);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifyRefreshRequired passed"),iTestCount++);
+
+	// Refresh Required Cancel
+	sat.NotifyRefreshRequired(reqStatus);
+	sat.CancelAsyncRequest(ESatNotifyRefreshRequired);
+
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrCancel);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifyRefreshRequiredCancel passed"),iTestCount++);
+
+	// Refresh Required
+	sat.NotifyRefreshRequired(reqStatus,*refreshPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	TEST(refresh->iType==DSATTSY_REFRESH_TYPE);
+	TEST(refresh->iFileList.Length()==2);
+ 	TEST(refresh->iFileList[0]==DSATTSY_REFRESH_FDN_EF);
+ 	TEST(refresh->iFileList[1]==DSATTSY_REFRESH_ADN_EF);
+	TEST(refresh->iAid==DSATTSY_AID);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifyRefreshRequiredParam passed"),iTestCount++);
+
+	sat.NotifyRefreshRequired(reqStatus,*refreshPckg);
+	sat.CancelAsyncRequest(ESatNotifyRefreshRequiredParam);
+
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrCancel);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifyRefreshRequiredParamCancel passed"),iTestCount++);
+
+	// Refresh Terminal Response
+	sat.NotifyRefreshPCmd(reqStatus,*refreshPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	RSat::TRefreshRspV1* refreshRsp = new (ELeave) RSat::TRefreshRspV1;
+	CleanupStack::PushL(refreshRsp);
+	RSat::TRefreshRspV1Pckg* refreshRspPckg = new (ELeave) RSat::TRefreshRspV1Pckg(*refreshRsp);
+	CleanupStack::PushL(refreshRspPckg);
+
+	refreshRsp->SetPCmdNumber(refresh->PCmdNumber());
+	refreshRsp->iGeneralResult=DSATTSY_PCMD_RESULT_SUCCESS;
+	refreshRsp->iInfoType=DSATTSY_PCMD_RSP_NO_INFO;
+	refreshRsp->iAdditionalInfo=DSATTSY_NULL_BUF;
+
+	sat.TerminalRsp(reqStatus,RSat::ERefresh,*refreshRspPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+	INFO_PRINTF2(_L("Test %d - RSat::TerminalRsp - Refresh - passed"),iTestCount++);
+
+	// Refresh Required Response
+	RSat::TRefreshRspV1* refreshAllowedRsp = new (ELeave) RSat::TRefreshRspV1;
+	CleanupStack::PushL(refreshAllowedRsp);
+	RSat::TRefreshRspV1Pckg* refreshAllowedRspPckg = new (ELeave) RSat::TRefreshRspV1Pckg(*refreshAllowedRsp);
+	CleanupStack::PushL(refreshAllowedRspPckg);
+
+	refreshAllowedRsp->iGeneralResult=DSATTSY_PCMD_RESULT_SUCCESS;
+	refreshAllowedRsp->iInfoType=DSATTSY_PCMD_RSP_NO_INFO;
+	refreshAllowedRsp->iAdditionalInfo=DSATTSY_NULL_BUF;
+
+	sat.RefreshAllowed(reqStatus, *refreshAllowedRspPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	INFO_PRINTF2(_L("Test %d - RSat::RefreshAllowed - passed"),iTestCount++);
+
+	// Refresh Required Response Cancel
+	sat.RefreshAllowed(reqStatus, *refreshAllowedRspPckg);
+	sat.CancelAsyncRequest(ESatRefreshAllowed);
+
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrCancel);
+	INFO_PRINTF2(_L("Test %d - RSat::RefreshAllowedCancel passed"),iTestCount++);
+
+	CleanupStack::PopAndDestroy(6, refresh);
+
+	// Set Up Event List
+	RSat::TSetUpEventListV1* setUpEventList = new (ELeave) RSat::TSetUpEventListV1;
+	CleanupStack::PushL(setUpEventList);
+	RSat::TSetUpEventListV1Pckg* setUpEventListPckg = new (ELeave) RSat::TSetUpEventListV1Pckg(*setUpEventList);
+	CleanupStack::PushL(setUpEventListPckg);
+
+	sat.NotifySetUpEventListPCmd(reqStatus,*setUpEventListPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	TEST(setUpEventList->PCmdNumber()==DSATTSY_SET_UP_EVENT_LIST_NUMBER);
+
+	TEST(setUpEventList->iType==DSATTSY_SET_UP_EVENT_LIST_TYPE);
+	TEST(setUpEventList->iEvents==DSATTSY_EVENTS);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpEventList passed"),iTestCount++);
+
+	// Set Up Event List Cancel
+	sat.NotifySetUpEventListPCmd(reqStatus,*setUpEventListPckg);
+	sat.CancelAsyncRequest(ESatNotifySetUpEventListPCmd);
+
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrCancel);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpEventListPCmdCancel passed"),iTestCount++);
+
+	// Set Up Event List Terminal Response
+	sat.NotifySetUpEventListPCmd(reqStatus,*setUpEventListPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	RSat::TSetUpEventListRspV1* setUpEventListRsp = new (ELeave) RSat::TSetUpEventListRspV1;
+	CleanupStack::PushL(setUpEventListRsp);
+	RSat::TSetUpEventListRspV1Pckg* setUpEventListRspPckg = new (ELeave) RSat::TSetUpEventListRspV1Pckg(*setUpEventListRsp);
+	CleanupStack::PushL(setUpEventListRspPckg);
+
+	setUpEventListRsp->SetPCmdNumber(setUpEventList->PCmdNumber());
+	setUpEventListRsp->iGeneralResult=DSATTSY_PCMD_RESULT_SUCCESS;
+	setUpEventListRsp->iInfoType=DSATTSY_PCMD_RSP_NO_INFO;
+	setUpEventListRsp->iAdditionalInfo=DSATTSY_NULL_BUF;
+
+	sat.TerminalRsp(reqStatus,RSat::ESetUpEventList,*setUpEventListRspPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+	INFO_PRINTF2(_L("Test %d - RSat::TerminalRsp - Set Up Event List - passed"),iTestCount++);
+
+	CleanupStack::PopAndDestroy(4, setUpEventList);
+
+	// Set Up Idle Mode Text with V1
+	RSat::TSetUpIdleModeTextV1* setUpIdleModeText = new (ELeave) RSat::TSetUpIdleModeTextV1;
+	CleanupStack::PushL(setUpIdleModeText);
+	RSat::TSetUpIdleModeTextV1Pckg* setUpIdleModeTextPckg = new (ELeave) RSat::TSetUpIdleModeTextV1Pckg(*setUpIdleModeText);
+	CleanupStack::PushL(setUpIdleModeTextPckg);
+
+	sat.NotifySetUpIdleModeTextPCmd(reqStatus,*setUpIdleModeTextPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	TEST(setUpIdleModeText->PCmdNumber()==DSATTSY_SET_UP_IDLE_MODE_TEXT_NUMBER);
+
+   	TEST(setUpIdleModeText->iType==DSATTSY_IDLE_MODE_TXT_TYPE);
+ 	TEST(setUpIdleModeText->iText==DSATTSY_IDLE_MODE_TEXT);
+   	TEST(setUpIdleModeText->iIconId.iIdentifier==DSATTSY_ICON_ID1);
+   	TEST(setUpIdleModeText->iIconId.iQualifier==DSATTSY_ICON_QUALIFIER1);
+   	TEST(setUpIdleModeText->iCodingScheme==DSATTSY_TEXT_ENCODING_SCHEME);
+ 	TPtrC idleModeText(DSATTSY_IDLE_MODE_TEXT);
+ 	TEST(setUpIdleModeText->iText.Length() == idleModeText.Length()); // 276
+ 	TEST(setUpIdleModeText->iText.Size() == idleModeText.Size()); // 552
+ 	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpIdleModeText (Unicode) with RSat::TSetUpIdleModeTextV1 passed"),iTestCount++);
+
+ 	// Set Up Idle Mode Text Cancel with V1
+ 	sat.NotifySetUpIdleModeTextPCmd(reqStatus,*setUpIdleModeTextPckg);
+ 	sat.CancelAsyncRequest(ESatNotifySetUpIdleModeTextPCmd);
+
+ 	User::WaitForRequest(reqStatus);
+ 	TEST(reqStatus.Int()==KErrCancel);
+ 	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpIdleModeTextPCmdCancel with RSat::TSetUpIdleModeTextV1passed"),iTestCount++);
+
+ 	// Issue another request. The DTSY will set the idle text mode to an 8-bit string
+ 	sat.NotifySetUpIdleModeTextPCmd(reqStatus,*setUpIdleModeTextPckg);
+ 	User::WaitForRequest(reqStatus);
+ 	TEST(reqStatus.Int()==KErrNone);
+
+ 	TEST(setUpIdleModeText->PCmdNumber()==DSATTSY_SET_UP_IDLE_MODE_TEXT_NUMBER);
+
+ 	TPtrC8 textIdleMode8(DSATTSY_IDLE_MODE_TEXT_8BIT);
+   	TEST(setUpIdleModeText->iType==DSATTSY_IDLE_MODE_TXT_TYPE);
+   	TBuf8<276> text8;
+   	CnvUtfConverter::ConvertFromUnicodeToUtf8(text8,setUpIdleModeText->iText);
+ 	TEST(text8==DSATTSY_IDLE_MODE_TEXT_8BIT);
+   	TEST(setUpIdleModeText->iIconId.iIdentifier==DSATTSY_ICON_ID1);
+   	TEST(setUpIdleModeText->iIconId.iQualifier==DSATTSY_ICON_QUALIFIER1);
+   	TEST(setUpIdleModeText->iCodingScheme==DSATTSY_TEXT_ENCODING_SCHEME_8);
+
+ 	TEST(setUpIdleModeText->iText.Length() == textIdleMode8.Length()); // 276
+ 	TEST(setUpIdleModeText->iText.Size() == 2*textIdleMode8.Size()); // 2*276
+
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpIdleModeText (8-bit) with RSat::TSetUpIdleModeTextV1 passed"),iTestCount++);
+
+	// Set Up Idle Mode Text Cancel with V1
+	sat.NotifySetUpIdleModeTextPCmd(reqStatus,*setUpIdleModeTextPckg);
+	sat.CancelAsyncRequest(ESatNotifySetUpIdleModeTextPCmd);
+
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrCancel);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpIdleModeTextPCmdCancel passed"),iTestCount++);
+
+	// Set Up Idle Mode Text with V5
+	RSat::TSetUpIdleModeTextV5* setUpIdleModeTextV5 = new (ELeave) RSat::TSetUpIdleModeTextV5;
+	CleanupStack::PushL(setUpIdleModeTextV5);
+	RSat::TSetUpIdleModeTextV5Pckg* setUpIdleModeTextV5Pckg = new (ELeave) RSat::TSetUpIdleModeTextV5Pckg(*setUpIdleModeTextV5);
+	CleanupStack::PushL(setUpIdleModeTextV5Pckg);
+
+	TEST(setUpIdleModeTextV5->ExtensionId() == RSat::KSatV5);
+	TEST(setUpIdleModeTextV5->iTextAttribute.iStatus == RSat::ETextAttributeNotSet);
+
+	sat.NotifySetUpIdleModeTextPCmd(reqStatus,*setUpIdleModeTextV5Pckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	TEST(setUpIdleModeTextV5->PCmdNumber()==DSATTSY_SET_UP_IDLE_MODE_TEXT_NUMBER);
+
+   	TEST(setUpIdleModeTextV5->iType==DSATTSY_IDLE_MODE_TXT_TYPE);
+ 	TEST(setUpIdleModeTextV5->iText==DSATTSY_IDLE_MODE_TEXT);
+   	TEST(setUpIdleModeTextV5->iIconId.iIdentifier==DSATTSY_ICON_ID1);
+   	TEST(setUpIdleModeTextV5->iIconId.iQualifier==DSATTSY_ICON_QUALIFIER1);
+   	TEST(setUpIdleModeTextV5->iCodingScheme==DSATTSY_TEXT_ENCODING_SCHEME);
+
+ 	TEST(setUpIdleModeTextV5->iText.Length() == idleModeText.Length()); // 276
+ 	TEST(setUpIdleModeTextV5->iText.Size() == idleModeText.Size()); // 552
+
+	// V5 parameters
+	TEST(setUpIdleModeTextV5->iTextAttribute.iStatus == textAttribute1.iStatus);
+	TEST(setUpIdleModeTextV5->iTextAttribute.iTextAttributeData == textAttribute1.iTextAttributeData);
+
+ 	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpIdleModeText (Unicode) with RSat::TSetUpIdleModeTextV5 passed"),iTestCount++);
+
+ 	// Set Up Idle Mode Text Cancel
+ 	sat.NotifySetUpIdleModeTextPCmd(reqStatus,*setUpIdleModeTextV5Pckg);
+ 	sat.CancelAsyncRequest(ESatNotifySetUpIdleModeTextPCmd);
+
+ 	User::WaitForRequest(reqStatus);
+ 	TEST(reqStatus.Int()==KErrCancel);
+ 	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpIdleModeTextPCmdCancel with RSat::TSetUpIdleModeTextV5 passed"),iTestCount++);
+
+ 	// Issue another request. The DTSY will set the idle text mode to an 8-bit string
+ 	sat.NotifySetUpIdleModeTextPCmd(reqStatus,*setUpIdleModeTextV5Pckg);
+ 	User::WaitForRequest(reqStatus);
+ 	TEST(reqStatus.Int()==KErrNone);
+
+ 	TEST(setUpIdleModeTextV5->PCmdNumber()==DSATTSY_SET_UP_IDLE_MODE_TEXT_NUMBER);
+
+ 	TPtrC8 textIdleMode8_V5(DSATTSY_IDLE_MODE_TEXT_8BIT);
+   	TEST(setUpIdleModeTextV5->iType==DSATTSY_IDLE_MODE_TXT_TYPE);
+   	TBuf8<276> text8_V5;
+   	CnvUtfConverter::ConvertFromUnicodeToUtf8(text8_V5,setUpIdleModeText->iText);
+ 	TEST(text8==DSATTSY_IDLE_MODE_TEXT_8BIT);
+   	TEST(setUpIdleModeTextV5->iIconId.iIdentifier==DSATTSY_ICON_ID1);
+   	TEST(setUpIdleModeTextV5->iIconId.iQualifier==DSATTSY_ICON_QUALIFIER1);
+   	TEST(setUpIdleModeTextV5->iCodingScheme==DSATTSY_TEXT_ENCODING_SCHEME_8);
+
+ 	TEST(setUpIdleModeTextV5->iText.Length() == textIdleMode8_V5.Length()); // 276
+ 	TEST(setUpIdleModeTextV5->iText.Size() == 2*textIdleMode8_V5.Size()); // 2*276
+
+	TEST(setUpIdleModeTextV5->iTextAttribute.iStatus == textAttribute1.iStatus);
+	TEST(setUpIdleModeTextV5->iTextAttribute.iTextAttributeData == textAttribute1.iTextAttributeData);
+
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpIdleModeText (8-bit) with RSat::TSetUpIdleModeTextV5 passed"),iTestCount++);
+
+	// Set Up Idle Mode Text Cancel
+	sat.NotifySetUpIdleModeTextPCmd(reqStatus,*setUpIdleModeTextV5Pckg);
+	sat.CancelAsyncRequest(ESatNotifySetUpIdleModeTextPCmd);
+
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrCancel);
+	INFO_PRINTF2(_L("Test %d - RSat::NotifySetUpIdleModeTextPCmdCancel with RSat::TSetUpIdleModeTextV5 passed"),iTestCount++);
+
+	// Set Up Idle Mode Text Terminal Rsp
+	sat.NotifySetUpIdleModeTextPCmd(reqStatus,*setUpIdleModeTextPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+
+	RSat::TSetUpIdleModeTextRspV1* setUpIdleModeTextRsp = new (ELeave) RSat::TSetUpIdleModeTextRspV1;
+	CleanupStack::PushL(setUpIdleModeTextRsp);
+	RSat::TSetUpIdleModeTextRspV1Pckg* setUpIdleModeTextRspPckg = new (ELeave) RSat::TSetUpIdleModeTextRspV1Pckg(*setUpIdleModeTextRsp);
+	CleanupStack::PushL(setUpIdleModeTextRspPckg);
+
+	setUpIdleModeTextRsp->SetPCmdNumber(setUpIdleModeText->PCmdNumber());
+	setUpIdleModeTextRsp->iGeneralResult=DSATTSY_PCMD_RESULT_SUCCESS;
+	setUpIdleModeTextRsp->iInfoType=DSATTSY_PCMD_RSP_NO_INFO;
+	setUpIdleModeTextRsp->iAdditionalInfo=DSATTSY_NULL_BUF;
+
+	sat.TerminalRsp(reqStatus,RSat::ESetUpIdleModeText,*setUpIdleModeTextRspPckg);
+	User::WaitForRequest(reqStatus);
+	TEST(reqStatus.Int()==KErrNone);
+	INFO_PRINTF2(_L("Test %d - RSat::TerminalRsp - Set Up Idle Mode Text - passed"),iTestCount++);
+
+	CleanupStack::PopAndDestroy(6, setUpIdleModeText);
+
+	sat.Close();
+	phone.Close();
+
+	return TestStepResult();
+	}