diff -r 000000000000 -r 3553901f7fa8 telephonyserverplugins/ctsydispatchlayer/test/dispatchertests/dispatchsrc/cctsysatfu.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/telephonyserverplugins/ctsydispatchlayer/test/dispatchertests/dispatchsrc/cctsysatfu.cpp Tue Feb 02 01:41:59 2010 +0200 @@ -0,0 +1,3798 @@ + +// 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "cctsysatfu.h" +#include +#include //for KLtsyDispatchSmsSendSatSmsApiId +#include //for KLtsyDispatchPhoneGetPhoneIdApiId +#include //for KLtsyDispatchPhonebookSmsStoreWriteEntryApiId +#include "mockltsyindicatorids.h" + + +#include "testconstants.h" +#include + + +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 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(tlv.End()); + + TMockLtsyData1 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(menuSelectionEnvelope.End()); + TMockLtsyData1 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(displayTextTlv.End()); + + TMockLtsyData1 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(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(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 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 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 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 getImageInstanceData(recordNumber,imageInstanceNumberInRecord); + getImageInstanceData.SerialiseL(getData); + + RBuf8 imageInstanceData; + CleanupClosePushL(imageInstanceData); + + RBuf8 imageInstanceBody; + CleanupClosePushL(imageInstanceBody); + + //A basic image data + const TUint KIconDataLength = 2; + imageInstanceData.CreateMaxL(KIconDataLength); + imageInstanceData[0] = retrievedIconEfImg[KNoImagesLength + 1]; //i.e. KWidth; + imageInstanceData[1] = retrievedIconEfImg[KNoImagesLength + 2]; //i.e. KHeight; + + //The image body + imageInstanceBody.CreateMaxL(KWidth * KHeight); + + //fill with any data (just for testing) + for(TInt i = 0; i < imageInstanceBody.Length(); ++i) + { + imageInstanceBody[i] = i; + } + + TDesC8* imageInstanceDataPtr = &imageInstanceData; + TDesC8* imageInstanceBodyPtr = &imageInstanceBody; + + TMockLtsyData2 retImageInstanceData(imageInstanceDataPtr,imageInstanceBodyPtr); + retImageInstanceData.SerialiseL(retData); + + //queue the MockLTSY expect completes + iMockLTSY.ExpectL(MLtsyDispatchSatGetImageInstance::KLtsyDispatchSatGetImageInstanceApiId,getData); + iMockLTSY.CompleteL(MLtsyDispatchSatGetImageInstance::KLtsyDispatchSatGetImageInstanceApiId, KErrNone, retData); + + //this is used in the CTSY to check against the retrieved icon EF(Img) record + RSat::TInstanceInfoV3 instanceInfo; + instanceInfo.iInstanceNumber = KInstanceNumber; + instanceInfo.iLength = KLength; + instanceInfo.iOffset = KOffset; + instanceInfo.iCoding = RSat::KBasic; + instanceInfo.iImgWidth = KWidth; + instanceInfo.iImgHeight = KHeight; + instanceInfo.iFileId = 0; //not used in the CTSY + + RSat::TInstanceInfoV3Pckg instanceInfoPackage1(instanceInfo); + + RBuf8 retrievedImageinstance; + CleanupClosePushL(retrievedImageinstance); + retrievedImageinstance.CreateL(KIconDataLength + (KWidth * KHeight)); //the EF(IIDF) + + // ETel Sat Calls + iSat.GetImageInstance(reqStatus, instanceInfoPackage1, retrievedImageinstance); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),KErrNone); + ASSERT_TRUE(retrievedImageinstance.Mid(0,KIconDataLength) == imageInstanceData); + ASSERT_TRUE(retrievedImageinstance.Mid(KIconDataLength) == imageInstanceBody); + + AssertMockLtsyStatusL(); + + getData.Close(); + retData.Close(); + + CleanupStack::PopAndDestroy(&retrievedImageinstance); + CleanupStack::PopAndDestroy(&imageInstanceBody); + CleanupStack::PopAndDestroy(&imageInstanceData); + + /*************************************************************************************************/ + + /******************************************Get Image Instance*************************************/ + + //Test to get a given Icon instances CLUT + + TMockLtsyData2 getClutData(recordNumber,imageInstanceNumberInRecord); + getClutData.SerialiseL(getData); + + const TUint KClutLength = 24; + TBuf8 clutData(KClutLength); + + //fill with any data (just for testing) + for(TInt j = 0; j < clutData.Length(); ++j) + { + clutData[j] = j; + } + + TDesC8* clutDataPtr = &clutData; + TMockLtsyData1 retClutData(clutDataPtr); + retClutData.SerialiseL(retData); + + //queue the MockLTSY expect completes + iMockLTSY.ExpectL(MLtsyDispatchSatGetClut::KLtsyDispatchSatGetClutApiId,getData); + iMockLTSY.CompleteL(MLtsyDispatchSatGetClut::KLtsyDispatchSatGetClutApiId,KErrNone, retData); + + const TUint KGetClutOffset = 0; //Unused in the CTSY + + // ETel Sat Calls + TBuf8 retrievedClut; + iSat.GetClut(reqStatus, KInstanceNumber, KGetClutOffset, retrievedClut); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),KErrNone); + ASSERT_TRUE(clutData == retrievedClut); + AssertMockLtsyStatusL(); + + getData.Close(); + retData.Close(); + + /*************************************************************************************************/ + + CleanupStack::PopAndDestroy(&retData); + CleanupStack::PopAndDestroy(&getData); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UC0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test setting up the event list then an event download (User Activity) from ETel +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifySetUpEventListPCmd, Proactive command, RSat::TerminalRsp, RSat::EventDownload +@SYMTestExpectedResults Pass +@SYMTestType CT + */ +void CCTsySatFU::TestUseCase0004L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + const TUint8 KPCommandNumber = 123; + + SetupEventListL(KPCommandNumber,KEventUserActivity); + + // Create envelope + TTlv envelope; + envelope.Begin(KBerTlvEventDownloadTag); + // Event list + envelope.AddTag(KTlvEventListTag); + envelope.AddByte(KEventUserActivity); + // Device identities + envelope.AddTag(KTlvDeviceIdentityTag); + envelope.AddByte(KMe); + envelope.AddByte(KSim); + + WaitForEventDownloadL(RSat::KUserActivity,envelope.End()); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UC0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for control related functionality - a call is requested via a proactive command and then modified via call control +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifySetUpCallPCmd, RCall::OpenNewCall, RSat::TerminalRsp +@SYMTestExpectedResults Pass +@SYMTestType CT + */ +void CCTsySatFU::TestUseCase0005L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + iCallContainer = new (ELeave) CCallTypeContainer(); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus requestStatus; + + //provide location info so that it can be used during call control events + SetupLocalInfoL(KLocationAreaCode,KCellId,KOperatorCode,KLocationStatusNormalService); + //************************************************************************************ + //Now we do a setup call proactive command + + TUint8 pcmdCode = KSetUpCall; + TMockLtsyData1 expLtsyData(pcmdCode); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,data); + RSat::TSetUpCallV6 setupCall; + RSat::TSetUpCallV6Pckg setupCallPckg(setupCall); + iSat.NotifySetUpCallPCmd(requestStatus, setupCallPckg); + const TUint8 KSetUpCallPCmdNo = 201; + + TTlv tlv; + tlv.Begin(KBerTlvProactiveSimCommandTag); + tlv.AddTag(KTlvCommandDetailsTag); + tlv.AddByte(KSetUpCallPCmdNo);//ETLV_CommandNumber + tlv.AddByte(pcmdCode); //ETLV_TypeOfCommand + tlv.AddByte(KSetUpCallDisconnectingOtherCalls); //ETLV_CommandQualifier + + tlv.AddTag(KTlvDeviceIdentityTag); + tlv.AddByte(KSim); //ETLV_SourceDeviceIdentity + tlv.AddByte(KNetwork); //ETLV_DestinationDeviceIdentity + + tlv.AddTag(KTlvAddressTag); + const TUint8 KTonNpi = 0x91; + tlv.AddByte(KTonNpi); //TON and NPI (national number that conforms to the itu telephony style of numbering) + + RBuf8 setUpCallNo; + CleanupClosePushL(setUpCallNo); + setUpCallNo.CreateL(KPhoneNumber().Length()); + setUpCallNo.Copy(KPhoneNumber); //converts from 16 to 8 bit. + + RBuf8 bcdSetUpCallNo; + CleanupClosePushL(bcdSetUpCallNo); + bcdSetUpCallNo.CreateL(KPhoneNumber().Length()); + + TSatUtility::AsciiToBCD(setUpCallNo,bcdSetUpCallNo); + tlv.AddData(bcdSetUpCallNo); + + + TDesC8* tlvDscPtr = &const_cast(tlv.End()); + TMockLtsyData1 tlvDscPack(tlvDscPtr); + data.Close(); + tlvDscPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(requestStatus.Int(),KErrNone); + ASSERT_EQUALS(setupCall.PCmdNumber(),KSetUpCallPCmdNo); + + //****************************************************************************************************** + //* At this stage the phone application/system software would attempt to make the call specified in the + //* SET UP CALL pcmd payload, first checking whether this is the emergency number (112) per ETSI TS 102 223 + //* section 6.4.13 and routing the call via the appropriate ETel API, i.e. RMobileCall::DialEmergencyCall() + //* for emergency calls and RCall::Dial() for standard ones. + //* + //* After checking for emergency numbers and against the FDN list, the LTSY uses the CreateEnvelopeInd IPC to + //* request that the CTSY constructs TLV data for an ENVELOPE (CALL CONTROL). Once this is done it passes it + //* to the LTSY with the SendEnvelopeReq(IPC). + //* + //****************************************************************************************************** + + //Generate the call + // Call control code cribbed from cctsycallcontrolfu.cpp + TInt callId = 1; + RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService; + //The fourth parameter of DriverDialCallL specifies whether this call originates from the SIM or ETel client + //In this case the call originates from the SET UP CALL proactive command so the flag is set to ETrue. + DriverDialCallL(callId, mobileService, EFalse, ETrue); + TInt hangUpCause = KErrGsmCCNormalCallClearing; // Hang up cause for normal hang up + DriverHangUpCallL(callId, hangUpCause); + // Client Side Test + + RMobileLine mobileLine; + CleanupClosePushL(mobileLine); + RMobileCall mobileCall; + CleanupClosePushL(mobileCall); + ClientDialCallL(mobileLine, mobileCall, mobileService); + TRequestStatus notifyCallStatus; + RMobileCall::TMobileCallStatus callStatus = RMobileCall::EStatusUnknown; + mobileCall.NotifyMobileCallStatusChange(notifyCallStatus, callStatus); + TRequestStatus hangupStatus; + mobileCall.HangUp(hangupStatus); + RArray expectedCallStatuses; + CleanupClosePushL(expectedCallStatuses); + expectedCallStatuses.AppendL(RMobileCall::EStatusDisconnecting); + expectedCallStatuses.AppendL(RMobileCall::EStatusIdle); + ClientWaitForCallStatusNotifications(mobileCall, notifyCallStatus, callStatus, expectedCallStatuses, KErrNone); + User::WaitForRequest(hangupStatus); + ASSERT_EQUALS(KErrNone, hangupStatus.Int()); + mobileCall.GetMobileCallStatus(callStatus); + ASSERT_EQUALS(RMobileCall::EStatusIdle, callStatus); + expectedCallStatuses.Close(); + CleanupStack::PopAndDestroy(1, &expectedCallStatuses); + + mobileCall.Close(); + mobileLine.Close(); + CleanupStack::PopAndDestroy(&mobileCall); + CleanupStack::PopAndDestroy(&mobileLine); + //********************************************************************************** + //send up the "create envelope" event which causes the ctsy to assemble the ENVELOPE (CALL CONTROL) + _LIT8(KBcc1,"asdas"); + _LIT8(KBcc2,"qwqwqw"); + const TUint8 KDcs = 56; + + TDesC8* bcc1Ptr = const_cast(&KBcc1); + TDesC8* bcc2Ptr = const_cast(&KBcc2); + TDesC8* addrPtr = &setUpCallNo; + TUint8 tag = KTlvAddressTag; + TUint8 tonNpi = KTonNpi; + TUint8 dcs = KDcs; + TMockLtsyData6 ccInfoPck(tag, bcc1Ptr, bcc2Ptr, addrPtr, tonNpi, dcs); + data.Close(); + ccInfoPck.SerialiseL(data); + + iMockLTSY.CompleteL(KMockLtsyDispatchSatCreateCallControlEnvelopeIndId,KErrNone,data); + + //********************************************************************************** + //Now send down the created envelope + tlv.Begin( KBerTlvCallControlTag ); + // Device identities + tlv.AddTag( KTlvDeviceIdentityTag ); + tlv.AddByte( KMe ); + tlv.AddByte( KSim ); + // Address + tlv.AddTag( KTlvAddressTag ); + tlv.AddByte( KTonNpi ); + tlv.AddData( bcdSetUpCallNo ); + // Optional + tlv.AddTag( KTlvCapabilityConfigurationParametersTag ); + tlv.AddData( KBcc1 ); + // Add location information data + tlv.AddTag( KTlvLocationInformationTag ); + // Append Mobile Country & Network Codes, 3 bytes + tlv.AddData( KOperatorCode ); + // Append Location Area Code (LAC) + tlv.AddByte( static_cast( KLocationAreaCode >> KShiftBitsToGetMSB ) );//msb + tlv.AddByte( static_cast( KLocationAreaCode >> KShiftBitsToGetLSB ) );//lsb + // Append Cell Id + tlv.AddByte( static_cast( KCellId >> KShiftBitsToGetMSB ) ); // msbthey + tlv.AddByte( static_cast( KCellId >> KShiftBitsToGetLSB ) ); // lsb + + tlv.AddTag( KTlvCapabilityConfigurationParametersTag ); + tlv.AddData( KBcc2 ); + + // Prepare data + TDesC8* tlvDscDes = &const_cast(tlv.End()); + TMockLtsyData1 tlvDscDesPck(tlvDscDes); + data.Close(); + tlvDscDesPck.SerialiseL(data); + + iMockLTSY.ExpectL(MLtsyDispatchSatCallAndSmsControlEnvelope::KLtsyDispatchSatCallAndSmsControlEnvelopeApiId,data); + WaitForMockLTSYTerminated(); + + //************************************************************************************ + //Now we send up the response of the call control + + tlv.Begin(0x02);//the type of request has changed (the envelope responses have a slightly different format to the rest of the data so we achieve this by passing in call control result as the top level tag) + tlv.AddTag(KTlvAddressTag); + tlv.AddByte(KTonNpi); //ton+npi + tlv.AddData(bcdSetUpCallNo); + tlv.AddTag(KTlvAlphaIdentifierTag); + + _LIT8(KAlphaId8,"Test alpha id"); + _LIT16(KAlphaId16, "Test alpha id"); + tlv.AddData(KAlphaId8()); + + tlvDscDes = &const_cast(tlv.End()); + + + TMockLtsyData1 controlPck(tlvDscDes); + data.Close(); + controlPck.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatCallControlEnvelopeResponseIndId,KErrNone,data); + + + iSat.NotifyCallControlRequest(requestStatus, iCallContainer->iCallControlPckg); + User::WaitForRequest(requestStatus); + ASSERT_EQUALS(KErrNone, requestStatus.Int()); + RSat::TAlphaIdValidity val; + iCallContainer->iCallControl.GetAlphaId(val,iCallContainer->iAlphaId); + ASSERT_TRUE(KAlphaId16() == iCallContainer->iAlphaId.iAlphaId); + + + + //************************************************************************************ + //now we need to provide the terminal response to the SET UP CALL proactive command + + //from etsi 102 223 + //6.8.9 Result data object 2 + //When the terminal issues a TERMINAL RESPONSE for a proactive command SET UP CALL which has been + //modified by call control by UICC in another type of request, it shall supply the Result data object it would have + //supplied for the proactive command equivalent to the action requested by call control, and given in the Call control + //request data element. + + RSat::TSetUpCallRspV2 setUpCallRsp; + RSat::TSetUpCallRspV2Pckg setUpCallRspPckg(setUpCallRsp); + + + setUpCallRsp.iGeneralResult = RSat::KSuccess; + setUpCallRsp.iInfoType = RSat::KNoAdditionalInfo; + setUpCallRsp.SetPCmdNumber(KSetUpCallPCmdNo); + + GenerateAndWaitForTermRspL(KSetUpCallPCmdNo,KSetUpCall,KSetUpCallDisconnectingOtherCalls,RSat::ESetUpCall,RSat::KSuccess,setUpCallRspPckg,KErrNone); + + CleanupStack::PopAndDestroy(&bcdSetUpCallNo); // data, this + CleanupStack::PopAndDestroy(&setUpCallNo); // data, this + CleanupStack::PopAndDestroy(2, this); // data, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UC0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for Timer Managment functionality +@SYMTestPriority High +@SYMTestActions Invokes Proactive command, Terminal response, Timer Expiration Envelope, (start a timer and wait for it to expire) +@SYMTestExpectedResults Pass +@SYMTestType CT + */ +void CCTsySatFU::TestUseCase0006L() + { + OpenEtelServerL(EUseExtendedError); + + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + const TUint8 KPCommandNumber = 11; + const RSat::TTimerId KTimerId = RSat::KTimer1; + + const TUint8 KTimerManagementStart = 0x00; + //others KDeactivateTimer, KGetTimerValue and 0x03 is RFU + + //create the Mock LTSY complete TLV data (a proactive command to start a timer) + TTlv proactiveCommandTlv; + + proactiveCommandTlv.Begin(KBerTlvProactiveSimCommandTag); + + proactiveCommandTlv.AddTag(KTlvCommandDetailsTag); + proactiveCommandTlv.AddByte(KPCommandNumber);//ETLV_CommandNumber + proactiveCommandTlv.AddByte(KTimerManagement); //ETLV_TypeOfCommand + proactiveCommandTlv.AddByte(KTimerManagementStart); //ETLV_CommandQualifier + + proactiveCommandTlv.AddTag(KTlvDeviceIdentityTag); + proactiveCommandTlv.AddByte(KSim); + proactiveCommandTlv.AddByte(KMe); + + proactiveCommandTlv.AddTag(KTlvTimerIdentifierTag); + proactiveCommandTlv.AddByte(KTimerId); + + proactiveCommandTlv.AddTag(KTlvTimerValueTag); + + const TUint8 KHourLSB = 0; + const TUint8 KHourMSB = 0; + + const TUint8 KMinLSB = 0; + const TUint8 KMinMSB = 0; + + const TUint8 KSecLSB = 0; + const TUint8 KSecMSB = 2; //2 seconds + + const TInt KBitsToShiftMSNibble = 4; + + proactiveCommandTlv.AddByte((KHourMSB << KBitsToShiftMSNibble) | KHourLSB); //hour + proactiveCommandTlv.AddByte((KMinMSB << KBitsToShiftMSNibble) | KMinLSB); //min + proactiveCommandTlv.AddByte((KSecMSB << KBitsToShiftMSNibble) | KSecLSB); //second + + proactiveCommandTlv.AddByte((KHourMSB << KBitsToShiftMSNibble) | KHourLSB); //hour + proactiveCommandTlv.AddByte((KMinMSB << KBitsToShiftMSNibble) | KMinLSB); //min + proactiveCommandTlv.AddByte((KSecMSB << KBitsToShiftMSNibble) | KSecLSB); //second + + TDesC8* proactiveCommandTlvPtr = &const_cast(proactiveCommandTlv.End()); + TMockLtsyData1 tlvDscPack(proactiveCommandTlvPtr); + tlvDscPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data); + + //The Terminal response generated by the CTSY (as a result of the proactive command) + + const TDesC8& KGeneralResultAddInfo = KNullDesC8; + + TTlv additionalInfoTlv; + additionalInfoTlv.AddTag(KTlvTimerIdentifierTagCRBitOn); + additionalInfoTlv.AddByte(KTimerId); + + GenerateAndWaitForTermRspL( KPCommandNumber, + KTimerManagement, + KTimerManagementStart, + RSat::ETimerMngt, + RSat::KSuccess, + KGeneralResultAddInfo, + KNullDesC8, + additionalInfoTlv.GetDataWithoutTopLevelTag(), + KErrNone); + + //Queue the expect, this is the Timer Expiration ENVELOPE command when the timer expires. + TTlv timerExpirationTlv; + timerExpirationTlv.Begin( KBerTlvTimerExpirationTag ); + // Create Device Identity TLV + // Device identity tag + timerExpirationTlv.AddTag( KTlvDeviceIdentityTag ); + // Source device identity = ME + timerExpirationTlv.AddByte(KMe); + // Destination device identity = SIM + timerExpirationTlv.AddByte(KSim); + // Value KTlvTimerIdentifierTagCRBitOn ( 0xA4 ) is added, + // because used KTlvTimerIdentifierTag ( 0x24 ) doesn't + // include comprehension bit in tag the value and it is expected + // to be present in indications and terminal responses. + timerExpirationTlv.AddTag(KTlvTimerIdentifierTagCRBitOn); + timerExpirationTlv.AddByte(KTimerId); + // Timer value in semi-octets + timerExpirationTlv.AddTag( KTlvTimerValueTag ); + timerExpirationTlv.AddByte((KHourMSB << KBitsToShiftMSNibble) | KHourLSB); //hour + timerExpirationTlv.AddByte((KMinMSB << KBitsToShiftMSNibble) | KMinLSB); //min + timerExpirationTlv.AddByte((KSecMSB << KBitsToShiftMSNibble) | KSecLSB); //second + + TDesC8* timerExpirationDscPtr = &const_cast(timerExpirationTlv.End()); + + TMockLtsyData1 timerExpirationTlvDscPack(timerExpirationDscPtr); + timerExpirationTlvDscPack.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatTimerExpirationEnvelope::KLtsyDispatchSatTimerExpirationEnvelopeApiId,data); + data.Close(); + + //wait for the timer to expire + WaitForMockLTSYTerminated(); + + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UC0007 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for Setting the polling interval and turning polling off. +@SYMTestPriority High +@SYMTestActions Invokes CTSY Internal Proactive command, Set Polling Interval, Terminal Response +@SYMTestExpectedResults Pass +@SYMTestType CT + */ +void CCTsySatFU::TestUseCase0007L() + { + + OpenEtelServerL(EUseExtendedError); + + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + /*********************************Set Polling Interval*******************************************/ + + const TUint8 KSetPollingPCmdNumber = 123; + const TUint8 KCommandQualifier = 0; //RFU (Reserved for future use) + + TTlv pollIntervalPCmdTlv; + pollIntervalPCmdTlv.Begin(KBerTlvProactiveSimCommandTag); + pollIntervalPCmdTlv.AddTag(KTlvCommandDetailsTag); + pollIntervalPCmdTlv.AddByte(KSetPollingPCmdNumber);//ETLV_CommandNumber + pollIntervalPCmdTlv.AddByte(KPollInterval); //ETLV_TypeOfCommand + pollIntervalPCmdTlv.AddByte(KCommandQualifier); //ETLV_CommandQualifier - RFU + + pollIntervalPCmdTlv.AddTag(KTlvDeviceIdentityTag); + pollIntervalPCmdTlv.AddByte(KSim); //ETLV_SourceDeviceIdentity + pollIntervalPCmdTlv.AddByte(KMe); //ETLV_DestinationDeviceIdentity + + const TUint8 KTimeUint = KSeconds; //seconds + const TUint8 KTimeInterval = 5; //5 of them + + pollIntervalPCmdTlv.AddTag(KTlvDurationTag); + pollIntervalPCmdTlv.AddByte(KTimeUint); + pollIntervalPCmdTlv.AddByte(KTimeInterval); + + TDesC8* pollIntervalPCmdTlvDscPtr = &const_cast(pollIntervalPCmdTlv.End()); + + //the proactive command (LTSY -> CTSY) + TMockLtsyData1 pollIntervalPCmdPack(pollIntervalPCmdTlvDscPtr); + pollIntervalPCmdPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data); + data.Close(); + + TUint8 pollInterval = KTimeInterval; + + //set polling request (CTSY -> LTSY) + TMockLtsyData1 setPollIntervalRequestPack(pollInterval); + setPollIntervalRequestPack.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatSetPollingInterval::KLtsyDispatchSatSetPollingIntervalApiId,data); + data.Close(); + + //set polling complete (LTSY -> CTSY) + TMockLtsyData1 setPollIntervalCompletePack(pollInterval); + setPollIntervalCompletePack.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatSetPollingInterval::KLtsyDispatchSatSetPollingIntervalApiId,KErrNone,data); + data.Close(); + + //terminal response for inital proactive command request (CTSY -> LTSY) + RSat::TPCmdResult pollIntervalGeneralResult = RSat::KSuccess; + const TDesC8& KGeneralResultAddInfo = KNullDesC8; + + TTlv pollIntervalAdditionalInfoTlv; + pollIntervalAdditionalInfoTlv.AddTag(KTlvDurationTag); + pollIntervalAdditionalInfoTlv.AddByte(KSeconds); + pollIntervalAdditionalInfoTlv.AddByte(pollInterval); + + GenerateAndWaitForTermRspL( KSetPollingPCmdNumber, + KPollInterval, + KCommandQualifier, + RSat::EPollingInterval, + pollIntervalGeneralResult, + KGeneralResultAddInfo, + KNullDesC8, + pollIntervalAdditionalInfoTlv.GetDataWithoutTopLevelTag(), + KErrNone); + + /*********************************Turn Polling Off*******************************************/ + + const TUint8 KPollingOffPCmdNumber = 125; + + //proactive command to set Polling off (LTSY -> CTSY) + TTlv pollingOffPCmdTlv; + pollingOffPCmdTlv.Begin(KBerTlvProactiveSimCommandTag); + pollingOffPCmdTlv.AddTag(KTlvCommandDetailsTag); + pollingOffPCmdTlv.AddByte(KPollingOffPCmdNumber);//ETLV_CommandNumber + pollingOffPCmdTlv.AddByte(KPollingOff); //ETLV_TypeOfCommand + pollingOffPCmdTlv.AddByte(KCommandQualifier); //ETLV_CommandQualifier - RFU + + pollingOffPCmdTlv.AddTag(KTlvDeviceIdentityTag); + pollingOffPCmdTlv.AddByte(KSim); //ETLV_SourceDeviceIdentity + pollingOffPCmdTlv.AddByte(KMe); //ETLV_DestinationDeviceIdentity + + TDesC8* pollingOffPCmdTlvDscPtr = &const_cast(pollingOffPCmdTlv.End()); + + TMockLtsyData1 pollingOffPCmdPack(pollingOffPCmdTlvDscPtr); + pollingOffPCmdPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data); + data.Close(); + + //set polling request (CTSY -> LTSY) + TUint8 pollingOffInterval = 0; + TMockLtsyData1 setPollingOffRequestPack(pollingOffInterval); + setPollingOffRequestPack.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatSetPollingInterval::KLtsyDispatchSatSetPollingIntervalApiId,data); + data.Close(); + + //set polling complete (LTSY -> CTSY) + TMockLtsyData1 setPollingOffCompletePack(pollingOffInterval); + setPollingOffCompletePack.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatSetPollingInterval::KLtsyDispatchSatSetPollingIntervalApiId,KErrNone,data); + data.Close(); + + + //terminal response for inital proactive command request (CTSY -> LTSY) + RSat::TPCmdResult pollingOffGeneralResult = RSat::KSuccess; + + GenerateAndWaitForTermRspL(KPollingOffPCmdNumber,KPollingOff,KCommandQualifier,RSat::EPollingOff,pollingOffGeneralResult,KNullDesC8,KErrNone); + + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UC0008 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY Mo Short Message Control +@SYMTestPriority High +@SYMTestActions Send up a "send sms" proactive command, send the SMS via RSat, then handle the mo sms control envelope +and response, and complete a terminal response +@SYMTestExpectedResults Pass +@SYMTestType CT + */ +void CCTsySatFU::TestUseCase0008L() + { + OpenEtelServerL(EUseExtendedError); + + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(KSmsMoControlEnabled); + + //setup local info as this is appended to the MO SHORT MESSAGE CONTROL ENVELOPE + SetupLocalInfoL(KLocationAreaCode,KCellId,KOperatorCode,KLocationStatusNormalService); + + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + TRequestStatus sendMessageReqStatus; + TRequestStatus moSmControlRequestReqStatus; + + //send a Sm proactive command + TUint8 pcmdCode = KSendShortMessage; + TMockLtsyData1 expPCmdNotificationLtsyData(pcmdCode); + expPCmdNotificationLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId, data ); + expPCmdNotificationLtsyData.Close(); + + + const TUint8 KPCmdNumber = 123; + const TUint8 KCommandQualifier = 0; //0 = packing not required, 1 = SMS packing by the ME required. + + TTlv tlv; + tlv.Begin(KBerTlvProactiveSimCommandTag); + + tlv.AddTag(KTlvCommandDetailsTag); + tlv.AddByte(KPCmdNumber);//ETLV_CommandNumber + tlv.AddByte(KSendShortMessage); //ETLV_TypeOfCommand + tlv.AddByte(KCommandQualifier); // 0 = packing not required, 1 = SMS packing by the ME required. + + tlv.AddTag(KTlvDeviceIdentityTag); + tlv.AddByte(KSim); + tlv.AddByte(KMe); + + _LIT8(KAlphaId8,"Text To Display"); + _LIT16(KAlphaId16,"Text To Display"); + tlv.AddTag(KTlvAlphaIdentifierTag); + tlv.AddData(KAlphaId8); + + tlv.AddTag(KTlvAddressTag); + tlv.AddByte(0); //Ton NPI + tlv.AddData(_L8("Number")); + + + TUint8 tpduProtocolByte = 0; + + tpduProtocolByte |= 0x01 << 0;//TP Message Type Indicator, bit 0-1 - SMS SUBMIT + tpduProtocolByte |= 0x00 << 2;//TP Reject Duplicates, bit 2 - Instruct the SC to accept an SMS SUBMIT for an SM still held in the + //SC which has the same TP MR and the same TP DA as a previously submitted SM from the same OA. + tpduProtocolByte |= 0x00 << 3; //TP Validity Period Format, bit 3-4 - TP VP field not present + tpduProtocolByte |= 0x00 << 5; //TP Status Report Request, bit 5 - A status report is not requested + tpduProtocolByte |= 0x00 << 6; //TP User Data Header Indicator, bit 6 - The TP UD field contains only the short message + tpduProtocolByte |= 0x00 << 7; //TP Reply Path, bit 7- TP Reply Path parameter is not set in this SMS SUBMIT/DELIVER + + const TUint8 KProtocolIdentifier = 0x7F; //SmsTpduProtcolIdUSimDdl Parameters(1)+TP-OA(min 2)+TP-PID(1)+DCS(1)+TP-SCTS(7)+TP-UDL(2)+TP-UD(?) + const TUint8 KDataCodingScheme = 0x02; //TP Data Coding Scheme (TP DCS) + + TTpdu tpdu; + tpdu.Append(tpduProtocolByte); + + _LIT8(KOriginatingAddress,"1234567"); + tpdu.Append(KOriginatingAddress().Length() * 2); //Number of octets + tpdu.Append(0); //Type of address + tpdu.Append(KOriginatingAddress()); + tpdu.Append(KProtocolIdentifier); //TP Protocol Identifier + tpdu.Append(KDataCodingScheme); //TP Data Coding Scheme (TP DCS) + tpdu.Append(_L8("1234567")); //TP Service Centre Time Stamp + + _LIT8(KUserData,"User Data"); + tpdu.Append(KUserData().Length()); //TP User Data Length + tpdu.Append(KUserData()); //TP User Data + + tlv.AddTag(KTlvSmsTpduTag); + tlv.AddData(tpdu); + + TDesC8* tlvDscPtr = &const_cast(tlv.End()); + TMockLtsyData1 tlvDscPack(tlvDscPtr); + tlvDscPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data); + data.Close(); + + RSat::TSendSmV1 sendSm; + RSat::TSendSmV1Pckg sendSmPckg(sendSm); + iSat.NotifySendSmPCmd(reqStatus,sendSmPckg); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),KErrNone); + ASSERT_EQUALS(sendSm.PCmdNumber(),KPCmdNumber); + ASSERT_EQUALS(sendSm.iAlphaId.iStatus,RSat::EAlphaIdProvided); + ASSERT_TRUE(sendSm.iAlphaId.iAlphaId == KAlphaId16); + ASSERT_TRUE(sendSm.iSmsTpdu == tpdu); + + _LIT8(KServiceCentreNumber,"123456789"); + + const RMobilePhone::TMobileTON KMobilePhoneTon = RMobilePhone::ENetworkSpecificNumber; + const RSat::TTypeOfNumber KSatTon = RSat::ENetworkSpecificNumber; + const RMobilePhone::TMobileNPI KMobilePhoneNpi = RMobilePhone::EPrivateNumberPlan; + const RSat::TNumberingPlan KSatNpi = RSat::EPrivateNumberPlan; + + RMobileSmsMessaging::TMobileSmsSendAttributesV1 smsSendAttributes; + smsSendAttributes.iFlags = (RMobileSmsMessaging::KSmsDataFormat | RMobileSmsMessaging::KGsmServiceCentre | RMobileSmsMessaging::KMoreToSend); + smsSendAttributes.iDataFormat = RMobileSmsMessaging::EFormatGsmTpdu; + smsSendAttributes.iGsmServiceCentre.iTelNumber.Copy(KServiceCentreNumber); + smsSendAttributes.iGsmServiceCentre.iTypeOfNumber = KMobilePhoneTon; + smsSendAttributes.iGsmServiceCentre.iNumberPlan = KMobilePhoneNpi; + smsSendAttributes.iMore = EFalse; //set False in CSatTsy::SendMessageNoLogging + + TDesC8* tpduPtr = &tpdu; + TMockLtsyData4< TDesC8*, + RMobileSmsMessaging::TMobileSmsDataFormat, + RMobilePhone::TMobileAddress, + TBool + > sendMessagePack(tpduPtr, smsSendAttributes.iDataFormat, smsSendAttributes.iGsmServiceCentre, smsSendAttributes.iMore); + sendMessagePack.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSmsSendSatSms::KLtsyDispatchSmsSendSatSmsApiId,data); + data.Close(); + + RSat::TSatSmsV1 satSms; + RSat::TSatSmsV1Pckg satSmsPckg(satSms); + satSms.iBuf = sendSm.iSmsTpdu; + satSms.iServiceCenter.iTelNumber.Copy(KServiceCentreNumber); + satSms.iServiceCenter.iTypeOfNumber = KSatTon; + satSms.iServiceCenter.iNumberPlan = KSatNpi; + + RSat::TMoSmControlV1 moSmsControl; + RSat::TMoSmControlV1Pckg moSmsControlPckg(moSmsControl); + iSat.NotifyMoSmControlRequest(moSmControlRequestReqStatus,moSmsControlPckg); + + + TUint16 msgRef; + iSat.SendMessageNoLogging(sendMessageReqStatus,satSmsPckg,msgRef); + + + //indicator up from the CTSY to create a Mo Short Message Envelope + //LTSY -> CTSY + + //Type of Number (TON) and numbering plan identification (NPI). + //MSB - 1, Type of Number - 011 (Network Specific Number), Numbering Plan - 1001 (Private numbering plan) 10111001 = B9 Hex + const TUint8 KTonAndNpi = TonAndNpi(RMobilePhone::ENetworkSpecificNumber,RMobilePhone::EPrivateNumberPlan); + + RBuf8 rpDestinationAddress; + CleanupClosePushL(rpDestinationAddress); + rpDestinationAddress.CreateL(KAddrMaxLength); + rpDestinationAddress.Append(KTonAndNpi); //TON & NPI + rpDestinationAddress.Append(_L8("1234567")); //dummy data not EF(ADN) encoded data + + RBuf8 tpDestinationAddress; + CleanupClosePushL(tpDestinationAddress); + tpDestinationAddress.CreateL(KAddrMaxLength); + tpDestinationAddress.Append(KTonAndNpi); //TON & NPI + tpDestinationAddress.Append(_L8("7654321")); //dummy data not EF(ADN) encoded data + + TDesC8* rpDestinationAddressPtr = &rpDestinationAddress; + TDesC8* tpDestinationAddressPtr = &tpDestinationAddress; + + TMockLtsyData2 createMoSmsControlEnvelopPack(rpDestinationAddressPtr,tpDestinationAddressPtr); + + createMoSmsControlEnvelopPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatCreateMoSmControlEnvelopeIndId, KErrNone, data); + data.Close(); + + //constructed envelope by the CTSY send down (see 3GPP TS 11.14 - Structure of ENVELOPE (MO SHORT MESSAGE CONTROL)) + //CTSY -> LTSY + TTlv moSmControlEnvelope; + + moSmControlEnvelope.Begin(KBerTlvMoShortMessageControlTag); + //device identities + moSmControlEnvelope.AddTag(KTlvDeviceIdentityTag); + moSmControlEnvelope.AddByte(KMe); + moSmControlEnvelope.AddByte(KSim); + // Address Data object 1 + moSmControlEnvelope.AddTag(KTlvAddressTag); + moSmControlEnvelope.AddData(rpDestinationAddress); + // Address Data object 2 + moSmControlEnvelope.AddTag(KTlvAddressTag); + moSmControlEnvelope.AddData(tpDestinationAddress); + + // Add location information data, start with the tag + moSmControlEnvelope.AddTag(KTlvLocationInformationTag); + // Append Mobile Country & Network Codes, 3 bytes + + moSmControlEnvelope.AddData(KOperatorCode); + // Append Location Area Code (LAC) + moSmControlEnvelope.AddByte(KLocationAreaCode >> KShiftBitsToGetMSB);//msb + moSmControlEnvelope.AddByte(KLocationAreaCode & 0x00FF);//lsb + // Append Cell Id + moSmControlEnvelope.AddByte(KCellId >> KShiftBitsToGetMSB); //msb + moSmControlEnvelope.AddByte(KCellId & 0x00FF); //lsb + + // Prepare data + TDesC8* moSmControlEnvelopeTlvPtr = &const_cast(moSmControlEnvelope.End()); + + TMockLtsyData1 moSmsControlEnvelopePack(moSmControlEnvelopeTlvPtr); + + moSmsControlEnvelopePack.SerialiseL(data); + + iMockLTSY.ExpectL(MLtsyDispatchSatCallAndSmsControlEnvelope::KLtsyDispatchSatCallAndSmsControlEnvelopeApiId,data); + data.Close(); + + WaitForMockLTSYTerminated(); + + + //Response from the SIM + //LTSY -> CTSY + + TTlv moSmsControlResponseTlv; + + TUint8 result = KMoSmCtrlResultAllowed; + _LIT8(KAlphaIdData8,"Sending an SMS"); + _LIT16(KAlphaIdData16,"Sending an SMS"); + + moSmsControlResponseTlv.Begin(result); + + moSmsControlResponseTlv.AddTag(KTlvAddressTag); + moSmsControlResponseTlv.AddData(rpDestinationAddress); + + moSmsControlResponseTlv.AddTag(KTlvAddressTag); + moSmsControlResponseTlv.AddData(tpDestinationAddress); + + moSmsControlResponseTlv.AddTag(KTlvAlphaIdentifierTag); + moSmsControlResponseTlv.AddData(KAlphaIdData8); + + TDesC8* moSmsControlResponseTlvDesPtr = &const_cast( moSmsControlResponseTlv.End()); + + TMockLtsyData1 moSmsControlResponsePack(moSmsControlResponseTlvDesPtr); + moSmsControlResponsePack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatMoSmControlEnvelopeResponseIndId,KErrNone,data); + data.Close(); + + TMockLtsyData3 moSmControlResponseDataPack(result,rpDestinationAddressPtr,tpDestinationAddressPtr); + moSmControlResponseDataPack.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatSmControlResponseData::KLtsyDispatchSatSmControlResponseDataApiId,data); + data.Close(); + + User::WaitForRequest(moSmControlRequestReqStatus); + ASSERT_EQUALS(moSmControlRequestReqStatus.Int(),KErrNone); + ASSERT_EQUALS(moSmsControl.iResult,RSat::EAllowedNoModification); + ASSERT_EQUALS(moSmsControl.iAlphaId.iStatus,RSat::EAlphaIdProvided); + ASSERT_TRUE(moSmsControl.iAlphaId.iAlphaId == KAlphaIdData16); + + //LTSY -> CTSY the SMS has been sent + iMockLTSY.CompleteL(MLtsyDispatchSmsSendSatSms::KLtsyDispatchSmsSendSatSmsApiId,KErrNone); + User::WaitForRequest(sendMessageReqStatus); + ASSERT_EQUALS(sendMessageReqStatus.Int(),KErrNone); + + //generate the terminal response to the send sms proactive command. + RSat::TSendSmRspV1 sendSmRsp; + sendSmRsp.iGeneralResult = RSat::KSuccess; + sendSmRsp.iInfoType = RSat::KNoAdditionalInfo; + sendSmRsp.SetPCmdNumber(KPCmdNumber); + RSat::TSendSmRspV1Pckg sendSmRspPckg(sendSmRsp); + + GenerateAndWaitForTermRspL(KPCmdNumber,KSendShortMessage,KCommandQualifier,RSat::ESendSm,RSat::KSuccess,sendSmRspPckg,KErrNone); + + CleanupStack::PopAndDestroy(&tpDestinationAddress); + CleanupStack::PopAndDestroy(&rpDestinationAddress); + + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UC0009 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for Sms PP & Cell Broadcast Data Download +@SYMTestPriority High +@SYMTestActions Invokes CTSY Internal, create both SmsPP and Cell Broadcast envelopes +@SYMTestExpectedResults Pass +@SYMTestType CT + */ +void CCTsySatFU::TestUseCase0009L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(KSmsPpDownloadEnabled); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + /*********************************SMS PP Download********************************/ + + //test the case when SMS PP Data Download is allocated in NAA (KSmsPpDownloadEnabled) + + //MSB - 1, Type of Number - 011 (Network Specific Number), Numbering Plan - 1001 (Private numbering plan) + //10111001 = B9 Hex + + RMobilePhone::TMobileTON KTon = RMobilePhone::ENetworkSpecificNumber; + RMobilePhone::TMobileNPI KNpi = RMobilePhone::EPrivateNumberPlan; + + const TUint8 KTonAndNpi = TonAndNpi(KTon,KNpi); //Type of Number (TON) and numbering plan identification (NPI). + + RBuf8 rpOriginatingAddress; + CleanupClosePushL(rpOriginatingAddress); + rpOriginatingAddress.CreateL(KAddrMaxLength); + rpOriginatingAddress.Append(KTonAndNpi); //TON & NPI + _LIT8(KRpNumber,"1234567"); + rpOriginatingAddress.Append(KRpNumber); //dummy data not EF(ADN) encoded data + + RBuf8 smsDeliveryTpdu; + CleanupClosePushL(smsDeliveryTpdu); + smsDeliveryTpdu.CreateL(RMobileSmsMessaging::KGsmTpduSize); + + TUint8 tpduProtocolByte = 0; + + tpduProtocolByte |= 0x01 << 0;//TP Message Type Indicator, bit 0-1 - SMS SUBMIT + tpduProtocolByte |= 0x00 << 2;//TP Reject Duplicates, bit 2 - Instruct the SC to accept an SMS SUBMIT for an SM still held in the + //SC which has the same TP MR and the same TP DA as a previously submitted SM from the same OA. + tpduProtocolByte |= 0x00 << 3; //TP Validity Period Format, bit 3-4 - TP VP field not present + tpduProtocolByte |= 0x00 << 5; //TP Status Report Request, bit 5 - A status report is not requested + tpduProtocolByte |= 0x00 << 6; //TP User Data Header Indicator, bit 6 - The TP UD field contains only the short message + tpduProtocolByte |= 0x00 << 7; //TP Reply Path, bit 7- TP Reply Path parameter is not set in this SMS SUBMIT/DELIVER + + const TUint8 KProtocolIdentifier = 0x7F; //SmsTpduProtcolIdUSimDdl Parameters(1)+TP-OA(min 2)+TP-PID(1)+DCS(1)+TP-SCTS(7)+TP-UDL(2)+TP-UD(?) + const TUint8 KDataCodingScheme = 0x02; //TP Data Coding Scheme (TP DCS) + + smsDeliveryTpdu.Append(tpduProtocolByte); + + _LIT8(KOriginatingAddress,"1234567"); + smsDeliveryTpdu.Append(KOriginatingAddress().Length() * 2); //Number of octets + smsDeliveryTpdu.Append(0); //Type of address + smsDeliveryTpdu.Append(KOriginatingAddress()); + smsDeliveryTpdu.Append(KProtocolIdentifier); //TP Protocol Identifier + smsDeliveryTpdu.Append(KDataCodingScheme); //TP Data Coding Scheme (TP DCS) + smsDeliveryTpdu.Append(_L8("1234567")); //TP Service Centre Time Stamp + + _LIT8(KUserData,"User Data"); + smsDeliveryTpdu.Append(KUserData().Length()); //TP User Data Length + smsDeliveryTpdu.Append(KUserData()); //TP User Data + + + TDesC8* rpOriginatingAddressPtr = &rpOriginatingAddress; + TDesC8* smsDeliveryTpduPtr = &smsDeliveryTpdu; + + //Indicator of a Sms-Point to Point-Download - LTSY -> CTSY + TMockLtsyData2 smsPpDatadownloadIndDataPack(rpOriginatingAddressPtr,smsDeliveryTpduPtr); + smsPpDatadownloadIndDataPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatCreateSmsPpDownloadEnvelopeIndId,KErrNone,data); + data.Close(); + + TTlv smsPpDownloadEnvelope; + smsPpDownloadEnvelope.Begin(KBerTlvSmsPpDownloadTag); + smsPpDownloadEnvelope.AddTag(KTlvDeviceIdentityTag); + smsPpDownloadEnvelope.AddByte(KNetwork); + smsPpDownloadEnvelope.AddByte(KSim); + smsPpDownloadEnvelope.AddTag(KTlvAddressTag); + smsPpDownloadEnvelope.AddData(rpOriginatingAddress); + smsPpDownloadEnvelope.AddTag(KTlvSmsTpduTag ); + smsPpDownloadEnvelope.AddData(smsDeliveryTpdu); + + // Prepare data + TDesC8* smsPpDownloadEnvelopeTlv = &const_cast(smsPpDownloadEnvelope.End()); + + //handle the envelope as a result of the Indicator CTSY -> LTSY + TMockLtsyData1 smsPpDdlExpectDataPack(smsPpDownloadEnvelopeTlv); + smsPpDdlExpectDataPack.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatSmsPpDownloadEnvelope::KLtsyDispatchSatSmsPpDownloadEnvelopeApiId,data,KErrNone); + data.Close(); + + WaitForMockLTSYTerminated(); + + //test the case when SMS PP Data Download is not allocated in NAA + + //re-open RSat with Sms PP Download Disabled + iSat.Close(); + OpenSatL(); //KSmsPpDownloadEnabled - Disabled + + //Indicator of a Sms-Point to Point-Download - LTSY -> CTSY + smsPpDatadownloadIndDataPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatCreateSmsPpDownloadEnvelopeIndId,KErrNone,data); + data.Close(); + + + RMobileSmsStore::TMobileGsmSmsEntryV1 mobileGsmSmsEntry; + mobileGsmSmsEntry.iIndex = -1; //-1 means 1st free slot. See Etel MM API Specification, 8.1.4 Write Entry. + mobileGsmSmsEntry.iServiceCentre.iTypeOfNumber = KTon; + mobileGsmSmsEntry.iServiceCentre.iNumberPlan = KNpi; + + TBuf8 address8; + TPtrC8 rpNumber(KRpNumber); + TSatUtility::BCDToAscii(rpNumber,address8); + + for(TInt i = 0; i < address8.Length(); ++i) + { + mobileGsmSmsEntry.iServiceCentre.iTelNumber.Append(address8[i]); + } + + mobileGsmSmsEntry.iMsgData.Copy(smsDeliveryTpdu); + + + //the request to do a sms store (CTSY->LTSY) + TMockLtsyData1 mobileGsmSmsEntryDataPack(mobileGsmSmsEntry); + mobileGsmSmsEntryDataPack.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId,data,KErrNone); + data.Close(); + + //the complete to the sms stote (LTSY -> CTSY) + TInt location = 100; + TBool receivedClass2ToBeResent = ETrue; + TMockLtsyData2 smsWriteEntryCompPack(location, receivedClass2ToBeResent); + smsWriteEntryCompPack.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchPhonebookSmsStoreWriteEntry::KLtsyDispatchPhonebookSmsStoreWriteEntryApiId,KErrNone, data); + data.Close(); + + WaitForMockLTSYTerminated(); + + + //Indicator to create the Sms Delivery Report + //LTSY -> CTSY + iMockLTSY.CompleteL(KMockLtsyDispatchSatCreateSmsDeliveryReportIndId,KErrNone); + + + RBuf8 smsDeliveryReportTpdu; + CleanupClosePushL(smsDeliveryReportTpdu); + smsDeliveryReportTpdu.CreateL(RMobileSmsMessaging::KGsmTpduSize); + + smsDeliveryReportTpdu.Append(tpduProtocolByte); //TP-parameters + smsDeliveryReportTpdu.Append(0x07); //TP-Parameter-Indicator -KAllOptParamsPresent + smsDeliveryReportTpdu.Append(KProtocolIdentifier); //TP-Protocol-Identifier + smsDeliveryReportTpdu.Append(KDataCodingScheme); //TP-Data-Coding-Scheme + smsDeliveryReportTpdu.Append(KUserData().Length()); //TP User Data Length + smsDeliveryReportTpdu.Append(KUserData()); //TP User Data + + TDesC8* smsDeliveryReportTpduPtr = &smsDeliveryReportTpdu; + + //The Sms Delivery report expect Tpdu as a result from the indicator + //CTSY -> LTSY + TMockLtsyData1 smsDeliveryReportExpectDataPack(smsDeliveryReportTpduPtr); + smsDeliveryReportExpectDataPack.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatSmsDeliverReport::KLtsyDispatchSatSmsDeliverReportApiId,data,KErrNone); + data.Close(); + + //no associated complete to MLtsyDispatchSatSmsDeliverReport::KLtsyDispatchSatSmsDeliverReportApiId + WaitForMockLTSYTerminated(); + + /*********************************Cell Broadcast********************************/ + RBuf8 cellBroadcastPage; + CleanupClosePushL(cellBroadcastPage); + + _LIT8(KCellBroadCastPageData,"Page Data"); + cellBroadcastPage.CreateL(92/*KCbsMsgMaxLength*/); + cellBroadcastPage.Append(KCellBroadCastPageData); + + TDesC8* cellBroadcastPagePtr = &cellBroadcastPage; + TMockLtsyData1 cellBroadcastCompleteLtsyData(cellBroadcastPagePtr); + cellBroadcastCompleteLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatCreateCellBroadcastEnvelopeIndId, KErrNone, data); + data.Close(); + + + TTlv cellBroadcastEnvelope; + // Tag + cellBroadcastEnvelope.Begin(KBerTlvCellBroadcastTag); + // Device identities + cellBroadcastEnvelope.AddTag(KTlvDeviceIdentityTag); + cellBroadcastEnvelope.AddByte(KNetwork); + cellBroadcastEnvelope.AddByte(KSim); + // Cell broadcast page + cellBroadcastEnvelope.AddTag(KTlvCellBroadcastPageTag); + cellBroadcastEnvelope.AddData(KCellBroadCastPageData); + // Prepare data + + // Prepare data + TDesC8* cellBroadcastEnvelopePtr = &const_cast(cellBroadcastEnvelope.End()); + + TMockLtsyData1 cellBroadcastExpLtsyData(cellBroadcastEnvelopePtr); + cellBroadcastExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatCellBroadcastEnvelope::KLtsyDispatchSatCellBroadcastEnvelopeApiId,data); + data.Close(); + + WaitForMockLTSYTerminated(); + + CleanupStack::PopAndDestroy(&cellBroadcastPage); + CleanupStack::PopAndDestroy(&smsDeliveryReportTpdu); + CleanupStack::PopAndDestroy(&smsDeliveryTpdu); + CleanupStack::PopAndDestroy(&rpOriginatingAddress); + + CleanupStack::PopAndDestroy(2, this); // data, this + } + +/* +@SYMTestCaseID BA-CTSYD-DIS-SAT-UC0010 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test +@SYMTestPriority High +@SYMTestActions Testing of Refresh Commands +@SYMTestExpectedResults Pass +@SYMTestType CT + */ +void CCTsySatFU::TestUseCase0010L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + const TUint8 KPCmdNumber = 101; + const TUint8 KCommandQualifier = KSimInitFullFileChangeNotification; //zero is NAA Initialization and Full File Change Notification + + RefreshNoTerminalRspL(KPCmdNumber, KCommandQualifier, KErrNone); + + //Do the Client side refresh + + + //once finished generate the Terminal response + + RSat::TRefreshRspV1 refreshTerminalRsp; + refreshTerminalRsp.iGeneralResult = RSat::KSuccess; + refreshTerminalRsp.iInfoType = RSat::KNoAdditionalInfo; + refreshTerminalRsp.iAdditionalInfo = KNullDesC; + refreshTerminalRsp.SetPCmdNumber(KPCmdNumber); + + RSat::TRefreshRspV1Pckg refreshTerminalRspPckg(refreshTerminalRsp); + + GenerateAndWaitForTermRspL(KPCmdNumber,KRefresh,KCommandQualifier,RSat::ERefresh,RSat::KSuccess,refreshTerminalRspPckg,KErrNone); + + AssertMockLtsyStatusL(); + + //for a coverage test complete MLtsyDispatchSatTerminalRsp::KLtsyDispatchSatTerminalRspApiId with an error + RefreshNoTerminalRspL(KPCmdNumber, KCommandQualifier, KErrNone); + GenerateAndWaitForTermRspL(KPCmdNumber,KRefresh,KCommandQualifier,RSat::ERefresh,RSat::KSuccess,refreshTerminalRspPckg,KErrGeneral); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(this); + } + +// +// Other unit tests +// + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0001 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for notify local info Proactive Command sequence +@SYMTestPriority High +@SYMTestActions Invokes PROVIDE LOCAL INFO proactive command, RSat::NotifyLocalInfoPCmd +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySatFU::TestUnit0001L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + RBuf8 data; + CleanupClosePushL(data); + + // + //First provide local info (langauge) - this one gets sent up to the RSat client to deal with + + TUint8 pcmdCode = KProvideLocalInformation; + TMockLtsyData1 expLtsyData(pcmdCode); + + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,data); + data.Close(); + + + const TUint8 KPCmdNumber = 101; + + TTlv tlv; + tlv.Begin(KBerTlvProactiveSimCommandTag); + tlv.AddTag(KTlvCommandDetailsTag); + tlv.AddByte(KPCmdNumber);//ETLV_CommandNumber + tlv.AddByte(KProvideLocalInformation); //ETLV_TypeOfCommand + tlv.AddByte(RSat::KProvideLocalInfoLanguage);//ETLV_CommandQualifier / KCommandQualifier + tlv.AddTag(KTlvDeviceIdentityTag); + tlv.AddByte(KSim);//ETLV_SourceDeviceIdentity + tlv.AddByte(KMe); + TDesC8* tlvDscPtr = &const_cast(tlv.End()); + TMockLtsyData1 tlvDscPack(tlvDscPtr); + tlvDscPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data); + + data.Close(); + + TUint16 locationAreaCode = KLocationAreaCode; + TUint16 cellId = KCellId; + TBuf8 operatorCode(KOperatorCode); + TDesC8* opCodePtr = &operatorCode; + TMockLtsyData3 localInfoPCmdDataPack(locationAreaCode,cellId,opCodePtr); + localInfoPCmdDataPack.SerialiseL(data); + + RSat::TLocalInfoV3 localInfo; + RSat::TLocalInfoV3Pckg localInfoPck(localInfo); + localInfo.iInfoType = RSat::KProvideLocalInfo; + + TRequestStatus stat; + iSat.NotifyLocalInfoPCmd(stat, localInfoPck); + User::WaitForRequest(stat); + ASSERT_EQUALS(stat.Int(),KErrNone); + ASSERT_EQUALS(localInfo.PCmdNumber(),KPCmdNumber); + ASSERT_EQUALS(localInfo.iDevideId,RSat::KUICC); + ASSERT_EQUALS(localInfo.iInfoType,RSat::KProvideLocalInfoLanguage); + + + //Now send the terminal response + + _LIT(KTermRespLangCode,"EN"); //language code + + TTlv termRespAddInfo; + termRespAddInfo.AddTag( KTlvLanguageTag ); + TBuf8<2> character; + TSatUtility::Copy16to8LE( KTermRespLangCode, character); + termRespAddInfo.AddData( character ); + TPtrC8 termRespAddInfoDes= termRespAddInfo.GetDataWithoutTopLevelTag(); + + RSat::TLocalInfoRspV3 resp; + RSat::TLocalInfoRspV3Pckg respPck(resp); + resp.iGeneralResult = RSat::KSuccess; + //resp.iInfoType = RSat::KLocalInformation; + resp.iInfoType = RSat::KProvideLocalInfoLanguage; + resp.iAdditionalInfo = KTermRespLangCode; //language code + resp.SetPCmdNumber(KPCmdNumber); + + const TDesC8& KGeneralResultAddInfo = KNullDesC8; + + GenerateAndWaitForTermRspL( KPCmdNumber, + KProvideLocalInformation, + RSat::KProvideLocalInfoLanguage, + RSat::ELocalInfo, + RSat::KSuccess, + KGeneralResultAddInfo, + respPck, + termRespAddInfoDes, + KErrNone); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, this); // data, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0002 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for notify of a Access Technology change +@SYMTestPriority High +@SYMTestActions Invokes RSat::EventDownload, CallbackSatAccessTechnologyChangeInd +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySatFU::TestUnit0002L() + { + OpenEtelServerL(EUseExtendedError); + + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + const TUint8 KPCmdNumber = 123; + + SetupEventListL(KPCmdNumber,KEventAccessTechnologyChange); + + TUint8 currentAccessTechnology = 0x06; //i.e. TIA/EIA/IS-2000; + + //MockLTSY complete, an access technology change up from the LTSY to the CTSY + TMockLtsyData1 accTechPack(currentAccessTechnology); + accTechPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatAccessTechnologyChangeIndId, KErrNone, data); + data.Close(); + + //MockLTSY expect, the CTSY sends down a Event Download to the LTSY + + // Create envelope + TTlv envelope; + envelope.Begin(KBerTlvEventDownloadTag); + // Event list + envelope.AddTag(KTlvEventListTag); + envelope.AddByte(KEventAccessTechnologyChange); + // Device identities + envelope.AddTag(KTlvDeviceIdentityTag); + envelope.AddByte(KMe); + envelope.AddByte(KSim); + // channel status + envelope.AddTag(KTlvAccessTechnologyTag); + envelope.AddByte(currentAccessTechnology); + + // Prepare data + + WaitForEventDownloadL(RSat::KAccessTechnologyChange,envelope.End()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0003 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc tests EVENT DOWNLOAD (LOCATION STATUS) and (via SET UP EVENT LIST pcmd) +@SYMTestPriority High +@SYMTestActions Invokes RSat::EventDownload, CallbackSatLocationStatusInd +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySatFU::TestUnit0003L() + { + OpenEtelServerL(EUseExtendedError); + + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + const TUint8 KPCmdNumber = 123; + + SetupEventListL(KPCmdNumber,KEventLocationStatus); + + + //first scenario is that there is no location service available. + + TUint8 locationStatus = KLocationStatusNoService; + _LIT8(KEmptyOpCode,""); + TDesC8* operatorCode=&const_cast(KEmptyOpCode()); + TUint16 locationAreaCode = 0; + TUint16 cellId = 0; + TMockLtsyData4 lcnStat(locationStatus,operatorCode,locationAreaCode,cellId); + data.Close(); + lcnStat.SerialiseL(data); + + iMockLTSY.CompleteL(KMockLtsyDispatchSatLocationStatusIndId,KErrNone,data); + + + // Create envelope + TTlv envelope; + envelope.Begin(KBerTlvEventDownloadTag); + // Event list + envelope.AddTag(KTlvEventListTag); + envelope.AddByte(KEventLocationStatus); + // Device identities + envelope.AddTag(KTlvDeviceIdentityTag); + envelope.AddByte(KMe); + envelope.AddByte(KSim); + // location status + envelope.AddTag(KTlvLocationStatusTag); + envelope.AddByte(locationStatus); + + WaitForEventDownloadL(RSat::KLocationStatus,envelope.End()); + + //second scenario is that location status IS available + + locationStatus = KLocationStatusNormalService; + + _LIT8(KNonEmptyOperator,"gb"); + operatorCode = &const_cast(KNonEmptyOperator()); + locationAreaCode = 18; + cellId = 19; + + + data.Close(); + lcnStat.SerialiseL(data); + + iMockLTSY.CompleteL(KMockLtsyDispatchSatLocationStatusIndId,KErrNone,data); + + + //MockLTSY expect, the CTSY sends down a Event Download to the LTSY + + // Create envelope + envelope.Begin(KBerTlvEventDownloadTag); + // Event list + envelope.AddTag(KTlvEventListTag); + envelope.AddByte(KEventLocationStatus); + // Device identities + envelope.AddTag(KTlvDeviceIdentityTag); + envelope.AddByte(KMe); + envelope.AddByte(KSim); + // location status + envelope.AddTag(KTlvLocationStatusTag); + envelope.AddByte(locationStatus); + // location info + envelope.AddTag(KTlvLocationInformationTag); //location information varies depending on access technology + envelope.AddData(*operatorCode); + + envelope.AddByte( TUint8( locationAreaCode >> KShiftBitsToGetMSB ) );// Hi byte + envelope.AddByte( TUint8( locationAreaCode >> KShiftBitsToGetLSB ) );// Lo byte + envelope.AddByte( TUint8( cellId >> KShiftBitsToGetMSB ) ); // Hi byte + envelope.AddByte( TUint8( cellId >> KShiftBitsToGetLSB ) ); // Lo byte + + WaitForEventDownloadL(RSat::KLocationStatus,envelope.End()); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); + } + +/* + * UNSUPPORTED due to being used internally by sat tsy + * + case ESatGetMeSideSatProfile: + case ESatClientSatProfileIndication: + case ESatUsatClientReadyIndication: + case ESatGetProvisioningRefFile: + case ESatNotifyRefreshRequired: + // Notifications + case ESatNotifyPerformCardApduPCmd: + case ESatNotifyPowerOffCardPCmd: + case ESatNotifyPowerOnCardPCmd: + case ESatNotifyGetReaderStatusPCmd: + case ESatNotifyRunAtCommandPCmd: + case ESatNotifyPollingOff: + case ESatNotifyPollingInterval: + case ESatNotifyServiceSearchPCmd: + case ESatNotifyGetServiceInfoPCmd: + case ESatNotifyDeclareServicePCmd: + case ESatNotifyProactiveSimSessionStart: + case ESatNotifyTimerExpiration: + case ESatNotifyTimerMgmtPCmd: + case ESatNotifyTsyStateUpdated: +*/ + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0004 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test of Call Connect and Call Disconnect Events from the LTSY +@SYMTestPriority High +@SYMTestActions Invokes RSat::EventDownload, CallbackSatCallConnectedInd, CallbackSatCallDisconnectedInd +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySatFU::TestUnit0004L() + { + OpenEtelServerL(EUseExtendedError); + + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + //test call connected + const TUint8 KPCmdNumber = 124; + const TUint8 KTransactionId = 111; + + SetupEventListL(KPCmdNumber,KEventCallConnected); + + TUint8 transactionId = KTransactionId; + TBool nearEnd = EFalse; //i.e. MO + TMockLtsyData2 callConnectedTechPack(transactionId,nearEnd); + callConnectedTechPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatCallConnectedIndId, KErrNone, data); + data.Close(); + + // Create envelope + TTlv callConnectEnvelope; + callConnectEnvelope.Begin( KBerTlvEventDownloadTag ); + + // Event list + callConnectEnvelope.AddTag(KTlvEventListTag); + callConnectEnvelope.AddByte(KEventCallConnected); + // Device identities + callConnectEnvelope.AddTag(KTlvDeviceIdentityTag); + callConnectEnvelope.AddByte(nearEnd ? KMe : KNetwork); + callConnectEnvelope.AddByte(KSim); + // Transaction identifier + callConnectEnvelope.AddTag(KTlvTransactionIdentifierTag); + callConnectEnvelope.AddByte(KTransactionId); + // Prepare data + + WaitForEventDownloadL(RSat::KCallConnected,callConnectEnvelope.End()); + + //test call disconnect + SetupEventListL(KPCmdNumber,KEventCallDisconnected); + + const TUint8 KMaxCauseLength = 248; + + RBuf8 cause; + CleanupClosePushL(cause); + + cause.CreateL(KMaxCauseLength); + cause.Append(_L8("1234567")); + TDesC8* causePtr = &cause; + + TMockLtsyData3 callDisconnectedLtsyData(transactionId,nearEnd,causePtr); + callDisconnectedLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatCallDisconnectedIndId, KErrNone, data); + data.Close(); + + // Create envelope + TTlv callDisconnectedEnvelope; + callDisconnectedEnvelope.Begin(KBerTlvEventDownloadTag); + // Event list + callDisconnectedEnvelope.AddTag(KTlvEventListTag); + callDisconnectedEnvelope.AddByte(KEventCallDisconnected); + // Device identities + callDisconnectedEnvelope.AddTag(KTlvDeviceIdentityTag); + callDisconnectedEnvelope.AddByte(nearEnd ? KMe : KNetwork); + callDisconnectedEnvelope.AddByte(KSim); + // Transaction identifier + callDisconnectedEnvelope.AddTag(KTlvTransactionIdentifierTag); + callDisconnectedEnvelope.AddByte(KTransactionId); + + // Cause + if (cause.Length() != 0) + { + callDisconnectedEnvelope.AddTag (KTlvCauseTag); + callDisconnectedEnvelope.AddData(cause); + } + + // Prepare data + WaitForEventDownloadL(RSat::KCallDisconnected,callDisconnectedEnvelope.End()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&cause); + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0005 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test MT Call event IPC +@SYMTestPriority High +@SYMTestActions Invokes RSat::EventDownload, CallbackSatMtCallInd +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySatFU::TestUnit0005L() + { + OpenEtelServerL(EUseExtendedError); + + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + const TUint8 KPCmdNumber = 124; + const TUint8 KTransactionId = 201; + + SetupEventListL(KPCmdNumber,KEventMTCall); + + //Type of Number (TON) and numbering plan identification (NPI). + //MSB - 1, Type of Number - 011 (Network Specific Number), Numbering Plan - 1001 (Private numbering plan) 10111001 = B9 Hex + const TUint8 KTonAndNpi = TonAndNpi(RMobilePhone::ENetworkSpecificNumber,RMobilePhone::EPrivateNumberPlan); + + RBuf8 address; + CleanupClosePushL(address); + address.CreateL(KAddrMaxLength); + address.Append(KTonAndNpi); + address.Append(_L8("1234567")); //dummy data not EF(ADN) encoded data + + const TInt KSubAddressLength = 100; + RBuf8 subAddress; + CleanupClosePushL(subAddress); + subAddress.CreateL(KSubAddressLength); + subAddress.Append(_L8("12345678910")); //dummy data not EF(ADN) encoded data + + TUint8 transactionId = KTransactionId; + TDesC8* addressPtr = &address; + TDesC8* subAddressPtr = &subAddress; + + TMockLtsyData3 mtCallPack(transactionId,addressPtr,subAddressPtr); + mtCallPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatMtCallIndId, KErrNone, data); + data.Close(); + + // Create envelope + TTlv envelope; + envelope.Begin(KBerTlvEventDownloadTag); + + // Event list + envelope.AddTag(KTlvEventListTag); + envelope.AddByte(KEventMTCall); + + // Device identities + envelope.AddTag(KTlvDeviceIdentityTag); + envelope.AddByte(KNetwork); + envelope.AddByte(KSim); + + // Transaction identifier + envelope.AddTag(KTlvTransactionIdentifierTag); + envelope.AddByte(KTransactionId); + + if(KTonAndNpi != 0) + { + envelope.AddTag(KTlvAddressTag); + envelope.AddByte(KTonAndNpi); + + if(address.Length() != 0) + { + envelope.AddData(address.Mid(1)); //chop the Ton and Npi off + } + } + + if(subAddress.Length() != 0) + { + envelope.AddTag( KTlvSubaddressTag ); + envelope.AddData(subAddress); + } + + // Prepare data + WaitForEventDownloadL(RSat::KMTCall,envelope.End()); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&subAddress); + CleanupStack::PopAndDestroy(&address); + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0006 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Timezone change IPCs +@SYMTestPriority High +@SYMTestActions Send an indicator to the CTSY with the new time zone - CallbackSatTimeZoneChangeInd +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySatFU::TestUnit0006L() + { + OpenEtelServerL(EUseExtendedError); + + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + const TUint8 KTimeZone = 255; + + //test and time zone update + TUint8 timeZone = KTimeZone; + TMockLtsyData1 timeZonePack(timeZone); + timeZonePack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatTimeZoneChangeIndId, KErrNone, data); + data.Close(); + + WaitForMockLTSYTerminated(); + + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0007 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc SET UP EVENT LIST proactive command +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifySetUpEventListPCmd +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySatFU::TestUnit0007L() + { + OpenEtelServerL(EUseExtendedError); + + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + const TUint8 KPCmdNumber = 123; + + //setup the event list + SetupEventListL(KPCmdNumber,KEventMTCall); + + //"The list of events provided by the UICC in the last SET UP EVENT LIST + //command shall be removed if the terminal is powered off or the UICC is removed or a reset is performed." + + //clear the event list + iMockLTSY.CompleteL(KMockLtsyDispatchSatRemoveEventListIndId,KErrNone); + + WaitForMockLTSYTerminated(); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0008 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Testing RSat::NotifyProactiveSimSessionEnd support +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifyProactiveSimSessionEnd +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySatFU::TestUnit0008L() + { + + //RSat::NotifyProactiveSimSessionEnd Inroduced in version 6.1, marked as + //"no longer needed when using the ETelSat API" from version 8.2 + + OpenEtelServerL(EUseExtendedError); + + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + TUint8 statusWord1 = 0x90; + TUint8 statusWord2 = 0x00; + + TUint8 proactiveCommandType = KEndOfTheProactiveSession; + + //this is as a result of the NotifyProactiveSimSessionEnd call down to the LTSY, + //this tells the LTSY we are interested in a Sim Session End event + //CTSY -> LTSY + TMockLtsyData1 proactiveCommandTypeDataPack(proactiveCommandType); + proactiveCommandTypeDataPack.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,data); + data.Close(); + + + //the client side call to be notifed when the Proactive Sim Session has ended. + iSat.NotifyProactiveSimSessionEnd(reqStatus); + + //sometime later the Sim Session ends, indicator up + //LTSY -> CTSY + TMockLtsyData2 notifyProactiveSimSessionEndDataPack(statusWord1,statusWord2); + notifyProactiveSimSessionEndDataPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatNotifyProactiveSimSessionEndIndId,KErrNone,data); + data.Close(); + + //wait for the client side to be notified + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),KErrNone); + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); + } + + + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0009 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for notify local info (network measurement result) IPC +@SYMTestPriority High +@SYMTestActions Invokes CallbackSatPcmdInd, CallbackSatLocalInformationNmrComp +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySatFU::TestUnit0009L() + { + /* + * + * IPCS that are exercised + * + ESatTsyLocalInformationNmr: + ESatTsyNotifyLocalInfo: + */ + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + RBuf8 data; + CleanupClosePushL(data); + + // + //provide local info (network measurement) + const TUint8 KPCmdNumber = 105; + + TTlv tlv; + tlv.Begin(KBerTlvProactiveSimCommandTag); + tlv.AddTag(KTlvCommandDetailsTag); + tlv.AddByte(KPCmdNumber);//ETLV_CommandNumber + tlv.AddByte(KProvideLocalInformation); //ETLV_TypeOfCommand + tlv.AddByte(RSat::KProvideLocalInformationNmr);//ETLV_CommandQualifier / KCommandQualifier + tlv.AddTag(KTlvDeviceIdentityTag); + tlv.AddByte(KSim);//ETLV_SourceDeviceIdentity + tlv.AddByte(KMe); + + TDesC8* tlvDscPtr = &const_cast(tlv.End()); + TMockLtsyData1 tlvDscPack(tlvDscPtr); + tlvDscPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data); + + //Now send the terminal response + iMockLTSY.ExpectL(MLtsyDispatchSatLocalInformationNmr::KLtsyDispatchSatLocalInformationNmrApiId); + + + _LIT8(KNmrResults,"abc"); + TDesC8* nmr = &const_cast(KNmrResults()); + _LIT(KBcchList,"def"); + TDesC* bcch = &const_cast(KBcchList()); + TMockLtsyData2 nmrPack(nmr,bcch); + data.Close(); + nmrPack.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatLocalInformationNmr::KLtsyDispatchSatLocalInformationNmrApiId, KErrNone, data); + + TTlv tlvAddInfo; + tlvAddInfo.AddTag( KTlvNetworkMeasurementResultsTag ); + tlvAddInfo.AddData(KNmrResults); + tlvAddInfo.AddTag (KTlvBccdChannelListTag); + + //convert the BCCH data to the right format + TInt i( 0 ); + TInt mask( 3 ); + TInt shiftMove( 2 ); + TUint8 nextChar( 0 ); + + // Convert BCCH channel list from 16-bit to 10-bit format + for ( i = 0; i < bcch->Length(); i++ ) + { + TUint char2 = ( (*bcch)[i] & 0x03FF ); + TUint8 char1 = static_cast( char2 >> shiftMove ); + + // Append byte + tlvAddInfo.AddByte( + static_cast( char1 | nextChar ) ); + + nextChar = static_cast( ( char2 & mask ) + << ( 8 - shiftMove ) ); + + if ( 8 == shiftMove ) + { + shiftMove = 2; + nextChar = 0; + tlvAddInfo.AddByte( + static_cast ( char2 & 0x00FF ) ); + mask = 3; + } + else + { + shiftMove += 2; + mask = ( 1L << shiftMove ) - 1; + } + } + // Add last byte + tlvAddInfo.AddByte( nextChar ); + + GenerateAndWaitForTermRspL( KPCmdNumber, + KProvideLocalInformation, + RSat::KProvideLocalInformationNmr, + RSat::ELocalInfo, + RSat::KSuccess, + KGeneralResultAddInfo, + KNullDesC8, + tlvAddInfo.GetDataWithoutTopLevelTag(), + KErrNone); + + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, this); // data, this + + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0010 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for notify local info (timing advance) IPCs +@SYMTestPriority High +@SYMTestActions Invokes CallbackSatPcmdInd, CallbackSatTimingAdvanceComp +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySatFU::TestUnit0010L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + RBuf8 data; + CleanupClosePushL(data); + + // + //provide local info (network measurement) + + + const TUint8 KPCmdNumber = 109; + const TUint8 KTimingAdvance = 47; + const TUint8 KMeStatus = 0x01; + + TTlv tlv; + tlv.Begin(KBerTlvProactiveSimCommandTag); + tlv.AddTag(KTlvCommandDetailsTag); + tlv.AddByte(KPCmdNumber);//ETLV_CommandNumber + tlv.AddByte(KProvideLocalInformation); //ETLV_TypeOfCommand + //ETLV_CommandQualifier / KCommandQualifier + tlv.AddByte(RSat::KProvideLocalInfoTimingAdv); + tlv.AddTag(KTlvDeviceIdentityTag); + tlv.AddByte(KSim);//ETLV_SourceDeviceIdentity + tlv.AddByte(KMe); + + TDesC8* tlvDscPtr = &const_cast(tlv.End()); + TMockLtsyData1 tlvDscPack(tlvDscPtr); + tlvDscPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data); + + + iMockLTSY.ExpectL(MLtsyDispatchSatTimingAdvance::KLtsyDispatchSatTimingAdvanceApiId); + + + TUint8 timingAdvance = KTimingAdvance; + TUint8 meStatus = KMeStatus; + TMockLtsyData2 nmrPack(timingAdvance,meStatus); + data.Close(); + nmrPack.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatTimingAdvance::KLtsyDispatchSatTimingAdvanceApiId, KErrNone, data); + + + const TDesC8& KGeneralResultAddInfo = KNullDesC8; + + TTlv tlvAddInfo; + tlvAddInfo.AddTag( KTlvTimingAdvanceTag ); + tlvAddInfo.AddByte(KMeStatus); //me status + tlvAddInfo.AddByte(KTimingAdvance); //timing advance + + GenerateAndWaitForTermRspL( KPCmdNumber, + KProvideLocalInformation, + RSat::KProvideLocalInfoTimingAdv, + RSat::ELocalInfo, + RSat::KSuccess, + KGeneralResultAddInfo, + KNullDesC8, + tlvAddInfo.GetDataWithoutTopLevelTag(), + KErrNone); + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, this); // data, this + + } + + + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0011 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for notify local info access technology ipcs +@SYMTestPriority High +@SYMTestActions Invokes CallbackSatPcmdInd, CallbackSatAccessTechnologyChangeInd +@SYMTestExpectedResults Pass +@SYMTestType UT + */ + +void CCTsySatFU::TestUnit0011L() + { + /* + * + * IPCS that are exercised in this unit test + * + * ESatTsyProvideLocalInfo: + * ESatTsyAccTech: + */ + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + RBuf8 data; + CleanupClosePushL(data); + + // + //provide local info (network measurement) + + + const TUint8 KPCmdNumber = 129; + + TTlv tlv; + tlv.Begin(KBerTlvProactiveSimCommandTag); + tlv.AddTag(KTlvCommandDetailsTag); + tlv.AddByte(KPCmdNumber);//ETLV_CommandNumber + tlv.AddByte(KProvideLocalInformation); //ETLV_TypeOfCommand + tlv.AddByte(RSat::KProvideLocalInfoAccTech); //ETLV_CommandQualifier / KCommandQualifier + tlv.AddTag(KTlvDeviceIdentityTag); + tlv.AddByte(KSim);//ETLV_SourceDeviceIdentity + tlv.AddByte(KMe); + + TDesC8* tlvDscPtr = &const_cast(tlv.End()); + TMockLtsyData1 tlvDscPack(tlvDscPtr); + data.Close(); + tlvDscPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data); + + iMockLTSY.ExpectL(MLtsyDispatchSatGetAccessTechnology::KLtsyDispatchSatGetAccessTechnologyApiId); + + + const TUint8 KAccessTechnology = 47; + + TUint8 accessTechnology = KAccessTechnology; + TMockLtsyData1 accessTechnologyPack(accessTechnology); + data.Close(); + accessTechnologyPack.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatGetAccessTechnology::KLtsyDispatchSatGetAccessTechnologyApiId, KErrNone, data); + + const TDesC8& KGeneralResultAddInfo = KNullDesC8; + + TTlv tlvAddInfo; + tlvAddInfo.AddTag( KTlvAccessTechnologyTag ); + tlvAddInfo.AddByte( KAccessTechnology ); //access tech + + GenerateAndWaitForTermRspL( KPCmdNumber, + KProvideLocalInformation, + RSat::KProvideLocalInfoAccTech, + RSat::ELocalInfo, + RSat::KSuccess, + KGeneralResultAddInfo, + KNullDesC8, + tlvAddInfo.GetDataWithoutTopLevelTag(), + KErrNone); + + AssertMockLtsyStatusL(); + + //test with completing with an Error + data.Close(); + tlvDscPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data); + + iMockLTSY.ExpectL(MLtsyDispatchSatGetAccessTechnology::KLtsyDispatchSatGetAccessTechnologyApiId); + data.Close(); + accessTechnologyPack.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatGetAccessTechnology::KLtsyDispatchSatGetAccessTechnologyApiId, KErrGeneral, data); + + TBuf8<1> generalResultAddInfo; + generalResultAddInfo.Append(RSat::KNoSpecificMeProblem); + + GenerateAndWaitForTermRspL( KPCmdNumber, + KProvideLocalInformation, + RSat::KProvideLocalInfoAccTech, + RSat::ELocalInfo, + RSat::KMeUnableToProcessCmd, + generalResultAddInfo, + KNullDesC8, + KNullDesC8, //no additional info + KErrNone); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(2, this); // data, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0012 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for ESatTsyEnvelopeError api +@SYMTestPriority High +@SYMTestActions Invokes CallbackSatLocationStatusInd, CallbackSatCreateCallControlEnvelopeInd, HandleUssdControlEnvelopeErrorReqL +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySatFU::TestUnit0012L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + RBuf8 data; + CleanupClosePushL(data); + + RBuf8 expectData; + CleanupClosePushL(expectData); + + RBuf8 completeData; + CleanupClosePushL(completeData); + + TRequestStatus stat; + + + //first we need to provide local info so that it can be used during cc events + + SetupLocalInfoL(KLocationAreaCode,KCellId,KOperatorCode,KLocationStatusNormalService); + + //************************************************************************************ + //Now we do a SEND USSD proactive command + + TUint8 pcmdCode = KSendUssd; + TMockLtsyData1 expLtsyData(pcmdCode); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,data); + + RSat::TSendUssdV6 ussd; + RSat::TSendUssdV6Pckg ussdPck(ussd); + iSat.NotifySendUssdPCmd(stat, ussdPck); + + const TInt KSendUssdPCmdNo = 205; + + TTlv tlv; + tlv.Begin(KBerTlvProactiveSimCommandTag); + tlv.AddTag(KTlvCommandDetailsTag); + tlv.AddByte(KSendUssdPCmdNo);//ETLV_CommandNumber + tlv.AddByte(pcmdCode); //ETLV_TypeOfCommand + tlv.AddByte(KSetUpCallDisconnectingOtherCalls); //ETLV_CommandQualifier + + tlv.AddTag(KTlvDeviceIdentityTag); + tlv.AddByte(KSim); //ETLV_SourceDeviceIdentity + tlv.AddByte(KNetwork); //ETLV_DestinationDeviceIdentity + + tlv.AddTag(KTlvUssdStringTag); + const TUint8 KTonNpi = 0x91; //0b10010001; + tlv.AddByte(KTonNpi); //TON and NPI (national number that conforms to the itu telephony style of numbering) + + _LIT8(KSetUpCallNo8 ,"012345678hjhj"); + //_LIT16(KSetUpCallNo16,"012345678hjhj"); + TBuf8 bcdSetUpCallNo; + TBuf16 bcdSetUpCallNo16; + TSatUtility::AsciiToBCD(KSetUpCallNo8,bcdSetUpCallNo); + bcdSetUpCallNo16.Copy(bcdSetUpCallNo); + tlv.AddData(bcdSetUpCallNo); + + TDesC8* tlvDscPtr = &const_cast(tlv.End()); + TMockLtsyData1 tlvDscPack(tlvDscPtr); + data.Close(); + tlvDscPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data); + + User::WaitForRequest(stat); + ASSERT_EQUALS(stat.Int(),KErrNone); + + + //****************************************************************************************************** + //* At this stage the phone application/system software would attempt to make the call specified in the + //* SEND USSD pcmd payload, first checking whether this is the emergency number (112) per ETSI TS 102 223 + //* section 6.4.13 and routing the call via the appropriate ETel API, i.e. RMobileCall::DialEmergencyCall() + //* for emergency calls and RCall::Dial() for standard ones. + //* + //* After checking for emergency numbers and against the FDN list, the LTSY uses the CreateEnvelopeInd IPC to + //* request that the CTSY constructs TLV data for an ENVELOPE (CALL CONTROL). Once this is done it passes it + //* to the LTSY with the SendEnvelopeReq(IPC). + //* + //****************************************************************************************************** + + + + //********************************************************************************** + //send up the "create envelope" event which we know the CTSY won't be able to create, + //due to USSD strings not being supported. + _LIT8(KBcc1,"asdas"); + _LIT8(KBcc2,"qwqwqw"); + TDesC8* bcc1Ptr = const_cast(&KBcc1); + TDesC8* bcc2Ptr = const_cast(&KBcc2); + TDesC8* addrPtr = const_cast(&KSetUpCallNo8); + TUint8 tag = KTlvUssdStringTag; + const TUint8 KDcs = 56; + TUint8 tonNpi = KTonNpi; + TUint8 dcs = KDcs; + TMockLtsyData6 ccInfoPck(tag, bcc1Ptr, bcc2Ptr, addrPtr, tonNpi, dcs); + + data.Close(); + ccInfoPck.SerialiseL(data); + + iMockLTSY.CompleteL(KMockLtsyDispatchSatCreateCallControlEnvelopeIndId,KErrNone,data); + + + //********************************************************************************** + //Now report the error creating the USSD envelope. + + iMockLTSY.ExpectL(MLtsyDispatchSatUssdControlEnvelopeError::KLtsyDispatchSatUssdControlEnvelopeErrorApiId); + iMockLTSY.CompleteL(MLtsyDispatchSatUssdControlEnvelopeError::KLtsyDispatchSatUssdControlEnvelopeErrorApiId,KErrNone); + + + WaitForMockLTSYTerminated(); + + + CleanupStack::PopAndDestroy(&completeData); + CleanupStack::PopAndDestroy(&expectData); + CleanupStack::PopAndDestroy(2, this); // data, this + } + + + + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0013 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for ESatNotifySetupCall (interaction between setup call proactive command and the call connected event) +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifySetUpCallPCmd, RSat::NotifyCallControlRequest +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySatFU::TestUnit0013L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + iCallContainer = new (ELeave) CCallTypeContainer(); + + RBuf8 data; + CleanupClosePushL(data); + + RBuf8 expectData; + CleanupClosePushL(expectData); + RBuf8 completeData; + CleanupClosePushL(completeData); + + TRequestStatus reqStatus; + + //************************************************************************** + //first we need to provide local info so that it can be used during cc events + + SetupLocalInfoL(KLocationAreaCode,KCellId,KOperatorCode,KLocationStatusNormalService); + + //***************************************************** + //now we set up an event list containing the call connected event + const TInt KPCommandNumber = 135; + SetupEventListL(KPCommandNumber,KEventCallConnected); + //************************************************************************************ + //Now we do a setup call proactive command + + TUint8 pcmdCode = KSetUpCall; + TMockLtsyData1 expLtsyData(pcmdCode); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,data); + //iMockLTSY.ExpectL(MLtsyDispatchSatNotifySetUpCallPcmd::KLtsyDispatchSatNotifySetUpCallPcmdApiId); + + iSat.NotifySetUpCallPCmd(reqStatus, iCallContainer->iSetUpCallPckg); + AssertMockLtsyStatusL(); //LTSY should be empty KLtsyDispatchSatPCmdNotificationApiId expect consumed by the NotifySetUpCallPCmd + + const TUint8 KSetUpCallPCmdNo = 201; + + TTlv tlv; + tlv.Begin(KBerTlvProactiveSimCommandTag); + tlv.AddTag(KTlvCommandDetailsTag); + tlv.AddByte(KSetUpCallPCmdNo);//ETLV_CommandNumber + tlv.AddByte(pcmdCode); //ETLV_TypeOfCommand + tlv.AddByte(KSetUpCallDisconnectingOtherCalls); //ETLV_CommandQualifier + + tlv.AddTag(KTlvDeviceIdentityTag); + tlv.AddByte(KSim); //ETLV_SourceDeviceIdentity + tlv.AddByte(KNetwork); //ETLV_DestinationDeviceIdentity + + tlv.AddTag(KTlvAddressTag); + const TUint8 KTonNpi = 0x91; //0b10010001; + tlv.AddByte(KTonNpi); //TON and NPI (national number that conforms to the itu telephony style of numbering) + + _LIT8(KSetUpCallNo,"012345678"); + TBuf8 bcdSetUpCallNo; + TSatUtility::AsciiToBCD(KSetUpCallNo,bcdSetUpCallNo); + tlv.AddData(bcdSetUpCallNo); + + TDesC8* tlvDscPtr = &const_cast(tlv.End()); + TMockLtsyData1 tlvDscPack(tlvDscPtr); + data.Close(); + tlvDscPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data); + User::WaitForRequest(reqStatus); //NotifySetUpCallProactiveCommand + ASSERT_EQUALS(reqStatus.Int(),KErrNone); + ASSERT_EQUALS(KSetUpCallPCmdNo, iCallContainer->iSetUpCall.PCmdNumber()); + AssertMockLtsyStatusL(); + //set up to listen for call control + + + iSat.NotifyCallControlRequest(reqStatus, iCallContainer->iCallControlPckg); + + //********************************************************************************** + //send up the "create envelope" event which causes the ctsy to assemble the ENVELOPE (CALL CONTROL) + _LIT8(KBcc1,"asdas"); + _LIT8(KBcc2,"qwqwqw"); + TDesC8* bcc1Ptr = const_cast(&KBcc1); + TDesC8* bcc2Ptr = const_cast(&KBcc2); + TDesC8* addrPtr = const_cast(&KSetUpCallNo); + TUint8 tag = KTlvAddressTag; + const TUint8 KDcs = 56; + TUint8 tonNpi = KTonNpi; + TUint8 dcs = KDcs; + + TMockLtsyData6 ccInfoPck(tag, bcc1Ptr, bcc2Ptr, addrPtr, tonNpi, dcs); + data.Close(); + ccInfoPck.SerialiseL(data); + + iMockLTSY.CompleteL(KMockLtsyDispatchSatCreateCallControlEnvelopeIndId,KErrNone,data); + //********************************************************************************** + //Now send down the created envelope + + tlv.Begin( KBerTlvCallControlTag ); + // Device identities + tlv.AddTag( KTlvDeviceIdentityTag ); + tlv.AddByte( KMe ); + tlv.AddByte( KSim ); + // Address + tlv.AddTag( KTlvAddressTag ); + tlv.AddByte( KTonNpi ); + tlv.AddData( bcdSetUpCallNo ); + // Optional + tlv.AddTag( KTlvCapabilityConfigurationParametersTag ); + tlv.AddData( KBcc1 ); + // Add location information data + tlv.AddTag( KTlvLocationInformationTag ); + // Append Mobile Country & Network Codes, 3 bytes + tlv.AddData(KOperatorCode ); + // Append Location Area Code (LAC) + tlv.AddByte( static_cast( KLocationAreaCode >> KShiftBitsToGetMSB ) );//msb + tlv.AddByte( static_cast( KLocationAreaCode >> KShiftBitsToGetLSB ) );//lsb + // Append Cell Id + tlv.AddByte( static_cast( KCellId >> KShiftBitsToGetMSB ) ); // msbthey + tlv.AddByte( static_cast( KCellId >> KShiftBitsToGetLSB ) ); // lsb + + tlv.AddTag( KTlvCapabilityConfigurationParametersTag ); + tlv.AddData( KBcc2 ); + + // Prepare data + TDesC8* tlvDscDes = &const_cast(tlv.End()); + TMockLtsyData1 tlvDscDesPck(tlvDscDes); + tlvDscDesPck.SerialiseL(expectData); + + iMockLTSY.ExpectL(MLtsyDispatchSatCallAndSmsControlEnvelope::KLtsyDispatchSatCallAndSmsControlEnvelopeApiId,expectData); + + //let the envelope IPCs go up and down + WaitForMockLTSYTerminated(); + data.Close(); + expectData.Close(); + //************************************************************************************ + //Now we send up the response of the call control + + tlv.Begin(0x02);//the type of request has changed (the envelope responses have a slightly different format to the rest of the data so we achieve this by passing in call control result as the top level tag) + tlv.AddTag(KTlvAddressTag); + tlv.AddByte(KTonNpi); //ton+npi + tlv.AddData(bcdSetUpCallNo); + tlv.AddTag(KTlvAlphaIdentifierTag); + tlv.AddData(_L8("Test alpha id")); + tlvDscDes = &const_cast(tlv.End()); + //RSat::TControlResult controlResult=RSat::EAllowedWithModifications; + + TMockLtsyData1 controlPck(tlvDscDes); + controlPck.SerialiseL(completeData); + iMockLTSY.CompleteL(KMockLtsyDispatchSatCallControlEnvelopeResponseIndId,KErrNone,completeData); + //********************************************************************** + // we now get a call connected event after the potentially modified call has been dialled + TUint8 transactionId = 111; + TBool nearEnd = EFalse; //i.e. this is a MO call + TMockLtsyData2 callConnectedTechPack(transactionId,nearEnd); + callConnectedTechPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatCallConnectedIndId, KErrNone, data); + + User::WaitForRequest(reqStatus); //NotifyCallControlRequest + ASSERT_EQUALS(reqStatus.Int(),KErrNone); + AssertMockLtsyStatusL(); + data.Close(); + completeData.Close(); + //************************************************************************************ + //now we need to provide the terminal response to the SET UP CALL proactive command; + //when the terminal response is sent, it will trigger the sending of the saved + //call connected event envelope + + //now fire off terminal response + + RSat::TSetUpCallRspV2 setUpCallRsp; + RSat::TSetUpCallRspV2Pckg setUpCallRspPckg(setUpCallRsp); + + const RSat::TPCmdResult KPCmdResult = RSat::KSuccess; + + const TDesC8& KGeneralResultAddInfo = KNullDesC8(); + + setUpCallRsp.iGeneralResult = KPCmdResult; + setUpCallRsp.iInfoType = RSat::KNoAdditionalInfo; + setUpCallRsp.SetPCmdNumber(KSetUpCallPCmdNo); + + + RBuf8 terminalRsp; + CleanupClosePushL(terminalRsp); + terminalRsp.CreateL(KTlvMaxSize); + //void GenerateTermRspTlv(RBuf8& buf, TUint8 aPCmdNumber,TUint8 aTypeOfCommand, TUint8 aCommandQualifier, RSat::TPCmd aRSatTypeOfCommand, RSat::TPCmdResult aResult, const TDesC8& aRsp, const TDesC8& aAdditionalInfo); + GenerateTermRspTlv(terminalRsp, KSetUpCallPCmdNo, KSetUpCall, KSetUpCallDisconnectingOtherCalls, KPCmdResult, KGeneralResultAddInfo, KNullDesC8()); + + TDesC8* terminalRspPtr = &terminalRsp; + + TMockLtsyData1 termRespData(terminalRspPtr); + termRespData.SerialiseL(data); + + iMockLTSY.ExpectL(MLtsyDispatchSatTerminalRsp::KLtsyDispatchSatTerminalRspApiId, data); + + //following the dispatch terminal response ipc, we get the event envelope in response to call connected + TTlv callConnectEnvelope; + callConnectEnvelope.Begin( KBerTlvEventDownloadTag ); + + // Event list + callConnectEnvelope.AddTag(KTlvEventListTag); + callConnectEnvelope.AddByte(KEventCallConnected); + // Device identities + callConnectEnvelope.AddTag(KTlvDeviceIdentityTag); + callConnectEnvelope.AddByte(nearEnd ? KMe : KNetwork); + callConnectEnvelope.AddByte(KSim); + // Transaction identifier + callConnectEnvelope.AddTag(KTlvTransactionIdentifierTag); + callConnectEnvelope.AddByte(transactionId); + // Prepare data + //WaitForEventDownloadL(RSat::KCallConnected,); + TPtrC8 ccEnv(callConnectEnvelope.End()); + TDesC8* ccEnvPtr = &ccEnv; + + TMockLtsyData1 eventDownloadExpLtsyData(ccEnvPtr); + eventDownloadExpLtsyData.SerialiseL(expectData); + iMockLTSY.ExpectL(MLtsyDispatchSatEventDownloadEnvelope::KLtsyDispatchSatEventDownloadEnvelopeApiId,expectData); + //after that we can complete the terminal response ipc + + iMockLTSY.CompleteL(MLtsyDispatchSatTerminalRsp::KLtsyDispatchSatTerminalRspApiId, KErrNone); + + TRequestStatus reqStatusNotifyTerminated; + iMockLTSY.NotifyTerminated(reqStatusNotifyTerminated); + + iSat.TerminalRsp(reqStatus, RSat::ESetUpCall, setUpCallRspPckg); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),KErrNone); + + User::WaitForRequest(reqStatusNotifyTerminated); + ASSERT_EQUALS(reqStatusNotifyTerminated.Int(),KErrNone); + + + AssertMockLtsyStatusL(); + + //**************** + CleanupStack::PopAndDestroy(&terminalRsp); + CleanupStack::PopAndDestroy(&completeData); + CleanupStack::PopAndDestroy(&expectData); + CleanupStack::PopAndDestroy(2, this); // data, this + } + + + + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0014 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for refresh +@SYMTestPriority High +@SYMTestActions Invokes RSat::NotifyRefreshRequired, RSat::NotifyRefreshPCmd, RSat::NotifyRefreshAllowed, RSat::TerminalRsp +@SYMTestExpectedResults Pass +@SYMTestType UT + */ +void CCTsySatFU::TestUnit0014L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + RBuf8 data; + CleanupClosePushL(data); + + const TUint8 KPCmdNumber1 = 101; + const TUint8 KCommandQualifier1 = KSimInitFullFileChangeNotification; //zero is NAA Initialization and Full File Change Notification + + RefreshNoTerminalRspL(KPCmdNumber1,KCommandQualifier1,KErrNotReady); + + //ESatTsyRefresh + //indicator to create the terminal response. + const TUint8 KGeneralResultAddInfo = 0x3D; + + TBuf8 additionalInfo8; + additionalInfo8.Append(KGeneralResultAddInfo); + + RSat::TAdditionalInfo additionalInfo; + additionalInfo.Append(KGeneralResultAddInfo); + + RSat::TPCmdResult generalResult = RSat::KMeUnableToProcessCmd; + TDesC* additionalInfoPtr = &additionalInfo; + TMockLtsyData2 refreshDataPck(generalResult,additionalInfoPtr); + refreshDataPck.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatCreateRefreshTerminalRspIndId,KErrNone,data); + data.Close(); + + const TUint8 KRefreshCommandQualifier = 0x00; // 00 = NAA Initialization and Full File Change Notification + GenerateAndWaitForTermRspL(KPCmdNumber1,KRefresh,KRefreshCommandQualifier,RSat::ERefresh,generalResult,additionalInfo8,KNullDesC8,KNullDesC8,KErrNone); + + /********************************************************************/ + + const TUint8 KPCmdNumber2 = 102; + const TUint8 KCommandQualifier2 = KSimInit; //zero is NAA Initialization and Full File Change Notification + + RefreshNoTerminalRspL(KPCmdNumber2,KCommandQualifier2,KErrNone); + + //ESatTsyImsiChanged + iMockLTSY.CompleteL(KMockLtsyDispatchSatImsiChangedIndId,KErrNone); + WaitForMockLTSYTerminated(); + + //once finished generate the Terminal response + RSat::TRefreshRspV1 refreshTerminalRsp; + refreshTerminalRsp.iGeneralResult = RSat::KSuccess; + refreshTerminalRsp.iInfoType = RSat::KNoAdditionalInfo; + refreshTerminalRsp.iAdditionalInfo = KNullDesC; + refreshTerminalRsp.SetPCmdNumber(KPCmdNumber1); + + RSat::TRefreshRspV1Pckg refreshTerminalRspPckg(refreshTerminalRsp); + + TRequestStatus reqStatus; + iSat.TerminalRsp(reqStatus, RSat::ERefresh, refreshTerminalRspPckg); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),KErrNone); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(this); + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0015 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for notify local info - location information request (i.e. cell id etc) +@SYMTestPriority High +@SYMTestActions Invokes CallbackSatProvideLocationInfoComp +@SYMTestExpectedResults Pass +@SYMTestType UT + */ + +void CCTsySatFU::TestUnit0015L() + { + /* + * + * IPCS that are exercised in this unit test + * + * ESatTsyProvideLocalInfo: + * ESatTsyAccTech: + */ + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + RBuf8 data; + CleanupClosePushL(data); + + // + //provide local info (location info) + + + const TUint8 KPCmdNumber = 142; + + TTlv tlv; + tlv.Begin(KBerTlvProactiveSimCommandTag); + tlv.AddTag(KTlvCommandDetailsTag); + tlv.AddByte(KPCmdNumber);//ETLV_CommandNumber + tlv.AddByte(KProvideLocalInformation); //ETLV_TypeOfCommand + tlv.AddByte(RSat::KProvideLocalInfo); //ETLV_CommandQualifier / KCommandQualifier + tlv.AddTag(KTlvDeviceIdentityTag); + tlv.AddByte(KSim);//ETLV_SourceDeviceIdentity + tlv.AddByte(KMe); + + TDesC8* tlvDscPtr = &const_cast(tlv.End()); + TMockLtsyData1 tlvDscPack(tlvDscPtr); + tlvDscPack.SerialiseL(data); + + TRequestStatus reqStatus; + iMockLTSY.NotifyTerminated(reqStatus); + + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data); + + iMockLTSY.ExpectL(MLtsyDispatchSatProvideLocationInfo::KLtsyDispatchSatProvideLocationInfoApiId); + + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),KErrNone); + + TDesC8* opCodePtr = const_cast(&KOperatorCode); + TUint16 lac = KLocationAreaCode; + TUint16 cellId = KCellId; + TMockLtsyData3 locationInfoPCmdDataPack( lac, + cellId, opCodePtr); + data.Close(); + locationInfoPCmdDataPack.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatProvideLocationInfo::KLtsyDispatchSatProvideLocationInfoApiId, KErrNone, data); + + + + + const TDesC8& KGeneralResultAddInfo = KNullDesC8; + + TTlv tlvAddInfo; + tlvAddInfo.AddTag( KTlvLocationInformationTag ); + tlvAddInfo.AddData( KOperatorCode ); + + tlvAddInfo.AddByte( static_cast( KLocationAreaCode >> KShiftBitsToGetMSB ) );//msb + tlvAddInfo.AddByte( static_cast( KLocationAreaCode >> KShiftBitsToGetLSB ) );//lsb + tlvAddInfo.AddByte( static_cast( KCellId >> KShiftBitsToGetMSB ) );//msb + tlvAddInfo.AddByte( static_cast( KCellId >> KShiftBitsToGetLSB ) );//lsb + + GenerateAndWaitForTermRspL( KPCmdNumber, + KProvideLocalInformation, + RSat::KProvideLocalInfo, + RSat::ELocalInfo, + RSat::KSuccess, + KGeneralResultAddInfo, + KNullDesC8, + tlvAddInfo.GetDataWithoutTopLevelTag(), + KErrNone); + + + + AssertMockLtsyStatusL(); + CleanupStack::PopAndDestroy(2, this); // data, this + } + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0016 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for the ESatTsySsStatus api +@SYMTestPriority High +@SYMTestActions Invokes +@SYMTestExpectedResults Pass +@SYMTestType CT + */ +void CCTsySatFU::TestUnit0016L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + OpenPhoneL(); + OpenSatL(); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + DispatcherSat::TSsStatus status = DispatcherSat::ENotBusy; + TMockLtsyData1 ltsyData(status); + ltsyData.SerialiseL(data); + iMockLTSY.NotifyTerminated(reqStatus); + iMockLTSY.CompleteL(KMockLtsyDispatchSatSsChangeIndId, KErrNone, data); + data.Close(); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),KErrNone); + + status = DispatcherSat::ESsBusy; + ltsyData.SerialiseL(data); + iMockLTSY.NotifyTerminated(reqStatus); + iMockLTSY.CompleteL(KMockLtsyDispatchSatSsChangeIndId, KErrNone, data); + data.Close(); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),KErrNone); + + status = DispatcherSat::EUssdBusy; + ltsyData.SerialiseL(data); + iMockLTSY.NotifyTerminated(reqStatus); + iMockLTSY.CompleteL(KMockLtsyDispatchSatSsChangeIndId, KErrNone, data); + data.Close(); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),KErrNone); + + CleanupStack::PopAndDestroy(2, this); // data, this + } + + +/** +@SYMTestCaseID BA-CTSYD-DIS-SAT-UN0017 +@SYMComponent telephony_ctsy +@SYMTestCaseDesc Test support in CTSY for RMmCustomAPI::SatRefreshCompleteNotification() +@SYMTestPriority High +@SYMTestActions Invokes RMmCustomAPI::SatRefreshCompleteNotification() +@SYMTestExpectedResults Pass +@SYMTestType CT + */ +void CCTsySatFU::TestUnit0017L() + { + OpenEtelServerL(EUseExtendedError); + CleanupStack::PushL(TCleanupItem(Cleanup,this)); + + OpenPhoneL(); + OpenSatL(); + + RMmCustomAPI customApi; + OpenCustomApiLC(customApi); + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + customApi.SatRefreshCompleteNotification(reqStatus); + + const TUint8 KPCmdNumber = 101; + const TUint8 KCommandQualifier = KSimInitFullFileChangeNotification; //zero is NAA Initialization and Full File Change Notification + + RefreshNoTerminalRspL(KPCmdNumber, KCommandQualifier, KErrNone); + + //can't wait here known defect 403701, see CCTsyCustomIPCFU::TestSatRefreshCompleteNotification0001L + //User::WaitForRequest(reqStatus); + //ASSERT_EQUALS(reqStatus.Int(),KErrNone); + + //Do the Client side refresh + + + //once finished generate the Terminal response + + RSat::TRefreshRspV1 refreshTerminalRsp; + refreshTerminalRsp.iGeneralResult = RSat::KSuccess; + refreshTerminalRsp.iInfoType = RSat::KNoAdditionalInfo; + refreshTerminalRsp.iAdditionalInfo = KNullDesC; + refreshTerminalRsp.SetPCmdNumber(KPCmdNumber); + + RSat::TRefreshRspV1Pckg refreshTerminalRspPckg(refreshTerminalRsp); + + GenerateAndWaitForTermRspL(KPCmdNumber,KRefresh,KCommandQualifier,RSat::ERefresh,RSat::KSuccess,refreshTerminalRspPckg,KErrNone); + + AssertMockLtsyStatusL(); + + CleanupStack::PopAndDestroy(&data); + CleanupStack::PopAndDestroy(&customApi); + CleanupStack::PopAndDestroy(this); + } + + +/** + * Utility function which handles all the Expects/Completes generated by Opening an RSat object. + */ +void CCTsySatFU::OpenSatL(TUint8 aEnabled) + { + RBuf8 data; + CleanupClosePushL(data); + + + iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId); + + TBool smsMoControlActivated = aEnabled & KSmsMoControlEnabled; + TMockLtsyData1 comLtsyData(smsMoControlActivated); + comLtsyData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsControlActivated::KLtsyDispatchSatGetSmsControlActivatedApiId, KErrNone, data); + + TUint8 pcmdCode = KPollInterval; + TMockLtsyData1 expLtsyData(pcmdCode); + data.Close(); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId, data ); + + pcmdCode = KPollingOff; + data.Close(); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId, data ); + + pcmdCode = KMoreTime; + data.Close(); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId, data ); + + pcmdCode = KTimerManagement; + data.Close(); + expLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId, data ); + + iMockLTSY.ExpectL(MLtsyDispatchPhoneGetPhoneId::KLtsyDispatchPhoneGetPhoneIdApiId); + + _LIT(KSerialNumber, "12345678"); + + RMobilePhone::TMobilePhoneIdentityV1 phoneId; + phoneId.iSerialNumber = KSerialNumber; + + TMockLtsyData1 phoneIdData(phoneId); + data.Close(); + phoneIdData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchPhoneGetPhoneId::KLtsyDispatchPhoneGetPhoneIdApiId, KErrNone, data); + + iMockLTSY.ExpectL(MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId); + + TBuf8 bearerCapabilities(_L8("TEST BEARER!")); + TDesC8* bearerCapabilitiesPtr = &bearerCapabilities; + TMockLtsyData1 bearerCapabilitiesData(bearerCapabilitiesPtr); + data.Close(); + bearerCapabilitiesData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatGetDefaultBearerCapability::KLtsyDispatchSatGetDefaultBearerCapabilityApiId, KErrNone, data); + + iMockLTSY.ExpectL(MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId); + + TBool ussdSupported = aEnabled & KUssdEnabled; + TMockLtsyData1 ussdSupportedData(ussdSupported); + data.Close(); + ussdSupportedData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatGetUssdControlSupported::KLtsyDispatchSatGetUssdControlSupportedApiId, KErrNone, data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatUssdControlSupportedChangeIndId, KErrNone, data); //do a future indicator completion as well as this could happen at some point + + iMockLTSY.ExpectL(MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId); + iMockLTSY.CompleteL(MLtsyDispatchSatReady::KLtsyDispatchSatReadyApiId,KErrNone); + + iMockLTSY.ExpectL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId); + + TBool smsPpDdlSupported = aEnabled & KSmsPpDownloadEnabled; + TMockLtsyData1 smsPpData(smsPpDdlSupported); + data.Close(); + smsPpData.SerialiseL(data); + iMockLTSY.CompleteL(MLtsyDispatchSatGetSmsPpDownloadSupported::KLtsyDispatchSatGetSmsPpDownloadSupportedApiId, KErrNone, data); + + TRequestStatus reqStatus; + iMockLTSY.NotifyTerminated(reqStatus); + + + ASSERT_EQUALS(KErrNone, iSat.Open(iPhone)); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(KErrNone, reqStatus.Int()); + + CleanupStack::PopAndDestroy(&data); + } + +void CCTsySatFU::SetupEventListL(TUint8 aPCommandNumber, TUint8 aEvent) + { + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + //setup the expect for Mock LTSY from the RSat::NotifySetUpEventListPCmd call + //ETel -> CTSY -> LTSY + TUint8 pcmdCode = KSetUpEventList; + TMockLtsyData1 setUpEventListPCmdExpLtsyData(pcmdCode); + setUpEventListPCmdExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,data); + data.Close(); + + //create the Mock LTSY complete TLV data (a proactive command) + //LTSY -> CTSY + TTlv proactiveCmdTlv; + + proactiveCmdTlv.Begin(KBerTlvProactiveSimCommandTag); + + proactiveCmdTlv.AddTag(KTlvCommandDetailsTag); + proactiveCmdTlv.AddByte(aPCommandNumber);//ETLV_CommandNumber + proactiveCmdTlv.AddByte(KSetUpEventList); //ETLV_TypeOfCommand + proactiveCmdTlv.AddByte(0); //ETLV_CommandQualifier - RFU for Set up event list + + proactiveCmdTlv.AddTag(KTlvEventListTag); + proactiveCmdTlv.AddByte(aEvent); //ETLV_TypeOfCommand + + proactiveCmdTlv.AddTag(KTlvDeviceIdentityTag); + proactiveCmdTlv.AddByte(KSim); + proactiveCmdTlv.AddByte(KMe); + + TDesC8* tlvDscPtr = &const_cast(proactiveCmdTlv.End()); + TMockLtsyData1 tlvDscPack(tlvDscPtr); + tlvDscPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data); + data.Close(); + + //ETel Sat calls + RSat::TSetUpEventListV1 setUpEventList; + RSat::TSetUpEventListV1Pckg setUpEventListPckg(setUpEventList); + + iSat.NotifySetUpEventListPCmd(reqStatus,setUpEventListPckg); + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),KErrNone); + ASSERT_EQUALS(setUpEventList.iType,RSat::EUpdateEventList); + //Can't be asserted (easily) as some events the TSY is completly responsible for and iEvent is not set in the CTSY + //ASSERT_TRUE((setUpEventList.iEvents & RSat::KUserActivity) == RSat::KUserActivity) + ASSERT_EQUALS(setUpEventList.PCmdNumber(),aPCommandNumber); + + AssertMockLtsyStatusL(); + + //The Terminal response + RSat::TSetUpEventListRspV1 resp; + RSat::TSetUpEventListRspV1Pckg respPck(resp); + + resp.iGeneralResult = RSat::KSuccess; + resp.iInfoType = RSat::KNoAdditionalInfo; + resp.SetPCmdNumber(aPCommandNumber); + + GenerateAndWaitForTermRspL(aPCommandNumber,KSetUpEventList,0,RSat::ESetUpEventList,RSat::KSuccess,respPck,KErrNone); + + CleanupStack::PopAndDestroy(&data); + } + +void CCTsySatFU::SetupLocalInfoL(TUint16 aAreaCode, TUint16 aCellId, const TDesC8& aOperatorCode, TUint8 aLocationStatus) + { + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + ASSERT_TRUE(aOperatorCode.Length() <= KOperatorCodeLength); + + TDesC8* operatorCode = &const_cast(aOperatorCode); + + TMockLtsyData4localInfoPack(aLocationStatus,operatorCode,aAreaCode,aCellId); + localInfoPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatLocationStatusIndId, KErrNone, data); + + WaitForMockLTSYTerminated(); + + CleanupStack::PopAndDestroy(&data); + } + +void CCTsySatFU::WaitForEventDownloadL(RSat::TEventList aEventList, const TDesC8& aEventDownloadEnvelope) + { + + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + TDesC8* envelopePtr = &const_cast(aEventDownloadEnvelope); + + TMockLtsyData1 eventDownloadExpLtsyData(envelopePtr); + eventDownloadExpLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatEventDownloadEnvelope::KLtsyDispatchSatEventDownloadEnvelopeApiId,data); + data.Close(); + + switch(aEventList) + { + case RSat::KUserActivity: + { + //ETel calls event download + RSat::TEventDownloadBaseV2 eventDownload; + RSat::TEventDownloadBaseV2Pckg eventDownloadPck(eventDownload); + RSat::TEventList eventList = aEventList; + + iSat.EventDownload(reqStatus, eventList, eventDownloadPck); // No associated data + + AssertMockLtsyStatusL(); //RSat::EventDownload should consume the queue expect of KLtsyDispatchSatEventDownloadEnvelopeApiId IPC + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),KErrNone); + ASSERT_FALSE(eventDownload.iDataAvailable); + break; + } + case RSat::KAccessTechnologyChange: + case RSat::KLocationStatus: + case RSat::KCallConnected: + case RSat::KCallDisconnected: + case RSat::KMTCall: + { + //ETel notifiers not currently supported + WaitForMockLTSYTerminated(); + break; + } + } + + CleanupStack::PopAndDestroy(&data); + } + +/** + * Handles sending a terminal response, generating a "command completed successfully" additional info tlv + */ +void CCTsySatFU::GenerateAndWaitForTermRspL( TUint8 aPCmdNumber, + TUint8 aTypeOfCommand, + TUint8 aCommandQualifier, + RSat::TPCmd aRSatTypeOfCommand, + RSat::TPCmdResult aGeneralResult, + const TDesC8& aRsp, + TInt aCompError) + { + GenerateAndWaitForTermRspL(aPCmdNumber, aTypeOfCommand, aCommandQualifier, aRSatTypeOfCommand, aGeneralResult, KNullDesC8, aRsp, KNullDesC8,aCompError); + } + +/** + * Handles sending a terminal response, and takes as an argument a descriptor containing a tlv. This is to be used when a "command completed successfully" tlv + * is insufficient. + */ +void CCTsySatFU::GenerateAndWaitForTermRspL(TUint8 aPCmdNumber, + TUint8 aTypeOfCommand, + TUint8 aCommandQualifier, + RSat::TPCmd aRSatTypeOfCommand, + RSat::TPCmdResult aGeneralResult, + const TDesC8& aGeneralResultAddInfo, + const TDesC8& aRsp, + const TDesC8& aAdditionalInfo, + TInt aCompError) + { + RBuf8 data; + CleanupClosePushL(data); + + TRequestStatus reqStatus; + + RBuf8 terminalRsp; + CleanupClosePushL(terminalRsp); + terminalRsp.CreateL(KTlvMaxSize); + + GenerateTermRspTlv(terminalRsp, aPCmdNumber, aTypeOfCommand, aCommandQualifier, aGeneralResult, aGeneralResultAddInfo, aAdditionalInfo); + + TDesC8* terminalRspPtr = &terminalRsp; + + TMockLtsyData1 termRespData(terminalRspPtr); + termRespData.SerialiseL(data); + + iMockLTSY.ExpectL(MLtsyDispatchSatTerminalRsp::KLtsyDispatchSatTerminalRspApiId, data); + + if(aRsp != KNullDesC8) + { + //ETel generated Terminal response + iSat.TerminalRsp(reqStatus, aRSatTypeOfCommand, aRsp); + } + else + { + //CTSY generate Terminal response + iMockLTSY.NotifyTerminated(reqStatus); + } + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),KErrNone); + + iMockLTSY.NotifyTerminated(reqStatus); + + iMockLTSY.CompleteL(MLtsyDispatchSatTerminalRsp::KLtsyDispatchSatTerminalRspApiId, aCompError); + + User::WaitForRequest(reqStatus); + ASSERT_EQUALS(reqStatus.Int(),KErrNone); + + CleanupStack::PopAndDestroy(&terminalRsp); + CleanupStack::PopAndDestroy(&data); + } + +void CCTsySatFU::GenerateTermRspTlv( RBuf8& aBuf, + TUint8 aPCmdNumber, + TUint8 aTypeOfCommand, + TUint8 aCommandQualifier, + RSat::TPCmdResult aGeneralResult, + const TDesC8& aGeneralResultAddInfo, + const TDesC8& aAdditionalInfo) + { + TTlv tlv; + tlv.AddTag(KTlvCommandDetailsTag); + tlv.AddByte(aPCmdNumber);//ETLV_CommandNumber + tlv.AddByte(aTypeOfCommand); //ETLV_TypeOfCommand + tlv.AddByte(aCommandQualifier); //ETLV_CommandQualifier + + tlv.AddTag(KTlvDeviceIdentityTag); + tlv.AddByte(KMe); + tlv.AddByte(KSim); + + tlv.AddTag(KTlvResultTag); + tlv.AddByte(aGeneralResult); + tlv.AddData(aGeneralResultAddInfo); + + aBuf.Zero(); + aBuf.Append(tlv.GetDataWithoutTopLevelTag()); + aBuf.Append(aAdditionalInfo); + } + +void CCTsySatFU::RefreshNoTerminalRspL(TUint8 aPCmdNumber, TUint8 aCommandQualifier, TInt aRefreshAllowedCompleteResult) + { + RBuf8 data; + CleanupClosePushL(data); + + //this is an example of how a other interested parties can register for NotifyRefreshPCmd, + //this would be any other but the main SAT engine. + RSat satUser; + CleanupClosePushL(satUser); + satUser.Open(iPhone); + + //Expect a MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId when both + //notifiers are set (thus needs to be queued before we setup the two notifiers below) + TUint8 pcmdCode = KRefresh; + TMockLtsyData1 proactiveCmdNotificationsLtsyData(pcmdCode); + proactiveCmdNotificationsLtsyData.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId,data); + data.Close(); + + //Refresh Required client side notifier + //ETel -> CTSY + RSat::TRefreshV2 refreshRequired; + RSat::TRefreshV2Pckg refreshRequiredPckg(refreshRequired); + TRequestStatus refreshRequiredReqStatus; + iSat.NotifyRefreshRequired(refreshRequiredReqStatus,refreshRequiredPckg); + + //Refresh Proactive Command client side notifier + //ETel -> CTSY + //Not both have been set, this will trigger a HandlePCmdNotificationReqL() down to the LTSY + RSat::TRefreshV2 refreshPCmd; + RSat::TRefreshV2Pckg refreshPCmdPckg(refreshPCmd); + TRequestStatus refreshPCmdReqStatus; + iSat.NotifyRefreshPCmd(refreshPCmdReqStatus,refreshPCmdPckg); + + RSat::TRefreshV2 refreshPCmd2; + RSat::TRefreshV2Pckg refreshPCmdPckg2(refreshPCmd2); + TRequestStatus refreshPCmdReqStatus2; + satUser.NotifyRefreshPCmd(refreshPCmdReqStatus2,refreshPCmdPckg2); + + //the MLtsyDispatchSatPCmdNotification::KLtsyDispatchSatPCmdNotificationApiId expect should be gone + //so assert the LTSY status + AssertMockLtsyStatusL(); + + + TTlv proactiveCmdTlv; + + proactiveCmdTlv.Begin(KBerTlvProactiveSimCommandTag); + + proactiveCmdTlv.AddTag(KTlvCommandDetailsTag); + proactiveCmdTlv.AddByte(aPCmdNumber);//ETLV_CommandNumber + proactiveCmdTlv.AddByte(KRefresh); //ETLV_TypeOfCommand + proactiveCmdTlv.AddByte(aCommandQualifier); //ETLV_CommandQualifier + + proactiveCmdTlv.AddTag(KTlvDeviceIdentityTag); + proactiveCmdTlv.AddByte(KSim); + proactiveCmdTlv.AddByte(KMe); + + TUint numberOfFiles = 1; + proactiveCmdTlv.AddTag(KTlvFileListTag); + proactiveCmdTlv.AddByte(numberOfFiles); + //full paths to files (first byte identifies the type of file) + //master file + + const TInt KFilePathLength = 4; + TBuf8 filePath(KFilePathLength); + filePath[0] = 0x3F; + filePath[1] = 0x00; + filePath[2] = 0x2F; + filePath[3] = 0xE2; + + proactiveCmdTlv.AddData(filePath); + + _LIT8(KAid,"AID INFO"); //not correct format, just for test check "Application identifier as defined in TS 101 220 [31]" + proactiveCmdTlv.AddTag(KTlvAIDTag); + proactiveCmdTlv.AddData(KAid); + + + const TUint8 KTextAttributeTag = 0xC8; + proactiveCmdTlv.AddTag(KTextAttributeTag); + //text formatting + proactiveCmdTlv.AddByte(0x00); + proactiveCmdTlv.AddByte(0x00); + proactiveCmdTlv.AddByte(0x00); + proactiveCmdTlv.AddByte(0x00); + + + TDesC8* tlvDscPtr = &const_cast(proactiveCmdTlv.End()); + TMockLtsyData1 tlvDscPack(tlvDscPtr); + tlvDscPack.SerialiseL(data); + iMockLTSY.CompleteL(KMockLtsyDispatchSatPcmdIndId,KErrNone,data); + data.Close(); + + User::WaitForRequest(refreshRequiredReqStatus); + ASSERT_EQUALS(refreshRequiredReqStatus.Int(),KErrNone); + //ASSERT_EQUALS(refreshRequired.PCmdNumber(),aPCmdNumber); not set in the CTSY + ASSERT_TRUE(refreshRequired.iAid == KAid); + ASSERT_EQUALS(refreshRequired.iType,static_cast(aCommandQualifier + 1)); //+1 as RSat::TRefreshType 0x00 is ERefreshTypeNotSet + ASSERT_EQUALS(filePath[2],static_cast(refreshRequired.iFileList[0] >> KShiftBitsToGetMSB)); + ASSERT_EQUALS(filePath[3],static_cast(refreshRequired.iFileList[0] & 0xFF)); + + //no IPCs down to the LTSY should have occured, so we can AssertMockLtsyStatusL here. + AssertMockLtsyStatusL(); + + + //ESatTsyServiceRequest + TDesC8* aidPtr = const_cast(&KAid); + TDesC8* refreshFileListPtr = &filePath; + TUint16 cache = 0x01 | 0x02;//ECacheEFSST | ECacheEFCBMID; + TMockLtsyData3 refreshAllowedPack(refreshFileListPtr,aidPtr,cache); + refreshAllowedPack.SerialiseL(data); + iMockLTSY.ExpectL(MLtsyDispatchSatRefreshAllowed::KLtsyDispatchSatRefreshAllowedApiId,data,KErrNone); + data.Close(); + + RSat::TRefreshRspV1 refreshAllowedRsp; + refreshAllowedRsp.iGeneralResult = RSat::KSuccess; + refreshAllowedRsp.iInfoType = RSat::KNoAdditionalInfo; + refreshAllowedRsp.iAdditionalInfo = KNullDesC; + RSat::TRefreshRspV1Pckg refreshAllowedRspPckg(refreshAllowedRsp); + TRequestStatus refreshAllowedReqStatus; + iSat.RefreshAllowed(refreshAllowedReqStatus,refreshAllowedRspPckg); + User::WaitForRequest(refreshAllowedReqStatus); + ASSERT_EQUALS(refreshAllowedReqStatus.Int(),KErrNone); + + //the MLtsyDispatchSatRefreshAllowed::KLtsyDispatchSatRefreshAllowedApiId expect should be gone + //so assert the LTSY status + AssertMockLtsyStatusL(); + + + + //ESatTsyCompleteRefresh + //indicator to create complete the notifier + const TInt KResult = aRefreshAllowedCompleteResult; + iMockLTSY.CompleteL(MLtsyDispatchSatRefreshAllowed::KLtsyDispatchSatRefreshAllowedApiId,KResult); + + User::WaitForRequest(refreshPCmdReqStatus); + ASSERT_EQUALS(refreshPCmdReqStatus.Int(),KResult); + //ASSERT_EQUALS(refreshPCmd.PCmdNumber(),aPCmdNumber); not set in the CTSY + ASSERT_TRUE(refreshPCmd.iAid == KAid); + ASSERT_EQUALS(refreshPCmd.iType,static_cast(aCommandQualifier + 1)); //+1 as RSat::TRefreshType 0x00 is ERefreshTypeNotSet + ASSERT_EQUALS(filePath[2],static_cast(refreshPCmd.iFileList[0] >> KShiftBitsToGetMSB)); + ASSERT_EQUALS(filePath[3],static_cast(refreshPCmd.iFileList[0] & 0xFF)); + + User::WaitForRequest(refreshPCmdReqStatus2); + ASSERT_EQUALS(refreshPCmdReqStatus2.Int(),KResult); + //ASSERT_EQUALS(refreshPCmd2.PCmdNumber(),aPCmdNumber); not set in the CTSY + ASSERT_TRUE(refreshPCmd2.iAid == KAid); + ASSERT_EQUALS(refreshPCmd2.iType,static_cast(aCommandQualifier + 1)); //+1 as RSat::TRefreshType 0x00 is ERefreshTypeNotSet + ASSERT_EQUALS(filePath[2],static_cast(refreshPCmd2.iFileList[0] >> KShiftBitsToGetMSB)); + ASSERT_EQUALS(filePath[3],static_cast(refreshPCmd2.iFileList[0] & 0xFF)); + + CleanupStack::PopAndDestroy(&satUser); + CleanupStack::PopAndDestroy(&data); + } + +TUint8 CCTsySatFU::TonAndNpi(RMobilePhone::TMobileTON aTon, RMobilePhone::TMobileNPI aNpi) + { + return (0x80) | (aTon << 4) | (aNpi); + } + +void CCTsySatFU::DoCleanup() + { + + delete iCallContainer; + iCallContainer = NULL; + + iSat.Close(); + CCtsyComponentTestBase::DoCleanup(); + } + +CCTsySatFU::CCallTypeContainer::CCallTypeContainer() : + iCallControlPckg(iCallControl), + iSetUpCallPckg(iSetUpCall) + { + + } + + +